X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-rest-connector%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Frestconf%2Fimpl%2Ftest%2FBrokerFacadeTest.java;h=656427352aea0da2242910ba5a274b1d500e63f2;hp=19ca812f8e9a90c1aad698be0df347b2b651b26f;hb=73c9fecf86aad02761df47fe0cc943af4ea1f2bc;hpb=d23028f7c3fab3536de6049ef3ecddee324f6567

diff --git a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/BrokerFacadeTest.java b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/BrokerFacadeTest.java
index 19ca812f8e..656427352a 100644
--- a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/BrokerFacadeTest.java
+++ b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/BrokerFacadeTest.java
@@ -7,6 +7,7 @@
  */
 
 package org.opendaylight.controller.sal.restconf.impl.test;
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
@@ -66,268 +67,252 @@ public class BrokerFacadeTest {
 
     BrokerFacade brokerFacade = BrokerFacade.getInstance();
 
-    CompositeNode dataNode = TestUtils.readInputToCnSn( "/parts/ietf-interfaces_interfaces.xml",
-                                                        XmlToCompositeNodeProvider.INSTANCE );
+    CompositeNode dataNode = TestUtils.readInputToCnSn("/parts/ietf-interfaces_interfaces.xml",
+            XmlToCompositeNodeProvider.INSTANCE);
 
-    QName qname = QName.create( "node" );
+    QName qname = QName.create("node");
 
-    InstanceIdentifier instanceID = InstanceIdentifier.builder().node( qname ).toInstance();
+    InstanceIdentifier instanceID = InstanceIdentifier.builder().node(qname).toInstance();
 
     @Before
     public void setUp() throws Exception {
-        MockitoAnnotations.initMocks( this );
+        MockitoAnnotations.initMocks(this);
 
-        brokerFacade.setDataService( dataBroker );
-        brokerFacade.setContext( mockConsumerSession );
+        brokerFacade.setDataService(dataBroker);
+        brokerFacade.setContext(mockConsumerSession);
     }
 
     @Test
     public void testReadConfigurationData() {
-        when( dataBroker.readConfigurationData( instanceID ) ).thenReturn( dataNode );
+        when(dataBroker.readConfigurationData(instanceID)).thenReturn(dataNode);
 
-        CompositeNode actualNode = brokerFacade.readConfigurationData( instanceID );
+        CompositeNode actualNode = brokerFacade.readConfigurationData(instanceID);
 
-        assertSame( "readConfigurationData", dataNode, actualNode );
+        assertSame("readConfigurationData", dataNode, actualNode);
     }
 
     @Test
     public void testReadConfigurationDataBehindMountPoint() {
-        when( mockMountInstance.readConfigurationData( instanceID ) ).thenReturn( dataNode );
+        when(mockMountInstance.readConfigurationData(instanceID)).thenReturn(dataNode);
 
-        CompositeNode actualNode = brokerFacade.readConfigurationDataBehindMountPoint(
-                                                                              mockMountInstance, instanceID );
+        CompositeNode actualNode = brokerFacade.readConfigurationDataBehindMountPoint(mockMountInstance, instanceID);
 
-        assertSame( "readConfigurationDataBehindMountPoint", dataNode, actualNode );
+        assertSame("readConfigurationDataBehindMountPoint", dataNode, actualNode);
     }
 
     @Test
     public void testReadOperationalData() {
-        when( dataBroker.readOperationalData( instanceID ) ).thenReturn( dataNode );
+        when(dataBroker.readOperationalData(instanceID)).thenReturn(dataNode);
 
-        CompositeNode actualNode = brokerFacade.readOperationalData( instanceID );
+        CompositeNode actualNode = brokerFacade.readOperationalData(instanceID);
 
-        assertSame( "readOperationalData", dataNode, actualNode );
+        assertSame("readOperationalData", dataNode, actualNode);
     }
 
     @Test
     public void testReadOperationalDataBehindMountPoint() {
-        when( mockMountInstance.readOperationalData( instanceID ) ).thenReturn( dataNode );
+        when(mockMountInstance.readOperationalData(instanceID)).thenReturn(dataNode);
 
-        CompositeNode actualNode = brokerFacade.readOperationalDataBehindMountPoint(
-                                                                              mockMountInstance, instanceID );
+        CompositeNode actualNode = brokerFacade.readOperationalDataBehindMountPoint(mockMountInstance, instanceID);
 
-        assertSame( "readOperationalDataBehindMountPoint", dataNode, actualNode );
+        assertSame("readOperationalDataBehindMountPoint", dataNode, actualNode);
     }
 
-    @Test(expected=RestconfDocumentedException.class)
+    @Test(expected = RestconfDocumentedException.class)
     public void testReadOperationalDataWithNoDataBroker() {
-        brokerFacade.setDataService( null );
+        brokerFacade.setDataService(null);
 
-        brokerFacade.readOperationalData( instanceID );
+        brokerFacade.readOperationalData(instanceID);
     }
 
     @SuppressWarnings("unchecked")
     @Test
     public void testInvokeRpc() throws Exception {
-        RpcResult<CompositeNode> expResult = mock( RpcResult.class );
-        Future<RpcResult<CompositeNode>> future = Futures.immediateFuture( expResult );
-        when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future );
+        RpcResult<CompositeNode> expResult = mock(RpcResult.class);
+        Future<RpcResult<CompositeNode>> future = Futures.immediateFuture(expResult);
+        when(mockConsumerSession.rpc(qname, dataNode)).thenReturn(future);
 
-        Future<RpcResult<CompositeNode>> actualFuture = brokerFacade.invokeRpc( qname, dataNode );
-        assertNotNull( "Future is null", actualFuture );
+        Future<RpcResult<CompositeNode>> actualFuture = brokerFacade.invokeRpc(qname, dataNode);
+        assertNotNull("Future is null", actualFuture);
         RpcResult<CompositeNode> actualResult = actualFuture.get();
 
-        assertSame( "invokeRpc", expResult, actualResult );
+        assertSame("invokeRpc", expResult, actualResult);
     }
 
