opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/BrokerFacadeTest.java

   1 /*
   2  * Copyright (c) ${year} Brocade Communications Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.sal.restconf.impl.test;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertSame;
  14 import static org.mockito.Mockito.inOrder;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.verify;
  17 import static org.mockito.Mockito.verifyNoMoreInteractions;
  18 import static org.mockito.Mockito.when;
  19
  20 import java.util.Map;
  21 import java.util.concurrent.Future;
  22
  23 import org.junit.Before;
  24 import org.junit.Test;
  25 import org.mockito.InOrder;
  26 import org.mockito.Mock;
  27 import org.mockito.MockitoAnnotations;
  28 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  29 import org.opendaylight.controller.sal.core.api.Broker.ConsumerSession;
  30 import org.opendaylight.controller.sal.core.api.data.DataBrokerService;
  31 import org.opendaylight.controller.sal.core.api.data.DataChangeListener;
  32 import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
  33 import org.opendaylight.controller.sal.core.api.mount.MountInstance;
  34 import org.opendaylight.controller.sal.rest.impl.XmlToCompositeNodeProvider;
  35 import org.opendaylight.controller.sal.restconf.impl.BrokerFacade;
  36 import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
  37 import org.opendaylight.controller.sal.restconf.impl.RestconfError;
  38 import org.opendaylight.controller.sal.streams.listeners.ListenerAdapter;
  39 import org.opendaylight.controller.sal.streams.listeners.Notificator;
  40 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  41 import org.opendaylight.yangtools.yang.common.QName;
  42 import org.opendaylight.yangtools.yang.common.RpcResult;
  43 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  44 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  45
  46 import com.google.common.collect.ImmutableMap;
  47 import com.google.common.util.concurrent.Futures;
  48
  49 /**
  50  * Unit tests for BrokerFacade.
  51  *
  52  * @author Thomas Pantelis
  53  */
  54 public class BrokerFacadeTest {
  55
  56     @Mock
  57     DataBrokerService dataBroker;
  58
  59     @Mock
  60     DataModificationTransaction mockTransaction;
  61
  62     @Mock
  63     ConsumerSession mockConsumerSession;
  64
  65     @Mock
  66     MountInstance mockMountInstance;
  67
  68     BrokerFacade brokerFacade = BrokerFacade.getInstance();
  69
  70     CompositeNode dataNode = TestUtils.readInputToCnSn( "/parts/ietf-interfaces_interfaces.xml",
  71                                                         XmlToCompositeNodeProvider.INSTANCE );
  72
  73     QName qname = QName.create( "node" );
  74
  75     InstanceIdentifier instanceID = InstanceIdentifier.builder().node( qname ).toInstance();
  76
  77     @Before
  78     public void setUp() throws Exception {
  79         MockitoAnnotations.initMocks( this );
  80
  81         brokerFacade.setDataService( dataBroker );
  82         brokerFacade.setContext( mockConsumerSession );
  83     }
  84
  85     @Test
  86     public void testReadConfigurationData() {
  87         when( dataBroker.readConfigurationData( instanceID ) ).thenReturn( dataNode );
  88
  89         CompositeNode actualNode = brokerFacade.readConfigurationData( instanceID );
  90
  91         assertSame( "readConfigurationData", dataNode, actualNode );
  92     }
  93
  94     @Test
  95     public void testReadConfigurationDataBehindMountPoint() {
  96         when( mockMountInstance.readConfigurationData( instanceID ) ).thenReturn( dataNode );
  97
  98         CompositeNode actualNode = brokerFacade.readConfigurationDataBehindMountPoint(
  99                                                                               mockMountInstance, instanceID );
 100
 101         assertSame( "readConfigurationDataBehindMountPoint", dataNode, actualNode );
 102     }
 103
 104     @Test
 105     public void testReadOperationalData() {
 106         when( dataBroker.readOperationalData( instanceID ) ).thenReturn( dataNode );
 107
 108         CompositeNode actualNode = brokerFacade.readOperationalData( instanceID );
 109
 110         assertSame( "readOperationalData", dataNode, actualNode );
 111     }
 112
 113     @Test
 114     public void testReadOperationalDataBehindMountPoint() {
 115         when( mockMountInstance.readOperationalData( instanceID ) ).thenReturn( dataNode );
 116
 117         CompositeNode actualNode = brokerFacade.readOperationalDataBehindMountPoint(
 118                                                                               mockMountInstance, instanceID );
 119
 120         assertSame( "readOperationalDataBehindMountPoint", dataNode, actualNode );
 121     }
 122
 123     @Test(expected=RestconfDocumentedException.class)
 124     public void testReadOperationalDataWithNoDataBroker() {
 125         brokerFacade.setDataService( null );
 126
 127         brokerFacade.readOperationalData( instanceID );
 128     }
 129
 130     @SuppressWarnings("unchecked")
 131     @Test
 132     public void testInvokeRpc() throws Exception {
 133         RpcResult<CompositeNode> expResult = mock( RpcResult.class );
 134         Future<RpcResult<CompositeNode>> future = Futures.immediateFuture( expResult );
 135         when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future );
 136
 137         Future<RpcResult<CompositeNode>> actualFuture = brokerFacade.invokeRpc( qname, dataNode );
 138         assertNotNull( "Future is null", actualFuture );
 139         RpcResult<CompositeNode> actualResult = actualFuture.get();
 140
 141         assertSame( "invokeRpc", expResult, actualResult );
 142     }
 143
 144     @Test(expected=RestconfDocumentedException.class)
 145     public void testInvokeRpcWithNoConsumerSession() {
 146         brokerFacade.setContext( null );
 147
 148         brokerFacade.invokeRpc( qname, dataNode );
 149     }
 150
 151     @Test
 152     public void testCommitConfigurationDataPut() {
 153         Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
 154
 155         when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
 156         mockTransaction.putConfigurationData( instanceID, dataNode );
 157         when( mockTransaction.commit() ).thenReturn( expFuture );
 158
 159         Future<RpcResult<TransactionStatus>> actualFuture =
 160                              brokerFacade.commitConfigurationDataPut( instanceID, dataNode );
 161
 162         assertSame( "invokeRpc", expFuture, actualFuture );
 163
 164         InOrder inOrder = inOrder( dataBroker, mockTransaction );
 165         inOrder.verify( dataBroker ).beginTransaction();
 166         inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
 167         inOrder.verify( mockTransaction ).commit();
 168     }
 169
 170     @Test
 171     public void testCommitConfigurationDataPutBehindMountPoint() {
 172         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
 173
 174         when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
 175         mockTransaction.putConfigurationData( instanceID, dataNode );
 176         when( mockTransaction.commit() ).thenReturn( expFuture );
 177
 178         Future<RpcResult<TransactionStatus>> actualFuture =
 179                  brokerFacade.commitConfigurationDataPutBehindMountPoint(
 180                                                        mockMountInstance, instanceID, dataNode );
 181
 182         assertSame( "invokeRpc", expFuture, actualFuture );
 183
 184         InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
 185         inOrder.verify( mockMountInstance ).beginTransaction();
 186         inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
 187         inOrder.verify( mockTransaction ).commit();
 188     }
 189
 190     @Test
 191     public void testCommitConfigurationDataPost() {
 192         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
 193
 194         Map<InstanceIdentifier, CompositeNode> nodeMap =
 195                 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
 196                                                              .put( instanceID, dataNode ).build();
 197
 198         when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
 199         mockTransaction.putConfigurationData( instanceID, dataNode );
 200         when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
 201         when( mockTransaction.commit() ).thenReturn( expFuture );
 202
 203         Future<RpcResult<TransactionStatus>> actualFuture =
 204                              brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
 205
 206         assertSame( "commitConfigurationDataPut", expFuture, actualFuture );
 207
 208         InOrder inOrder = inOrder( dataBroker, mockTransaction );
 209         inOrder.verify( dataBroker ).beginTransaction();
 210         inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
 211         inOrder.verify( mockTransaction ).commit();
 212     }
 213
 214     @Test(expected=RestconfDocumentedException.class)
 215     public void testCommitConfigurationDataPostAlreadyExists() {
 216         when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
 217         mockTransaction.putConfigurationData( instanceID, dataNode );
 218         when ( mockTransaction.readConfigurationData( instanceID ) )
 219             .thenReturn( dataNode );
 220         try {
 221             brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
 222         }
 223         catch (RestconfDocumentedException e) {
 224             assertEquals("getErrorTag",
 225                     RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag());
 226             throw e;
 227         }
 228     }
 229
 230     @Test
 231     public void testCommitConfigurationDataPostBehindMountPoint() {
 232         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
 233
 234         Map<InstanceIdentifier, CompositeNode> nodeMap =
 235                 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
 236                                                            .put( instanceID, dataNode ).build();
 237
 238         when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
 239         mockTransaction.putConfigurationData( instanceID, dataNode );
 240         when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
 241         when( mockTransaction.commit() ).thenReturn( expFuture );
 242
 243         Future<RpcResult<TransactionStatus>> actualFuture =
 244                 brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
 245                                                                           instanceID, dataNode );
 246
 247         assertSame( "commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture );
 248
 249         InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
 250         inOrder.verify( mockMountInstance ).beginTransaction();
 251         inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
 252         inOrder.verify( mockTransaction ).commit();
 253     }
 254
 255     @Test(expected=RestconfDocumentedException.class)
 256     public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() {
 257
 258         when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
 259         mockTransaction.putConfigurationData( instanceID, dataNode );
 260         when ( mockTransaction.readConfigurationData( instanceID ) )
 261             .thenReturn( dataNode );
 262         try {
 263             brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
 264                     instanceID, dataNode );
 265         }
 266         catch (RestconfDocumentedException e) {
 267             assertEquals("getErrorTag",
 268                     RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag());
 269             throw e;
 270         }
 271     }
 272
 273     @Test
 274     public void testCommitConfigurationDataDelete() {
 275         Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
 276
 277         when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
 278         mockTransaction.removeConfigurationData( instanceID );
 279         when( mockTransaction.commit() ).thenReturn( expFuture );
 280
 281         Future<RpcResult<TransactionStatus>> actualFuture =
 282                              brokerFacade.commitConfigurationDataDelete( instanceID );
 283
 284         assertSame( "commitConfigurationDataDelete", expFuture, actualFuture );
 285
 286         InOrder inOrder = inOrder( dataBroker, mockTransaction );
 287         inOrder.verify( dataBroker ).beginTransaction();
 288         inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
 289         inOrder.verify( mockTransaction ).commit();
 290     }
 291
 292     @Test
 293     public void testCommitConfigurationDataDeleteBehindMountPoint() {
 294         Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
 295
 296         when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
 297         mockTransaction.removeConfigurationData( instanceID );
 298         when( mockTransaction.commit() ).thenReturn( expFuture );
 299
 300         Future<RpcResult<TransactionStatus>> actualFuture =
 301                              brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
 302                                                               mockMountInstance, instanceID );
 303
 304         assertSame( "commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture );
 305
 306         InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
 307         inOrder.verify( mockMountInstance ).beginTransaction();
 308         inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
 309         inOrder.verify( mockTransaction ).commit();
 310     }
 311
 312     @SuppressWarnings("unchecked")
 313     @Test
 314     public void testRegisterToListenDataChanges() {
 315         ListenerAdapter listener = Notificator.createListener( instanceID, "stream" );
 316
 317         ListenerRegistration<DataChangeListener> mockRegistration = mock( ListenerRegistration.class );
 318         when( dataBroker.registerDataChangeListener( instanceID, listener ) )
 319             .thenReturn( mockRegistration );
 320
 321         brokerFacade.registerToListenDataChanges( listener );
 322
 323         verify( dataBroker ).registerDataChangeListener( instanceID, listener );
 324
 325         assertEquals( "isListening", true, listener.isListening() );
 326
 327         brokerFacade.registerToListenDataChanges( listener );
 328         verifyNoMoreInteractions( dataBroker );
 329     }
 330 }