/*
- * Copyright (c) ${year} Brocade Communications Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2014, 2015 Brocade Communications Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
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.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.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.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.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.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.
DOMDataBroker domDataBroker;
@Mock
- ConsumerSession mockConsumerSession;
+ ConsumerSession context;
+
+ @Mock
+ DOMRpcService mockRpcService;
@Mock
DOMMountPoint mockMountInstance;
BrokerFacade brokerFacade = BrokerFacade.getInstance();
- CompositeNode dataNode;
+ NormalizedNode<?, ?> dummyNode = createDummyNode("test:module", "2014-01-09", "interfaces");
+ CheckedFuture<Optional<NormalizedNode<?, ?>>,ReadFailedException> dummyNodeInFuture = wrapDummyNode(dummyNode);
- NormalizedNode<?, ?> dummyNode = createDummyNode("dummy:namespace", "2014-07-01", "dummy local name");
- ListenableFuture<Optional<NormalizedNode<?, ?>>> dummyNodeInFuture = wrapDummyNode(dummyNode);
+ QName qname = TestUtils.buildQName("interfaces","test:module", "2014-01-09");
- QName qname = QName.create("node");
+ SchemaPath type = SchemaPath.create(true, qname);
- YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).toInstance();
+ YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).build();
@Mock
DOMDataReadOnlyTransaction rTransaction;
MockitoAnnotations.initMocks(this);
// TODO it is started before every test method
brokerFacade.setDomDataBroker(domDataBroker);
- brokerFacade.setContext(mockConsumerSession);
+ brokerFacade.setRpcService(mockRpcService);
+ brokerFacade.setContext(context);
when(domDataBroker.newReadOnlyTransaction()).thenReturn(rTransaction);
when(domDataBroker.newWriteOnlyTransaction()).thenReturn(wTransaction);
when(domDataBroker.newReadWriteTransaction()).thenReturn(rwTransaction);
- dataNode = TestUtils.prepareCompositeNodeWithIetfInterfacesInterfacesData();
+ ControllerContext.getInstance().setSchemas(TestUtils.loadSchemaContext("/full-versions/test-module"));
+
+ }
+ private CheckedFuture<Optional<NormalizedNode<?, ?>>,ReadFailedException> wrapDummyNode(final NormalizedNode<?, ?> dummyNode) {
+ return Futures.immediateCheckedFuture(Optional.<NormalizedNode<?, ?>> of(dummyNode));
}
- private ListenableFuture<Optional<NormalizedNode<?, ?>>> wrapDummyNode(NormalizedNode<?, ?> dummyNode) {
- return Futures.<Optional<NormalizedNode<?, ?>>> immediateFuture(Optional.<NormalizedNode<?, ?>> of(dummyNode));
+ private CheckedFuture<Boolean,ReadFailedException> wrapExistence(final Boolean exists) {
+ return Futures.immediateCheckedFuture(exists);
}
+
/**
* Value of this node shouldn't be important for testing purposes
*/
- private NormalizedNode<?, ?> createDummyNode(String namespace, String date, String localName) {
+ private NormalizedNode<?, ?> createDummyNode(final String namespace, final String date, final String localName) {
return Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create(namespace, date, localName))).build();
}
when(rTransaction.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class))).thenReturn(
dummyNodeInFuture);
- NormalizedNode<?, ?> actualNode = brokerFacade.readConfigurationData(instanceID);
+ final NormalizedNode<?, ?> actualNode = brokerFacade.readConfigurationData(instanceID);
assertSame("readConfigurationData", dummyNode, actualNode);
}
when(rTransaction.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class))).thenReturn(
dummyNodeInFuture);
- NormalizedNode<?, ?> actualNode = brokerFacade.readOperationalData(instanceID);
+ final NormalizedNode<?, ?> actualNode = brokerFacade.readOperationalData(instanceID);
assertSame("readOperationalData", dummyNode, actualNode);
}
brokerFacade.readOperationalData(instanceID);
}
- @SuppressWarnings("unchecked")
@Test
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);
+ final DOMRpcResult expResult = mock(DOMRpcResult.class);
+ final CheckedFuture<DOMRpcResult, DOMRpcException> future = Futures.immediateCheckedFuture(expResult);
+ when(mockRpcService.invokeRpc(type, dummyNode)).thenReturn(future);
- Future<RpcResult<CompositeNode>> actualFuture = brokerFacade.invokeRpc(qname, dataNode);
+ final CheckedFuture<DOMRpcResult, DOMRpcException> actualFuture = brokerFacade.invokeRpc(type, dummyNode);
assertNotNull("Future is null", actualFuture);
- RpcResult<CompositeNode> actualResult = actualFuture.get();
-
+ final DOMRpcResult actualResult = actualFuture.get();
assertSame("invokeRpc", expResult, actualResult);
}
@Test(expected = RestconfDocumentedException.class)
public void testInvokeRpcWithNoConsumerSession() {
brokerFacade.setContext(null);
-
- brokerFacade.invokeRpc(qname, dataNode);
+ brokerFacade.invokeRpc(type, dummyNode);
}
+ @Ignore
@Test
public void testCommitConfigurationDataPut() {
- CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
+ @SuppressWarnings("unchecked")
+ final CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
when(wTransaction.submit()).thenReturn(expFuture);
- Future<Void> actualFuture = brokerFacade.commitConfigurationDataPut(instanceID, dummyNode);
+ final Future<Void> actualFuture = brokerFacade.commitConfigurationDataPut((SchemaContext)null, instanceID, dummyNode);
assertSame("commitConfigurationDataPut", expFuture, actualFuture);
- InOrder inOrder = inOrder(domDataBroker, wTransaction);
+ 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() {
- CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
+ @SuppressWarnings("unchecked")
+ final CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
+
+ when(rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn(
+ wrapExistence(false));
+
- 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);
- CheckedFuture<Void, TransactionCommitFailedException> actualFuture = brokerFacade.commitConfigurationDataPost(
- instanceID, dummyNode);
+ final CheckedFuture<Void, TransactionCommitFailedException> actualFuture = brokerFacade.commitConfigurationDataPost(
+ (SchemaContext)null, instanceID, dummyNode);
assertSame("commitConfigurationDataPost", expFuture, actualFuture);
- InOrder inOrder = inOrder(domDataBroker, rwTransaction);
+ final InOrder inOrder = inOrder(domDataBroker, rwTransaction);
inOrder.verify(domDataBroker).newReadWriteTransaction();
- inOrder.verify(rwTransaction).merge(LogicalDatastoreType.CONFIGURATION, instanceID, dummyNode);
+ inOrder.verify(rwTransaction).exists(LogicalDatastoreType.CONFIGURATION, instanceID);
+ inOrder.verify(rwTransaction).put(LogicalDatastoreType.CONFIGURATION, instanceID, dummyNode);
inOrder.verify(rwTransaction).submit();
}
@Test(expected = RestconfDocumentedException.class)
public void testCommitConfigurationDataPostAlreadyExists() {
- when(rwTransaction.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn(
- dummyNodeInFuture);
+ final CheckedFuture<Boolean, ReadFailedException> successFuture = Futures.immediateCheckedFuture(Boolean.TRUE);
+ when(rwTransaction.exists(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn(
+ successFuture);
try {
- brokerFacade.commitConfigurationDataPost(instanceID, dummyNode);
- } catch (RestconfDocumentedException e) {
+ // 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() {
- CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
+ @SuppressWarnings("unchecked")
+ final CheckedFuture<Void, TransactionCommitFailedException> expFuture = mock(CheckedFuture.class);
when(wTransaction.submit()).thenReturn(expFuture);
- CheckedFuture<Void, TransactionCommitFailedException> actualFuture = brokerFacade
+ final CheckedFuture<Void, TransactionCommitFailedException> actualFuture = brokerFacade
.commitConfigurationDataDelete(instanceID);
assertSame("commitConfigurationDataDelete", expFuture, actualFuture);
- InOrder inOrder = inOrder(domDataBroker, wTransaction);
+ 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");
- ListenerRegistration<DOMDataChangeListener> mockRegistration = mock(ListenerRegistration.class);
+ final ListenerRegistration<DOMDataChangeListener> mockRegistration = mock(ListenerRegistration.class);
when(
domDataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), eq(instanceID), eq(listener),
brokerFacade.registerToListenDataChanges(LogicalDatastoreType.CONFIGURATION, DataChangeScope.BASE, listener);
verifyNoMoreInteractions(domDataBroker);
- String escapeXml = StringEscapeUtils.escapeXml("data might contain & or ! or % or ' ");
- System.out.println(escapeXml);
}
}
Code Review / controller.git / blobdiff