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=6b2583024036b6b7ef39863f64f3fa9069d19e94;hp=18199de8c63ca056ed8aacbf947fe0d36f2afa0d;hb=971b179000ef1cc56699de35061cf6f97d4cf36f;hpb=a261052a953b780a6819b7f77b22b3d0244055f4 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 18199de8c6..6b25830240 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 @@ -8,43 +8,53 @@ package org.opendaylight.controller.sal.restconf.impl.test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertSame; -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 java.util.concurrent.Future; - -import javax.ws.rs.core.Response.Status; - +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.Futures; 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.ResponseException; +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 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 com.google.common.collect.ImmutableMap; -import com.google.common.util.concurrent.Futures; +import java.util.concurrent.Future; + +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; /** * Unit tests for BrokerFacade. @@ -54,284 +64,207 @@ 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; + + 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(); - QName qname = QName.create( "node" ); + @Mock + DOMDataReadOnlyTransaction rTransaction; - InstanceIdentifier instanceID = InstanceIdentifier.builder().node( qname ).toInstance(); + @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.setContext(mockConsumerSession); + when(domDataBroker.newReadOnlyTransaction()).thenReturn(rTransaction); + when(domDataBroker.newWriteOnlyTransaction()).thenReturn(wTransaction); + when(domDataBroker.newReadWriteTransaction()).thenReturn(rwTransaction); - brokerFacade.setDataService( dataBroker ); - brokerFacade.setContext( mockConsumerSession ); - } + dataNode = TestUtils.prepareCompositeNodeWithIetfInterfacesInterfacesData(); - @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(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=ResponseException.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() { - RpcResult expResult = mock( RpcResult.class ); - Future> future = Futures.immediateFuture( expResult ); - when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future ); + public void testInvokeRpc() throws Exception { + RpcResult expResult = mock(RpcResult.class); + Future> future = Futures.immediateFuture(expResult); + when(mockConsumerSession.rpc(qname, dataNode)).thenReturn(future); - RpcResult actualResult = brokerFacade.invokeRpc( qname, dataNode ); + 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=ResponseException.class) - public void testInvokeRpcWithException() { - Exception mockEx = new Exception( "mock" ); - Future> future = Futures.immediateFailedFuture( mockEx ); - when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future ); - - brokerFacade.invokeRpc( qname, dataNode ); - } - - @Test(expected=ResponseException.class) + @Test(expected = RestconfDocumentedException.class) public void testInvokeRpcWithNoConsumerSession() { - brokerFacade.setContext( null ); + brokerFacade.setContext(null); - brokerFacade.invokeRpc( qname, dataNode ); + 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 ); + CheckedFuture expFuture = mock(CheckedFuture.class); - assertSame( "invokeRpc", expFuture, actualFuture ); + when(wTransaction.submit()).thenReturn(expFuture); - 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 ); + 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(); - - 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 ); - - assertSame( "commitConfigurationDataPut", expFuture, actualFuture ); + CheckedFuture expFuture = mock(CheckedFuture.class); - InOrder inOrder = inOrder( dataBroker, mockTransaction ); - inOrder.verify( dataBroker ).beginTransaction(); - inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode ); - inOrder.verify( mockTransaction ).commit(); - } + NormalizedNode dummyNode2 = createDummyNode("dummy:namespace2", "2014-07-01", "dummy local name2"); - @Test(expected=ResponseException.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 (ResponseException e) { - assertEquals("Unexpect Exception Status -> " - + "http://tools.ietf.org/html/draft-bierman-netconf-restconf-03#page-48", - (e.getResponse().getStatus()), Status.CONFLICT.getStatusCode()); - throw e; - } - } + when(rwTransaction.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + wrapDummyNode(dummyNode2)); - @Test - public void testCommitConfigurationDataPostBehindMountPoint() { - Future> expFuture = Futures.immediateFuture( null ); + when(rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + wrapExistence(true)); - 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 ); + when(rwTransaction.submit()).thenReturn(expFuture); - Future> actualFuture = - brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance, - instanceID, dataNode ); + CheckedFuture actualFuture = brokerFacade.commitConfigurationDataPost( + instanceID, dummyNode); - assertSame( "commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture ); + assertSame("commitConfigurationDataPost", 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=ResponseException.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() { + when(rwTransaction.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn( + dummyNodeInFuture); try { - brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance, - instanceID, dataNode ); - } catch (ResponseException e) { - assertEquals("Unexpect Exception Status -> " - + "http://tools.ietf.org/html/draft-bierman-netconf-restconf-03#page-48", - e.getResponse().getStatus(), Status.CONFLICT.getStatusCode()); + 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 ); + CheckedFuture expFuture = mock(CheckedFuture.class); - when( dataBroker.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.removeConfigurationData( instanceID ); - when( mockTransaction.commit() ).thenReturn( expFuture ); + when(wTransaction.submit()).thenReturn(expFuture); - Future> actualFuture = - brokerFacade.commitConfigurationDataDelete( instanceID ); + CheckedFuture 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(); - } - - @Test - public void testCommitConfigurationDataDeleteBehindMountPoint() { - Future> expFuture = Futures.immediateFuture( null ); - - when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction ); - mockTransaction.removeConfigurationData( instanceID ); - when( mockTransaction.commit() ).thenReturn( expFuture ); - - Future> actualFuture = - brokerFacade.commitConfigurationDataDeleteBehindMountPoint( - mockMountInstance, instanceID ); - - 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 ); } }