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=f533a6360ad847a74e7f203bf32db65a0acfe995;hp=73f828c6466a886a2f5d7de7029c590389c5e662;hb=b5167b9bc04f2792b275cfe0eac78c0f5eb9442d;hpb=c222e37f2a0f0f3f6266242fbea2d3b018f4e6e3 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 73f828c646..f533a6360a 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 @@ -12,29 +12,36 @@ 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 com.google.common.collect.ImmutableMap; +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; import com.google.common.util.concurrent.Futures; -import java.util.Map; import java.util.concurrent.Future; import org.junit.Before; +import org.junit.Ignore; 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.ReadFailedException; +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.ControllerContext; import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException; import org.opendaylight.controller.sal.restconf.impl.RestconfError; import org.opendaylight.controller.sal.streams.listeners.ListenerAdapter; @@ -44,7 +51,9 @@ 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.YangInstanceIdentifier; -import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode; +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,73 +63,90 @@ import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode; 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("test:module", "2014-01-09", "interfaces"); + CheckedFuture>,ReadFailedException> dummyNodeInFuture = wrapDummyNode(dummyNode); + + QName qname = TestUtils.buildQName("interfaces","test:module", "2014-01-09"); YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).toInstance(); + @Mock + DOMDataReadOnlyTransaction rTransaction; + + @Mock + DOMDataWriteTransaction wTransaction; + + @Mock + DOMDataReadWriteTransaction rwTransaction; + @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); - - brokerFacade.setDataService(dataBroker); + // 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 testReadConfigurationData() { - when(dataBroker.readConfigurationData(instanceID)).thenReturn(dataNode); + dataNode = TestUtils.prepareCompositeNodeWithIetfInterfacesInterfacesData(); - CompositeNode actualNode = brokerFacade.readConfigurationData(instanceID); + ControllerContext.getInstance().setSchemas(TestUtils.loadSchemaContext("/full-versions/test-module")); - assertSame("readConfigurationData", dataNode, actualNode); } - @Test - public void testReadConfigurationDataBehindMountPoint() { - when(mockMountInstance.readConfigurationData(instanceID)).thenReturn(dataNode); + private CheckedFuture>,ReadFailedException> wrapDummyNode(final NormalizedNode dummyNode) { + return Futures.immediateCheckedFuture(Optional.> of(dummyNode)); + } + + private CheckedFuture wrapExistence(Boolean exists) { + return Futures.immediateCheckedFuture(exists); + } - CompositeNode actualNode = brokerFacade.readConfigurationDataBehindMountPoint(mockMountInstance, instanceID); - assertSame("readConfigurationDataBehindMountPoint", dataNode, actualNode); + /** + * Value of this node shouldn't be important for testing purposes + */ + private NormalizedNode createDummyNode(final String namespace, final String date, final 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) public void testReadOperationalDataWithNoDataBroker() { - brokerFacade.setDataService(null); + brokerFacade.setDomDataBroker(null); brokerFacade.readOperationalData(instanceID); } @@ -146,111 +172,55 @@ public class BrokerFacadeTest { brokerFacade.invokeRpc(qname, dataNode); } + @Ignore @Test public void testCommitConfigurationDataPut() { - Future> expFuture = Futures.immediateFuture(null); - - when(dataBroker.beginTransaction()).thenReturn(mockTransaction); - mockTransaction.putConfigurationData(instanceID, dataNode); - when(mockTransaction.commit()).thenReturn(expFuture); - - Future> actualFuture = brokerFacade.commitConfigurationDataPut(instanceID, - dataNode); - - assertSame("invokeRpc", 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); + CheckedFuture expFuture = mock(CheckedFuture.class); - when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction); - mockTransaction.putConfigurationData(instanceID, dataNode); - when(mockTransaction.commit()).thenReturn(expFuture); + when(wTransaction.submit()).thenReturn(expFuture); - Future> actualFuture = brokerFacade.commitConfigurationDataPutBehindMountPoint( - mockMountInstance, instanceID, dataNode); + Future actualFuture = brokerFacade.commitConfigurationDataPut(instanceID, dummyNode); - assertSame("invokeRpc", expFuture, actualFuture); + assertSame("commitConfigurationDataPut", 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); - - Map nodeMap = new ImmutableMap.Builder() - .put(instanceID, dataNode).build(); + CheckedFuture expFuture = mock(CheckedFuture.class); - when(dataBroker.beginTransaction()).thenReturn(mockTransaction); - mockTransaction.putConfigurationData(instanceID, dataNode); - when(mockTransaction.getCreatedConfigurationData()).thenReturn(nodeMap); - when(mockTransaction.commit()).thenReturn(expFuture); + NormalizedNode dummyNode2 = createDummyNode("dummy:namespace2", "2014-07-01", "dummy local name2"); - Future> actualFuture = brokerFacade.commitConfigurationDataPost(instanceID, - dataNode); + when(rwTransaction.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + wrapDummyNode(dummyNode2)); - assertSame("commitConfigurationDataPut", expFuture, actualFuture); + when(rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + wrapExistence(true)); - InOrder inOrder = inOrder(dataBroker, mockTransaction); - inOrder.verify(dataBroker).beginTransaction(); - inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode); - inOrder.verify(mockTransaction).commit(); - } - - @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); + when(rwTransaction.submit()).thenReturn(expFuture); - Map nodeMap = new ImmutableMap.Builder() - .put(instanceID, dataNode).build(); + CheckedFuture actualFuture = brokerFacade.commitConfigurationDataPost( + instanceID, dummyNode); - when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction); - mockTransaction.putConfigurationData(instanceID, dataNode); - when(mockTransaction.getCreatedConfigurationData()).thenReturn(nodeMap); - when(mockTransaction.commit()).thenReturn(expFuture); + assertSame("commitConfigurationDataPost", expFuture, actualFuture); - 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(); + 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) - public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() { - - when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction); - mockTransaction.putConfigurationData(instanceID, dataNode); - when(mockTransaction.readConfigurationData(instanceID)).thenReturn(dataNode); + public void testCommitConfigurationDataPostAlreadyExists() { + when(rwTransaction.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + dummyNodeInFuture); try { - brokerFacade.commitConfigurationDataPostBehindMountPoint(mockMountInstance, instanceID, dataNode); + brokerFacade.commitConfigurationDataPost(instanceID, dummyNode); } catch (RestconfDocumentedException e) { assertEquals("getErrorTag", RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag()); throw e; @@ -259,43 +229,22 @@ public class BrokerFacadeTest { @Test public void testCommitConfigurationDataDelete() { - Future> expFuture = Futures.immediateFuture(null); + CheckedFuture expFuture = mock(CheckedFuture.class); - when(dataBroker.beginTransaction()).thenReturn(mockTransaction); - when(mockTransaction.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn( - ImmutableCompositeNode.builder().toInstance()); - mockTransaction.removeConfigurationData(instanceID); - when(mockTransaction.commit()).thenReturn(expFuture); + when(wTransaction.submit()).thenReturn(expFuture); - Future> actualFuture = brokerFacade.commitConfigurationDataDelete(instanceID); + NormalizedNode dummyNode2 = createDummyNode("dummy:namespace2", "2014-07-01", "dummy local name2"); - assertSame("commitConfigurationDataDelete", expFuture, actualFuture); - InOrder inOrder = inOrder(dataBroker, mockTransaction); - inOrder.verify(dataBroker).beginTransaction(); - inOrder.verify(mockTransaction).removeConfigurationData(instanceID); - inOrder.verify(mockTransaction).commit(); - } + CheckedFuture actualFuture = brokerFacade + .commitConfigurationDataDelete(instanceID); - @Test - public void testCommitConfigurationDataDeleteBehindMountPoint() { - Future> expFuture = Futures.immediateFuture(null); - - when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction); - when(mockTransaction.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn( - ImmutableCompositeNode.builder().toInstance()); - mockTransaction.removeConfigurationData(instanceID); - when(mockTransaction.commit()).thenReturn(expFuture); - - Future> actualFuture = brokerFacade.commitConfigurationDataDeleteBehindMountPoint( - mockMountInstance, instanceID); - - assertSame("commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture); + assertSame("commitConfigurationDataDelete", 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") @@ -303,16 +252,21 @@ public class BrokerFacadeTest { public void testRegisterToListenDataChanges() { ListenerAdapter listener = Notificator.createListener(instanceID, "stream"); - ListenerRegistration mockRegistration = mock(ListenerRegistration.class); - when(dataBroker.registerDataChangeListener(instanceID, listener)).thenReturn(mockRegistration); + ListenerRegistration mockRegistration = mock(ListenerRegistration.class); + + when( + domDataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), eq(instanceID), eq(listener), + eq(DataChangeScope.BASE))).thenReturn(mockRegistration); - brokerFacade.registerToListenDataChanges(listener); + brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, DataChangeScope.BASE, listener); - verify(dataBroker).registerDataChangeListener(instanceID, listener); + verify(domDataBroker).registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, instanceID, listener, + DataChangeScope.BASE); assertEquals("isListening", true, listener.isListening()); - brokerFacade.registerToListenDataChanges(listener); - verifyNoMoreInteractions(dataBroker); + brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, DataChangeScope.BASE, listener); + verifyNoMoreInteractions(domDataBroker); + } }