-    @Test(expected=RestconfDocumentedException.class)
+    @Test(expected = RestconfDocumentedException.class)
     public void testInvokeRpcWithNoConsumerSession() {
-        brokerFacade.setContext( null );
+        brokerFacade.setContext(null);
 
-        brokerFacade.invokeRpc( qname, dataNode );
+        brokerFacade.invokeRpc(qname, dataNode);
     }
 
     @Test
     public void testCommitConfigurationDataPut() {
-        Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
+        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 
-        when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
-        mockTransaction.putConfigurationData( instanceID, dataNode );
-        when( mockTransaction.commit() ).thenReturn( expFuture );
+        when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
+        mockTransaction.putConfigurationData(instanceID, dataNode);
+        when(mockTransaction.commit()).thenReturn(expFuture);
 
-        Future<RpcResult<TransactionStatus>> actualFuture =
-                             brokerFacade.commitConfigurationDataPut( instanceID, dataNode );
+        Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPut(instanceID,
+                dataNode);
 
-        assertSame( "invokeRpc", expFuture, actualFuture );
+        assertSame("invokeRpc", expFuture, actualFuture);
 
-        InOrder inOrder = inOrder( dataBroker, mockTransaction );
-        inOrder.verify( dataBroker ).beginTransaction();
-        inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
-        inOrder.verify( mockTransaction ).commit();
+        InOrder inOrder = inOrder(dataBroker, mockTransaction);
+        inOrder.verify(dataBroker).beginTransaction();
+        inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
+        inOrder.verify(mockTransaction).commit();
     }
 
     @Test
     public void testCommitConfigurationDataPutBehindMountPoint() {
-        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
+        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 
-        when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
-        mockTransaction.putConfigurationData( instanceID, dataNode );
-        when( mockTransaction.commit() ).thenReturn( expFuture );
+        when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
+        mockTransaction.putConfigurationData(instanceID, dataNode);
+        when(mockTransaction.commit()).thenReturn(expFuture);
 
-        Future<RpcResult<TransactionStatus>> actualFuture =
-                 brokerFacade.commitConfigurationDataPutBehindMountPoint(
-                                                       mockMountInstance, instanceID, dataNode );
+        Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPutBehindMountPoint(
+                mockMountInstance, instanceID, dataNode);
 
-        assertSame( "invokeRpc", expFuture, actualFuture );
+        assertSame("invokeRpc", expFuture, actualFuture);
 
-        InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
-        inOrder.verify( mockMountInstance ).beginTransaction();
-        inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
-        inOrder.verify( mockTransaction ).commit();
+        InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
+        inOrder.verify(mockMountInstance).beginTransaction();
+        inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
+        inOrder.verify(mockTransaction).commit();
     }
 
     @Test
     public void testCommitConfigurationDataPost() {
-        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
+        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 
-        Map<InstanceIdentifier, CompositeNode> nodeMap =
-                new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
-                                                             .put( instanceID, dataNode ).build();
+        Map<InstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<InstanceIdentifier, CompositeNode>()
+                .put(instanceID, dataNode).build();
 
-        when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
-        mockTransaction.putConfigurationData( instanceID, dataNode );
-        when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
-        when( mockTransaction.commit() ).thenReturn( expFuture );
+        when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
+        mockTransaction.putConfigurationData(instanceID, dataNode);
+        when(mockTransaction.getCreatedConfigurationData()).thenReturn(nodeMap);
+        when(mockTransaction.commit()).thenReturn(expFuture);
 
-        Future<RpcResult<TransactionStatus>> actualFuture =
-                             brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
+        Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPost(instanceID,
+                dataNode);
 
-        assertSame( "commitConfigurationDataPut", expFuture, actualFuture );
+        assertSame("commitConfigurationDataPut", expFuture, actualFuture);
 
-        InOrder inOrder = inOrder( dataBroker, mockTransaction );
-        inOrder.verify( dataBroker ).beginTransaction();
-        inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
-        inOrder.verify( mockTransaction ).commit();
+        InOrder inOrder = inOrder(dataBroker, mockTransaction);
+        inOrder.verify(dataBroker).beginTransaction();
+        inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
+        inOrder.verify(mockTransaction).commit();
     }
 
