X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-rest-connector%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Frestconf%2Fimpl%2Ftest%2FBrokerFacadeTest.java;h=e50c07e05aef735b1adb2568981f2354718a64af;hb=48daeb11697dbb83f554b64fe8702e21de3e0a12;hp=ddab7004408f4d60aa3e89f8660f8aa9749bce7b;hpb=26da3c2a206a753356b507b018052cbb9cccca7d;p=controller.git 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 ddab700440..e50c07e05a 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 @@ -11,27 +11,35 @@ 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; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -import java.util.Map; +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; import java.util.concurrent.Future; - +import org.apache.commons.lang.StringEscapeUtils; import org.junit.Before; import org.junit.Test; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.opendaylight.controller.md.sal.common.api.TransactionStatus; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; +import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint; import org.opendaylight.controller.sal.core.api.Broker.ConsumerSession; -import org.opendaylight.controller.sal.core.api.data.DataBrokerService; -import org.opendaylight.controller.sal.core.api.data.DataChangeListener; -import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction; -import org.opendaylight.controller.sal.core.api.mount.MountInstance; -import org.opendaylight.controller.sal.rest.impl.XmlToCompositeNodeProvider; import org.opendaylight.controller.sal.restconf.impl.BrokerFacade; import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException; import org.opendaylight.controller.sal.restconf.impl.RestconfError; @@ -41,10 +49,10 @@ import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; - -import com.google.common.collect.ImmutableMap; -import com.google.common.util.concurrent.Futures; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.impl.schema.Builders; /** * Unit tests for BrokerFacade. @@ -54,277 +62,195 @@ import com.google.common.util.concurrent.Futures; public class BrokerFacadeTest { @Mock - DataBrokerService dataBroker; - - @Mock - DataModificationTransaction mockTransaction; + DOMDataBroker domDataBroker; @Mock ConsumerSession mockConsumerSession; @Mock - MountInstance mockMountInstance; + DOMMountPoint mockMountInstance; BrokerFacade brokerFacade = BrokerFacade.getInstance(); - CompositeNode dataNode = TestUtils.readInputToCnSn( "/parts/ietf-interfaces_interfaces.xml", - XmlToCompositeNodeProvider.INSTANCE ); + CompositeNode dataNode; - QName qname = QName.create( "node" ); + NormalizedNode dummyNode = createDummyNode("dummy:namespace", "2014-07-01", "dummy local name"); + ListenableFuture>> dummyNodeInFuture = wrapDummyNode(dummyNode); - InstanceIdentifier instanceID = InstanceIdentifier.builder().node( qname ).toInstance(); + QName qname = QName.create("node"); - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks( this ); + YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).toInstance(); - brokerFacade.setDataService( dataBroker ); - brokerFacade.setContext( mockConsumerSession ); - } + @Mock + DOMDataReadOnlyTransaction rTransaction; - @Test - public void testReadConfigurationData() { - when( dataBroker.readConfigurationData( instanceID ) ).thenReturn( dataNode ); + @Mock + DOMDataWriteTransaction wTransaction; - CompositeNode actualNode = brokerFacade.readConfigurationData( instanceID ); + @Mock + DOMDataReadWriteTransaction rwTransaction; - assertSame( "readConfigurationData", dataNode, actualNode ); - } + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + // TODO it is started before every test method + brokerFacade.setDomDataBroker(domDataBroker); + brokerFacade.setContext(mockConsumerSession); + when(domDataBroker.newReadOnlyTransaction()).thenReturn(rTransaction); + when(domDataBroker.newWriteOnlyTransaction()).thenReturn(wTransaction); + when(domDataBroker.newReadWriteTransaction()).thenReturn(rwTransaction); - @Test - public void testReadConfigurationDataBehindMountPoint() { - when( mockMountInstance.readConfigurationData( instanceID ) ).thenReturn( dataNode ); + dataNode = TestUtils.prepareCompositeNodeWithIetfInterfacesInterfacesData(); - CompositeNode actualNode = brokerFacade.readConfigurationDataBehindMountPoint( - mockMountInstance, instanceID ); + } - assertSame( "readConfigurationDataBehindMountPoint", dataNode, actualNode ); + private ListenableFuture>> wrapDummyNode(NormalizedNode dummyNode) { + return Futures.>> immediateFuture(Optional.> of(dummyNode)); + } + + /** + * Value of this node shouldn't be important for testing purposes + */ + private NormalizedNode createDummyNode(String namespace, String date, String localName) { + return Builders.containerBuilder() + .withNodeIdentifier(new NodeIdentifier(QName.create(namespace, date, localName))).build(); } @Test - public void testReadOperationalData() { - when( dataBroker.readOperationalData( instanceID ) ).thenReturn( dataNode ); + public void testReadConfigurationData() { + when(rTransaction.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class))).thenReturn( + dummyNodeInFuture); - CompositeNode actualNode = brokerFacade.readOperationalData( instanceID ); + NormalizedNode actualNode = brokerFacade.readConfigurationData(instanceID); - assertSame( "readOperationalData", dataNode, actualNode ); + assertSame("readConfigurationData", dummyNode, actualNode); } @Test - public void testReadOperationalDataBehindMountPoint() { - when( mockMountInstance.readOperationalData( instanceID ) ).thenReturn( dataNode ); + public void testReadOperationalData() { + when(rTransaction.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class))).thenReturn( + dummyNodeInFuture); - CompositeNode actualNode = brokerFacade.readOperationalDataBehindMountPoint( - mockMountInstance, instanceID ); + NormalizedNode actualNode = brokerFacade.readOperationalData(instanceID); - assertSame( "readOperationalDataBehindMountPoint", dataNode, actualNode ); + assertSame("readOperationalData", dummyNode, actualNode); } - @Test(expected=RestconfDocumentedException.class) + @Test(expected = RestconfDocumentedException.class) public void testReadOperationalDataWithNoDataBroker() { - brokerFacade.setDataService( null ); + brokerFacade.setDomDataBroker(null); - brokerFacade.readOperationalData( instanceID ); + brokerFacade.readOperationalData(instanceID); } @SuppressWarnings("unchecked") @Test public void testInvokeRpc() throws Exception { - RpcResult expResult = mock( RpcResult.class ); - Future> future = Futures.immediateFuture( expResult ); - when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future ); + RpcResult expResult = mock(RpcResult.class); + Future> future = Futures.immediateFuture(expResult); + when(mockConsumerSession.rpc(qname, dataNode)).thenReturn(future); - Future> actualFuture = brokerFacade.invokeRpc( qname, dataNode ); - assertNotNull( "Future is null", actualFuture ); + Future> actualFuture = brokerFacade.invokeRpc(qname, dataNode); + assertNotNull("Future is null", actualFuture); RpcResult 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> expFuture = Futures.immediateFuture( null ); + CheckedFuture expFuture = mock(CheckedFuture.class); - when( dataBroker.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.putConfigurationData( instanceID, dataNode ); - when( mockTransaction.commit() ).thenReturn( expFuture ); + when(wTransaction.submit()).thenReturn(expFuture); - Future> actualFuture = - brokerFacade.commitConfigurationDataPut( instanceID, dataNode ); + Future actualFuture = brokerFacade.commitConfigurationDataPut(instanceID, dummyNode); - assertSame( "invokeRpc", 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(); - } - - @Test - public void testCommitConfigurationDataPutBehindMountPoint() { - Future> expFuture = Futures.immediateFuture( null ); - - when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.putConfigurationData( instanceID, dataNode ); - when( mockTransaction.commit() ).thenReturn( expFuture ); - - Future> actualFuture = - brokerFacade.commitConfigurationDataPutBehindMountPoint( - mockMountInstance, instanceID, dataNode ); - - 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(domDataBroker, wTransaction); + inOrder.verify(domDataBroker).newWriteOnlyTransaction(); + inOrder.verify(wTransaction).put(LogicalDatastoreType.CONFIGURATION, instanceID, dummyNode); + inOrder.verify(wTransaction).submit(); } @Test public void testCommitConfigurationDataPost() { - Future> expFuture = Futures.immediateFuture( null ); + CheckedFuture expFuture = mock(CheckedFuture.class); - Map nodeMap = - new ImmutableMap.Builder() - .put( instanceID, dataNode ).build(); + NormalizedNode dummyNode2 = createDummyNode("dummy:namespace2", "2014-07-01", "dummy local name2"); + when(rwTransaction.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + wrapDummyNode(dummyNode2)); + when(rwTransaction.submit()).thenReturn(expFuture); - when( dataBroker.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.putConfigurationData( instanceID, dataNode ); - when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap ); - when( mockTransaction.commit() ).thenReturn( expFuture ); + CheckedFuture actualFuture = brokerFacade.commitConfigurationDataPost( + instanceID, dummyNode); - Future> actualFuture = - brokerFacade.commitConfigurationDataPost( instanceID, dataNode ); + assertSame("commitConfigurationDataPost", 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(domDataBroker, rwTransaction); + inOrder.verify(domDataBroker).newReadWriteTransaction(); + inOrder.verify(rwTransaction).merge(LogicalDatastoreType.CONFIGURATION, instanceID, dummyNode); + inOrder.verify(rwTransaction).submit(); } - @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 ); - try { - 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> expFuture = Futures.immediateFuture( null ); - - Map nodeMap = - new ImmutableMap.Builder() - .put( instanceID, dataNode ).build(); - - when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.putConfigurationData( instanceID, dataNode ); - when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap ); - when( mockTransaction.commit() ).thenReturn( expFuture ); - - Future> actualFuture = - brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance, - instanceID, dataNode ); - - assertSame( "commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture ); - - InOrder inOrder = inOrder( mockMountInstance, mockTransaction ); - inOrder.verify( mockMountInstance ).beginTransaction(); - inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode ); - inOrder.verify( mockTransaction ).commit(); - } - - @Test(expected=RestconfDocumentedException.class) - public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() { - - when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.putConfigurationData( instanceID, dataNode ); - when ( mockTransaction.readConfigurationData( instanceID ) ) - .thenReturn( dataNode ); + when(rwTransaction.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + dummyNodeInFuture); try { - brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance, - instanceID, dataNode ); - } - catch (RestconfDocumentedException e) { - assertEquals("getErrorTag", - RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag()); + brokerFacade.commitConfigurationDataPost(instanceID, dummyNode); + } catch (RestconfDocumentedException e) { + assertEquals("getErrorTag", RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag()); throw e; } } @Test public void testCommitConfigurationDataDelete() { - Future> expFuture = Futures.immediateFuture( null ); - - when( dataBroker.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.removeConfigurationData( instanceID ); - when( mockTransaction.commit() ).thenReturn( expFuture ); - - Future> actualFuture = - brokerFacade.commitConfigurationDataDelete( instanceID ); + CheckedFuture expFuture = mock(CheckedFuture.class); - assertSame( "commitConfigurationDataDelete", expFuture, actualFuture ); + when(wTransaction.submit()).thenReturn(expFuture); - InOrder inOrder = inOrder( dataBroker, mockTransaction ); - inOrder.verify( dataBroker ).beginTransaction(); - inOrder.verify( mockTransaction ).removeConfigurationData( instanceID ); - inOrder.verify( mockTransaction ).commit(); - } - - @Test - public void testCommitConfigurationDataDeleteBehindMountPoint() { - Future> expFuture = Futures.immediateFuture( null ); - - when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.removeConfigurationData( instanceID ); - when( mockTransaction.commit() ).thenReturn( expFuture ); + CheckedFuture actualFuture = brokerFacade + .commitConfigurationDataDelete(instanceID); - Future> actualFuture = - brokerFacade.commitConfigurationDataDeleteBehindMountPoint( - mockMountInstance, instanceID ); + assertSame("commitConfigurationDataDelete", 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(domDataBroker, wTransaction); + inOrder.verify(domDataBroker).newWriteOnlyTransaction(); + inOrder.verify(wTransaction).delete(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class)); + inOrder.verify(wTransaction).submit(); } @SuppressWarnings("unchecked") @Test public void testRegisterToListenDataChanges() { - ListenerAdapter listener = Notificator.createListener( instanceID, "stream" ); + ListenerAdapter listener = Notificator.createListener(instanceID, "stream"); + + ListenerRegistration mockRegistration = mock(ListenerRegistration.class); + + when( + domDataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), eq(instanceID), eq(listener), + eq(DataChangeScope.BASE))).thenReturn(mockRegistration); - ListenerRegistration mockRegistration = mock( ListenerRegistration.class ); - when( dataBroker.registerDataChangeListener( instanceID, listener ) ) - .thenReturn( mockRegistration ); + brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, DataChangeScope.BASE, listener); - brokerFacade.registerToListenDataChanges( listener ); + verify(domDataBroker).registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, instanceID, listener, + DataChangeScope.BASE); - verify( dataBroker ).registerDataChangeListener( instanceID, listener ); + assertEquals("isListening", true, listener.isListening()); - assertEquals( "isListening", true, listener.isListening() ); + brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, DataChangeScope.BASE, listener); + verifyNoMoreInteractions(domDataBroker); - brokerFacade.registerToListenDataChanges( listener ); - verifyNoMoreInteractions( dataBroker ); + String escapeXml = StringEscapeUtils.escapeXml("data might contain & or ! or % or ' "); + System.out.println(escapeXml); } }