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.assertSame;
  13 import static org.mockito.Mockito.inOrder;
  14 import static org.mockito.Mockito.mock;
  15 import static org.mockito.Mockito.verify;
  16 import static org.mockito.Mockito.verifyNoMoreInteractions;
  17 import static org.mockito.Mockito.when;
  18
  19 import java.util.Map;
  20 import java.util.concurrent.Future;
  21
  22 import javax.ws.rs.core.Response.Status;
  23
  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.ResponseException;
  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=ResponseException.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() {
 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         RpcResult<CompositeNode> actualResult = brokerFacade.invokeRpc( qname, dataNode );
 138
 139         assertSame( "invokeRpc", expResult, actualResult );
 140     }
 141
 142     @Test(expected=ResponseException.class)
 143     public void testInvokeRpcWithException() {
 144         Exception mockEx = new Exception( "mock" );
 145         Future<RpcResult<CompositeNode>> future = Futures.immediateFailedFuture( mockEx );
 146         when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future );
 147
 148         brokerFacade.invokeRpc( qname, dataNode );
 149     }
 150
 151     @Test(expected=ResponseException.class)
 152     public void testInvokeRpcWithNoConsumerSession() {
 153         brokerFacade.setContext( null );
 154
 155         brokerFacade.invokeRpc( qname, dataNode );
 156     }
 157
 158     @Test
 159     public void testCommitConfigurationDataPut() {
 160         Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
 161
 162         when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
 163         mockTransaction.putConfigurationData( instanceID, dataNode );
 164         when( mockTransaction.commit() ).thenReturn( expFuture );
 165
 166         Future<RpcResult<TransactionStatus>> actualFuture =
 167                              brokerFacade.commitConfigurationDataPut( instanceID, dataNode );
 168
 169         assertSame( "invokeRpc", expFuture, actualFuture );
 170
 171         InOrder inOrder = inOrder( dataBroker, mockTransaction );
 172         inOrder.verify( dataBroker ).beginTransaction();
 173         inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
 174         inOrder.verify( mockTransaction ).commit();
 175     }
 176
 177     @Test
 178     public void testCommitConfigurationDataPutBehindMountPoint() {
 179         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
 180
 181         when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
 182         mockTransaction.putConfigurationData( instanceID, dataNode );
 183         when( mockTransaction.commit() ).thenReturn( expFuture );
 184
 185         Future<RpcResult<TransactionStatus>> actualFuture =
 186                  brokerFacade.commitConfigurationDataPutBehindMountPoint(
 187                                                        mockMountInstance, instanceID, dataNode );
 188
 189         assertSame( "invokeRpc", expFuture, actualFuture );
 190
 191         InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
 192         inOrder.verify( mockMountInstance ).beginTransaction();
 193         inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
 194         inOrder.verify( mockTransaction ).commit();
 195     }
 196
 197     @Test
 198     public void testCommitConfigurationDataPost() {
 199         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
 200
 201         Map<InstanceIdentifier, CompositeNode> nodeMap =
 202                 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
 203                                                              .put( instanceID, dataNode ).build();
 204
 205         when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
 206         mockTransaction.putConfigurationData( instanceID, dataNode );
 207         when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
 208         when( mockTransaction.commit() ).thenReturn( expFuture );
 209
 210         Future<RpcResult<TransactionStatus>> actualFuture =
 211                              brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
 212
 213         assertSame( "commitConfigurationDataPut", expFuture, actualFuture );
 214
 215         InOrder inOrder = inOrder( dataBroker, mockTransaction );
 216         inOrder.verify( dataBroker ).beginTransaction();
 217         inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
 218         inOrder.verify( mockTransaction ).commit();
 219     }
 220
 221     @Test(expected=ResponseException.class)
 222     public void testCommitConfigurationDataPostAlreadyExists() {
 223         when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
 224         mockTransaction.putConfigurationData( instanceID, dataNode );
 225         when ( mockTransaction.readConfigurationData( instanceID ) )
 226             .thenReturn( dataNode );
 227         try {
 228             brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
 229         } catch (ResponseException e) {
 230             assertEquals("Unexpect Exception Status -> "
 231                     + "http://tools.ietf.org/html/draft-bierman-netconf-restconf-03#page-48",
 232                     (e.getResponse().getStatus()), Status.CONFLICT.getStatusCode());
 233             throw e;
 234         }
 235     }
 236
 237     @Test
 238     public void testCommitConfigurationDataPostBehindMountPoint() {
 239         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
 240
 241         Map<InstanceIdentifier, CompositeNode> nodeMap =
 242                 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
 243                                                            .put( instanceID, dataNode ).build();
 244
 245         when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
 246         mockTransaction.putConfigurationData( instanceID, dataNode );
 247         when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
 248         when( mockTransaction.commit() ).thenReturn( expFuture );
 249
 250         Future<RpcResult<TransactionStatus>> actualFuture =
 251                 brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
 252                                                                           instanceID, dataNode );
 253
 254         assertSame( "commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture );
 255
 256         InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
 257         inOrder.verify( mockMountInstance ).beginTransaction();
 258         inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
 259         inOrder.verify( mockTransaction ).commit();
 260     }
 261
 262     @Test(expected=ResponseException.class)
 263     public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() {
 264
 265         when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
 266         mockTransaction.putConfigurationData( instanceID, dataNode );
 267         when ( mockTransaction.readConfigurationData( instanceID ) )
 268             .thenReturn( dataNode );
 269         try {
 270             brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
 271                     instanceID, dataNode );
 272         } catch (ResponseException e) {
 273             assertEquals("Unexpect Exception Status -> "
 274                     + "http://tools.ietf.org/html/draft-bierman-netconf-restconf-03#page-48",
 275                     e.getResponse().getStatus(), Status.CONFLICT.getStatusCode());
 276             throw e;
 277         }
 278     }
 279
 280     @Test
 281     public void testCommitConfigurationDataDelete() {
 282         Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
 283
 284         when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
 285         mockTransaction.removeConfigurationData( instanceID );
 286         when( mockTransaction.commit() ).thenReturn( expFuture );
 287
 288         Future<RpcResult<TransactionStatus>> actualFuture =
 289                              brokerFacade.commitConfigurationDataDelete( instanceID );
 290
 291         assertSame( "commitConfigurationDataDelete", expFuture, actualFuture );
 292
 293         InOrder inOrder = inOrder( dataBroker, mockTransaction );
 294         inOrder.verify( dataBroker ).beginTransaction();
 295         inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
 296         inOrder.verify( mockTransaction ).commit();
 297     }
 298
 299     @Test
 300     public void testCommitConfigurationDataDeleteBehindMountPoint() {
 301         Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
 302
 303         when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
 304         mockTransaction.removeConfigurationData( instanceID );
 305         when( mockTransaction.commit() ).thenReturn( expFuture );
 306
 307         Future<RpcResult<TransactionStatus>> actualFuture =
 308                              brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
 309                                                               mockMountInstance, instanceID );
 310
 311         assertSame( "commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture );
 312
 313         InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
 314         inOrder.verify( mockMountInstance ).beginTransaction();
 315         inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
 316         inOrder.verify( mockTransaction ).commit();
 317     }
 318
 319     @SuppressWarnings("unchecked")
 320     @Test
 321     public void testRegisterToListenDataChanges() {
 322         ListenerAdapter listener = Notificator.createListener( instanceID, "stream" );
 323
 324         ListenerRegistration<DataChangeListener> mockRegistration = mock( ListenerRegistration.class );
 325         when( dataBroker.registerDataChangeListener( instanceID, listener ) )
 326             .thenReturn( mockRegistration );
 327
 328         brokerFacade.registerToListenDataChanges( listener );
 329
 330         verify( dataBroker ).registerDataChangeListener( instanceID, listener );
 331
 332         assertEquals( "isListening", true, listener.isListening() );
 333
 334         brokerFacade.registerToListenDataChanges( listener );
 335         verifyNoMoreInteractions( dataBroker );
 336     }
 337 }