-    @Test(expected=RestconfDocumentedException.class)
+    @Test(expected = RestconfDocumentedException.class)
     public void testCommitConfigurationDataPostAlreadyExists() {
-        when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
-        mockTransaction.putConfigurationData( instanceID, dataNode );
-        when ( mockTransaction.readConfigurationData( instanceID ) )
-            .thenReturn( dataNode );
+        when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
+        mockTransaction.putConfigurationData(instanceID, dataNode);
+        when(mockTransaction.readConfigurationData(instanceID)).thenReturn(dataNode);
         try {
-            brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
-        }
-        catch (RestconfDocumentedException e) {
-            assertEquals("getErrorTag",
-                    RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag());
+            brokerFacade.commitConfigurationDataPost(instanceID, dataNode);
+        } catch (RestconfDocumentedException e) {
+            assertEquals("getErrorTag", RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag());
             throw e;
         }
     }
 
     @Test
     public void testCommitConfigurationDataPostBehindMountPoint() {
-        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
+        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 
-        Map<InstanceIdentifier, CompositeNode> nodeMap =
-                new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
-                                                           .put( instanceID, dataNode ).build();
+        Map<InstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<InstanceIdentifier, CompositeNode>()
+                .put(instanceID, dataNode).build();
 
-        when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
-        mockTransaction.putConfigurationData( instanceID, dataNode );
-        when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
-        when( mockTransaction.commit() ).thenReturn( expFuture );
+        when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
+        mockTransaction.putConfigurationData(instanceID, dataNode);
+        when(mockTransaction.getCreatedConfigurationData()).thenReturn(nodeMap);
+        when(mockTransaction.commit()).thenReturn(expFuture);
 
-        Future<RpcResult<TransactionStatus>> actualFuture =
-                brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
-                                                                          instanceID, dataNode );
+        Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPostBehindMountPoint(
+                mockMountInstance, instanceID, dataNode);
 
