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