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.
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<Optional<NormalizedNode<?, ?>>,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<Optional<NormalizedNode<?, ?>>,ReadFailedException> wrapDummyNode(final NormalizedNode<?, ?> dummyNode) {
+ return Futures.immediateCheckedFuture(Optional.<NormalizedNode<?, ?>> of(dummyNode));
}
- @Test
- public void testReadConfigurationDataBehindMountPoint() {
- when( mockMountInstance.readConfigurationData( instanceID ) ).thenReturn( dataNode );
+ private CheckedFuture<Boolean,ReadFailedException> 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<CompositeNode> expResult = mock( RpcResult.class );
- Future<RpcResult<CompositeNode>> future = Futures.immediateFuture( expResult );
- when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future );
+ 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> actualResult = brokerFacade.invokeRpc( qname, dataNode );
+ 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=ResponseException.class)
- public void testInvokeRpcWithException() {
- Exception mockEx = new Exception( "mock" );
- Future<RpcResult<CompositeNode>> 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<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
-
- when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
- mockTransaction.putConfigurationData( instanceID, dataNode );
- when( mockTransaction.commit() ).thenReturn( expFuture );
-
- Future<RpcResult<TransactionStatus>> actualFuture =
- brokerFacade.commitConfigurationDataPut( instanceID, dataNode );
+ CheckedFuture<Void, TransactionCommitFailedException> 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<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
-
- when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
- mockTransaction.putConfigurationData( instanceID, dataNode );
- when( mockTransaction.commit() ).thenReturn( expFuture );
-
- Future<RpcResult<TransactionStatus>> actualFuture =
- brokerFacade.commitConfigurationDataPutBehindMountPoint(
- mockMountInstance, instanceID, dataNode );
+ Future<Void> 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<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
-
- 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 );
-
- Future<RpcResult<TransactionStatus>> actualFuture =
- brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
-
- assertSame( "commitConfigurationDataPut", expFuture, actualFuture );
+ CheckedFuture<Void, TransactionCommitFailedException> 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<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
+ when(rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn(
+ wrapExistence(true));
- 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(rwTransaction.submit()).thenReturn(expFuture);
- Future<RpcResult<TransactionStatus>> actualFuture =
- brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
- instanceID, dataNode );
+ CheckedFuture<Void, TransactionCommitFailedException> 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<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
+ CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
- when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
- mockTransaction.removeConfigurationData( instanceID );
- when( mockTransaction.commit() ).thenReturn( expFuture );
+ when(wTransaction.submit()).thenReturn(expFuture);
- Future<RpcResult<TransactionStatus>> actualFuture =
- brokerFacade.commitConfigurationDataDelete( instanceID );
+ CheckedFuture<Void, TransactionCommitFailedException> 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<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
-
- when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
- mockTransaction.removeConfigurationData( instanceID );
- when( mockTransaction.commit() ).thenReturn( expFuture );
-
- Future<RpcResult<TransactionStatus>> 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<DOMDataChangeListener> mockRegistration = mock(ListenerRegistration.class);
+
+ when(
+ domDataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), eq(instanceID), eq(listener),
+ eq(DataChangeScope.BASE))).thenReturn(mockRegistration);
- ListenerRegistration<DataChangeListener> 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 );
}
}
Code Review / controller.git / blobdiff