-        assertSame( "commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture );
+        assertSame("commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture);
 
-        InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
-        inOrder.verify( mockMountInstance ).beginTransaction();
-        inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
-        inOrder.verify( mockTransaction ).commit();
+        InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
+        inOrder.verify(mockMountInstance).beginTransaction();
+        inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
+        inOrder.verify(mockTransaction).commit();
     }
 
-    @Test(expected=RestconfDocumentedException.class)
+    @Test(expected = RestconfDocumentedException.class)
     public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() {
 
-        when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
-        mockTransaction.putConfigurationData( instanceID, dataNode );
-        when ( mockTransaction.readConfigurationData( instanceID ) )
-            .thenReturn( dataNode );
+        when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
+        mockTransaction.putConfigurationData(instanceID, dataNode);
+        when(mockTransaction.readConfigurationData(instanceID)).thenReturn(dataNode);
         try {
-            brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
-                    instanceID, dataNode );
-        }
-        catch (RestconfDocumentedException e) {
-            assertEquals("getErrorTag",
-                    RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag());
+            brokerFacade.commitConfigurationDataPostBehindMountPoint(mockMountInstance, instanceID, dataNode);
+        } catch (RestconfDocumentedException e) {
+            assertEquals("getErrorTag", RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag());
             throw e;
         }
     }
 
     @Test
     public void testCommitConfigurationDataDelete() {
-        Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
+        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 
-        when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
+        when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
         when(mockTransaction.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(
                 ImmutableCompositeNode.builder().toInstance());
-        mockTransaction.removeConfigurationData( instanceID );
-        when( mockTransaction.commit() ).thenReturn( expFuture );
+        mockTransaction.removeConfigurationData(instanceID);
+        when(mockTransaction.commit()).thenReturn(expFuture);
 
-        Future<RpcResult<TransactionStatus>> actualFuture =
-                             brokerFacade.commitConfigurationDataDelete( instanceID );
+        Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataDelete(instanceID);
 
-        assertSame( "commitConfigurationDataDelete", expFuture, actualFuture );
+        assertSame("commitConfigurationDataDelete", expFuture, actualFuture);
 
-        InOrder inOrder = inOrder( dataBroker, mockTransaction );
-        inOrder.verify( dataBroker ).beginTransaction();
-        inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
-        inOrder.verify( mockTransaction ).commit();
+        InOrder inOrder = inOrder(dataBroker, mockTransaction);
+        inOrder.verify(dataBroker).beginTransaction();
+        inOrder.verify(mockTransaction).removeConfigurationData(instanceID);
+        inOrder.verify(mockTransaction).commit();
     }
 
     @Test
     public void testCommitConfigurationDataDeleteBehindMountPoint() {
-        Future<RpcResult<TransactionStatus>> expFuture =  Futures.immediateFuture( null );
+        Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 
-        when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
+        when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
         when(mockTransaction.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(
                 ImmutableCompositeNode.builder().toInstance());
-        mockTransaction.removeConfigurationData( instanceID );
-        when( mockTransaction.commit() ).thenReturn( expFuture );
+        mockTransaction.removeConfigurationData(instanceID);
+        when(mockTransaction.commit()).thenReturn(expFuture);
 
-        Future<RpcResult<TransactionStatus>> actualFuture =
-                             brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
-                                                              mockMountInstance, instanceID );
+        Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
+                mockMountInstance, instanceID);
 
-        assertSame( "commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture );
+        assertSame("commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture);
 
-        InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
-        inOrder.verify( mockMountInstance ).beginTransaction();
-        inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
-        inOrder.verify( mockTransaction ).commit();
+        InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
+        inOrder.verify(mockMountInstance).beginTransaction();
+        inOrder.verify(mockTransaction).removeConfigurationData(instanceID);
+        inOrder.verify(mockTransaction).commit();
     }
 
     @SuppressWarnings("unchecked")
     @Test
     public void testRegisterToListenDataChanges() {
-        ListenerAdapter listener = Notificator.createListener( instanceID, "stream" );
+        ListenerAdapter listener = Notificator.createListener(instanceID, "stream");
 
-        ListenerRegistration<DataChangeListener> mockRegistration = mock( ListenerRegistration.class );
-        when( dataBroker.registerDataChangeListener( instanceID, listener ) )
-            .thenReturn( mockRegistration );
+        ListenerRegistration<DataChangeListener> mockRegistration = mock(ListenerRegistration.class);
+        when(dataBroker.registerDataChangeListener(instanceID, listener)).thenReturn(mockRegistration);
 
-        brokerFacade.registerToListenDataChanges( listener );
+        brokerFacade.registerToListenDataChanges(listener);
 
-        verify( dataBroker ).registerDataChangeListener( instanceID, listener );
+        verify(dataBroker).registerDataChangeListener(instanceID, listener);
 
-        assertEquals( "isListening", true, listener.isListening() );
+        assertEquals("isListening", true, listener.isListening());
 
-        brokerFacade.registerToListenDataChanges( listener );
-        verifyNoMoreInteractions( dataBroker );
+        brokerFacade.registerToListenDataChanges(listener);
+        verifyNoMoreInteractions(dataBroker);
     }
 }