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=9c5de08c5ce1d3346c713986d3d1ce0d31ee84b0;hp=ddab7004408f4d60aa3e89f8660f8aa9749bce7b;hb=1447e0132075bbd3013aa41b98384a373bd82d1a;hpb=26da3c2a206a753356b507b018052cbb9cccca7d 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..9c5de08c5c 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,40 +11,52 @@ 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 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.md.sal.dom.api.DOMRpcException; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcService; 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; import org.opendaylight.controller.sal.streams.listeners.Notificator; 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; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; /** * Unit tests for BrokerFacade. @@ -54,277 +66,207 @@ import com.google.common.util.concurrent.Futures; public class BrokerFacadeTest { @Mock - DataBrokerService dataBroker; + DOMDataBroker domDataBroker; @Mock - DataModificationTransaction mockTransaction; + ConsumerSession context; @Mock - ConsumerSession mockConsumerSession; + DOMRpcService mockRpcService; @Mock - MountInstance mockMountInstance; + DOMMountPoint mockMountInstance; BrokerFacade brokerFacade = BrokerFacade.getInstance(); - CompositeNode dataNode = TestUtils.readInputToCnSn( "/parts/ietf-interfaces_interfaces.xml", - XmlToCompositeNodeProvider.INSTANCE ); + NormalizedNode dummyNode = createDummyNode("test:module", "2014-01-09", "interfaces"); + CheckedFuture>,ReadFailedException> dummyNodeInFuture = wrapDummyNode(dummyNode); - QName qname = QName.create( "node" ); + QName qname = TestUtils.buildQName("interfaces","test:module", "2014-01-09"); - InstanceIdentifier instanceID = InstanceIdentifier.builder().node( qname ).toInstance(); + SchemaPath type = SchemaPath.create(true, qname); + + YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).build(); + + @Mock + DOMDataReadOnlyTransaction rTransaction; + + @Mock + DOMDataWriteTransaction wTransaction; + + @Mock + DOMDataReadWriteTransaction rwTransaction; @Before public void setUp() throws Exception { - MockitoAnnotations.initMocks( this ); + MockitoAnnotations.initMocks(this); + // TODO it is started before every test method + brokerFacade.setDomDataBroker(domDataBroker); + brokerFacade.setRpcService(mockRpcService); + brokerFacade.setContext(context); + when(domDataBroker.newReadOnlyTransaction()).thenReturn(rTransaction); + when(domDataBroker.newWriteOnlyTransaction()).thenReturn(wTransaction); + when(domDataBroker.newReadWriteTransaction()).thenReturn(rwTransaction); - brokerFacade.setDataService( dataBroker ); - brokerFacade.setContext( mockConsumerSession ); - } - - @Test - public void testReadConfigurationData() { - when( dataBroker.readConfigurationData( instanceID ) ).thenReturn( dataNode ); + ControllerContext.getInstance().setSchemas(TestUtils.loadSchemaContext("/full-versions/test-module")); - CompositeNode actualNode = brokerFacade.readConfigurationData( instanceID ); + } - assertSame( "readConfigurationData", dataNode, actualNode ); + private CheckedFuture>,ReadFailedException> wrapDummyNode(final NormalizedNode dummyNode) { + return Futures.immediateCheckedFuture(Optional.> of(dummyNode)); } - @Test - public void testReadConfigurationDataBehindMountPoint() { - when( mockMountInstance.readConfigurationData( instanceID ) ).thenReturn( dataNode ); + private CheckedFuture wrapExistence(final 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 ); + final 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 ); + final 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 ); - - Future> actualFuture = brokerFacade.invokeRpc( qname, dataNode ); - assertNotNull( "Future is null", actualFuture ); - RpcResult actualResult = actualFuture.get(); - - assertSame( "invokeRpc", expResult, actualResult ); + final DOMRpcResult expResult = mock(DOMRpcResult.class); + final CheckedFuture future = Futures.immediateCheckedFuture(expResult); + when(mockRpcService.invokeRpc(type, dummyNode)).thenReturn(future); + + final CheckedFuture actualFuture = brokerFacade.invokeRpc(type, dummyNode); + assertNotNull("Future is null", actualFuture); + final DOMRpcResult actualResult = actualFuture.get(); + assertSame("invokeRpc", expResult, actualResult); } - @Test(expected=RestconfDocumentedException.class) + @Test(expected = RestconfDocumentedException.class) public void testInvokeRpcWithNoConsumerSession() { - brokerFacade.setContext( null ); - - brokerFacade.invokeRpc( qname, dataNode ); + brokerFacade.setContext(null); + brokerFacade.invokeRpc(type, dummyNode); } + @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 ); + @SuppressWarnings("unchecked") + final 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 ); + final Future actualFuture = brokerFacade.commitConfigurationDataPut((SchemaContext)null, 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(); + final 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 ); + @SuppressWarnings("unchecked") + final CheckedFuture expFuture = mock(CheckedFuture.class); - Map nodeMap = - new ImmutableMap.Builder() - .put( instanceID, dataNode ).build(); + when(rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + wrapExistence(false)); - when( dataBroker.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.putConfigurationData( instanceID, dataNode ); - when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap ); - when( mockTransaction.commit() ).thenReturn( expFuture ); - Future> actualFuture = - brokerFacade.commitConfigurationDataPost( instanceID, dataNode ); + when(rwTransaction.submit()).thenReturn(expFuture); - assertSame( "commitConfigurationDataPut", expFuture, actualFuture ); + final CheckedFuture actualFuture = brokerFacade.commitConfigurationDataPost( + (SchemaContext)null, YangInstanceIdentifier.builder().build(), dummyNode); - InOrder inOrder = inOrder( dataBroker, mockTransaction ); - inOrder.verify( dataBroker ).beginTransaction(); - inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode ); - inOrder.verify( mockTransaction ).commit(); - } + assertSame("commitConfigurationDataPost", expFuture, actualFuture); - @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; - } + final InOrder inOrder = inOrder(domDataBroker, rwTransaction); + inOrder.verify(domDataBroker).newReadWriteTransaction(); + inOrder.verify(rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, instanceID); + inOrder.verify(rwTransaction).put(LogicalDatastoreType.CONFIGURATION, instanceID, dummyNode); + inOrder.verify(rwTransaction).submit(); } - @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 ); + @Test(expected = RestconfDocumentedException.class) + public void testCommitConfigurationDataPostAlreadyExists() { + final CheckedFuture successFuture = Futures.immediateCheckedFuture(Boolean.TRUE); + when(rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + successFuture); try { - brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance, - instanceID, dataNode ); - } - catch (RestconfDocumentedException e) { - assertEquals("getErrorTag", - RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag()); + // Schema context is only necessary for ensuring parent structure + brokerFacade.commitConfigurationDataPost((SchemaContext)null, instanceID, dummyNode); + } catch (final 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 ); + @SuppressWarnings("unchecked") + final 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 ); + final 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(); + final 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" ); + final ListenerAdapter listener = Notificator.createListener(instanceID, "stream"); + + final 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 ); } }