2 * Copyright (c) ${year} Brocade Communications Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.controller.sal.restconf.impl.test;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertSame;
14 import static org.mockito.Matchers.any;
15 import static org.mockito.Mockito.inOrder;
16 import static org.mockito.Mockito.mock;
17 import static org.mockito.Mockito.verify;
18 import static org.mockito.Mockito.verifyNoMoreInteractions;
19 import static org.mockito.Mockito.when;
21 import com.google.common.collect.ImmutableMap;
22 import com.google.common.util.concurrent.Futures;
24 import java.util.concurrent.Future;
25 import org.junit.Before;
26 import org.junit.Test;
27 import org.mockito.InOrder;
28 import org.mockito.Mock;
29 import org.mockito.MockitoAnnotations;
30 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
31 import org.opendaylight.controller.sal.core.api.Broker.ConsumerSession;
32 import org.opendaylight.controller.sal.core.api.data.DataBrokerService;
33 import org.opendaylight.controller.sal.core.api.data.DataChangeListener;
34 import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
35 import org.opendaylight.controller.sal.core.api.mount.MountInstance;
36 import org.opendaylight.controller.sal.rest.impl.XmlToCompositeNodeProvider;
37 import org.opendaylight.controller.sal.restconf.impl.BrokerFacade;
38 import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
39 import org.opendaylight.controller.sal.restconf.impl.RestconfError;
40 import org.opendaylight.controller.sal.streams.listeners.ListenerAdapter;
41 import org.opendaylight.controller.sal.streams.listeners.Notificator;
42 import org.opendaylight.yangtools.concepts.ListenerRegistration;
43 import org.opendaylight.yangtools.yang.common.QName;
44 import org.opendaylight.yangtools.yang.common.RpcResult;
45 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
46 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
47 import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
50 * Unit tests for BrokerFacade.
52 * @author Thomas Pantelis
54 public class BrokerFacadeTest {
57 DataBrokerService dataBroker;
60 DataModificationTransaction mockTransaction;
63 ConsumerSession mockConsumerSession;
66 MountInstance mockMountInstance;
68 BrokerFacade brokerFacade = BrokerFacade.getInstance();
70 CompositeNode dataNode = TestUtils.readInputToCnSn("/parts/ietf-interfaces_interfaces.xml",
71 XmlToCompositeNodeProvider.INSTANCE);
73 QName qname = QName.create("node");
75 YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).toInstance();
78 public void setUp() throws Exception {
79 MockitoAnnotations.initMocks(this);
81 brokerFacade.setDataService(dataBroker);
82 brokerFacade.setContext(mockConsumerSession);
86 public void testReadConfigurationData() {
87 when(dataBroker.readConfigurationData(instanceID)).thenReturn(dataNode);
89 CompositeNode actualNode = brokerFacade.readConfigurationData(instanceID);
91 assertSame("readConfigurationData", dataNode, actualNode);
95 public void testReadConfigurationDataBehindMountPoint() {
96 when(mockMountInstance.readConfigurationData(instanceID)).thenReturn(dataNode);
98 CompositeNode actualNode = brokerFacade.readConfigurationDataBehindMountPoint(mockMountInstance, instanceID);
100 assertSame("readConfigurationDataBehindMountPoint", dataNode, actualNode);
104 public void testReadOperationalData() {
105 when(dataBroker.readOperationalData(instanceID)).thenReturn(dataNode);
107 CompositeNode actualNode = brokerFacade.readOperationalData(instanceID);
109 assertSame("readOperationalData", dataNode, actualNode);
113 public void testReadOperationalDataBehindMountPoint() {
114 when(mockMountInstance.readOperationalData(instanceID)).thenReturn(dataNode);
116 CompositeNode actualNode = brokerFacade.readOperationalDataBehindMountPoint(mockMountInstance, instanceID);
118 assertSame("readOperationalDataBehindMountPoint", dataNode, actualNode);
121 @Test(expected = RestconfDocumentedException.class)
122 public void testReadOperationalDataWithNoDataBroker() {
123 brokerFacade.setDataService(null);
125 brokerFacade.readOperationalData(instanceID);
128 @SuppressWarnings("unchecked")
130 public void testInvokeRpc() throws Exception {
131 RpcResult<CompositeNode> expResult = mock(RpcResult.class);
132 Future<RpcResult<CompositeNode>> future = Futures.immediateFuture(expResult);
133 when(mockConsumerSession.rpc(qname, dataNode)).thenReturn(future);
135 Future<RpcResult<CompositeNode>> actualFuture = brokerFacade.invokeRpc(qname, dataNode);
136 assertNotNull("Future is null", actualFuture);
137 RpcResult<CompositeNode> actualResult = actualFuture.get();
139 assertSame("invokeRpc", expResult, actualResult);
142 @Test(expected = RestconfDocumentedException.class)
143 public void testInvokeRpcWithNoConsumerSession() {
144 brokerFacade.setContext(null);
146 brokerFacade.invokeRpc(qname, dataNode);
150 public void testCommitConfigurationDataPut() {
151 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
153 when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
154 mockTransaction.putConfigurationData(instanceID, dataNode);
155 when(mockTransaction.commit()).thenReturn(expFuture);
157 Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPut(instanceID,
160 assertSame("invokeRpc", expFuture, actualFuture);
162 InOrder inOrder = inOrder(dataBroker, mockTransaction);
163 inOrder.verify(dataBroker).beginTransaction();
164 inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
165 inOrder.verify(mockTransaction).commit();
169 public void testCommitConfigurationDataPutBehindMountPoint() {
170 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
172 when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
173 mockTransaction.putConfigurationData(instanceID, dataNode);
174 when(mockTransaction.commit()).thenReturn(expFuture);
176 Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPutBehindMountPoint(
177 mockMountInstance, instanceID, dataNode);
179 assertSame("invokeRpc", expFuture, actualFuture);
181 InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
182 inOrder.verify(mockMountInstance).beginTransaction();
183 inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
184 inOrder.verify(mockTransaction).commit();
188 public void testCommitConfigurationDataPost() {
189 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
191 Map<YangInstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<YangInstanceIdentifier, CompositeNode>()
192 .put(instanceID, dataNode).build();
194 when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
195 mockTransaction.putConfigurationData(instanceID, dataNode);
196 when(mockTransaction.getCreatedConfigurationData()).thenReturn(nodeMap);
197 when(mockTransaction.commit()).thenReturn(expFuture);
199 Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPost(instanceID,
202 assertSame("commitConfigurationDataPut", expFuture, actualFuture);
204 InOrder inOrder = inOrder(dataBroker, mockTransaction);
205 inOrder.verify(dataBroker).beginTransaction();
206 inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
207 inOrder.verify(mockTransaction).commit();
210 @Test(expected = RestconfDocumentedException.class)
211 public void testCommitConfigurationDataPostAlreadyExists() {
212 when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
213 mockTransaction.putConfigurationData(instanceID, dataNode);
214 when(mockTransaction.readConfigurationData(instanceID)).thenReturn(dataNode);
216 brokerFacade.commitConfigurationDataPost(instanceID, dataNode);
217 } catch (RestconfDocumentedException e) {
218 assertEquals("getErrorTag", RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag());
224 public void testCommitConfigurationDataPostBehindMountPoint() {
225 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
227 Map<YangInstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<YangInstanceIdentifier, CompositeNode>()
228 .put(instanceID, dataNode).build();
230 when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
231 mockTransaction.putConfigurationData(instanceID, dataNode);
232 when(mockTransaction.getCreatedConfigurationData()).thenReturn(nodeMap);
233 when(mockTransaction.commit()).thenReturn(expFuture);
235 Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPostBehindMountPoint(
236 mockMountInstance, instanceID, dataNode);
238 assertSame("commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture);
240 InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
241 inOrder.verify(mockMountInstance).beginTransaction();
242 inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
243 inOrder.verify(mockTransaction).commit();
246 @Test(expected = RestconfDocumentedException.class)
247 public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() {
249 when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
250 mockTransaction.putConfigurationData(instanceID, dataNode);
251 when(mockTransaction.readConfigurationData(instanceID)).thenReturn(dataNode);
253 brokerFacade.commitConfigurationDataPostBehindMountPoint(mockMountInstance, instanceID, dataNode);
254 } catch (RestconfDocumentedException e) {
255 assertEquals("getErrorTag", RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag());
261 public void testCommitConfigurationDataDelete() {
262 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
264 when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
265 when(mockTransaction.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn(
266 ImmutableCompositeNode.builder().toInstance());
267 mockTransaction.removeConfigurationData(instanceID);
268 when(mockTransaction.commit()).thenReturn(expFuture);
270 Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataDelete(instanceID);
272 assertSame("commitConfigurationDataDelete", expFuture, actualFuture);
274 InOrder inOrder = inOrder(dataBroker, mockTransaction);
275 inOrder.verify(dataBroker).beginTransaction();
276 inOrder.verify(mockTransaction).removeConfigurationData(instanceID);
277 inOrder.verify(mockTransaction).commit();
281 public void testCommitConfigurationDataDeleteBehindMountPoint() {
282 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
284 when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
285 when(mockTransaction.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn(
286 ImmutableCompositeNode.builder().toInstance());
287 mockTransaction.removeConfigurationData(instanceID);
288 when(mockTransaction.commit()).thenReturn(expFuture);
290 Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
291 mockMountInstance, instanceID);
293 assertSame("commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture);
295 InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
296 inOrder.verify(mockMountInstance).beginTransaction();
297 inOrder.verify(mockTransaction).removeConfigurationData(instanceID);
298 inOrder.verify(mockTransaction).commit();
301 @SuppressWarnings("unchecked")
303 public void testRegisterToListenDataChanges() {
304 ListenerAdapter listener = Notificator.createListener(instanceID, "stream");
306 ListenerRegistration<DataChangeListener> mockRegistration = mock(ListenerRegistration.class);
307 when(dataBroker.registerDataChangeListener(instanceID, listener)).thenReturn(mockRegistration);
309 brokerFacade.registerToListenDataChanges(listener);
311 verify(dataBroker).registerDataChangeListener(instanceID, listener);
313 assertEquals("isListening", true, listener.isListening());
315 brokerFacade.registerToListenDataChanges(listener);
316 verifyNoMoreInteractions(dataBroker);