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;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotNull;
12 import static org.junit.Assert.assertSame;
13 import static org.mockito.Matchers.any;
14 import static org.mockito.Mockito.inOrder;
15 import static org.mockito.Mockito.mock;
16 import static org.mockito.Mockito.verify;
17 import static org.mockito.Mockito.verifyNoMoreInteractions;
18 import static org.mockito.Mockito.when;
20 import com.google.common.collect.ImmutableMap;
21 import com.google.common.util.concurrent.Futures;
23 import java.util.concurrent.Future;
24 import org.junit.Before;
25 import org.junit.Test;
26 import org.mockito.InOrder;
27 import org.mockito.Mock;
28 import org.mockito.MockitoAnnotations;
29 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
30 import org.opendaylight.controller.sal.core.api.Broker.ConsumerSession;
31 import org.opendaylight.controller.sal.core.api.data.DataBrokerService;
32 import org.opendaylight.controller.sal.core.api.data.DataChangeListener;
33 import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
34 import org.opendaylight.controller.sal.core.api.mount.MountInstance;
35 import org.opendaylight.controller.sal.rest.impl.XmlToCompositeNodeProvider;
36 import org.opendaylight.controller.sal.restconf.impl.BrokerFacade;
37 import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
38 import org.opendaylight.controller.sal.restconf.impl.RestconfError;
39 import org.opendaylight.controller.sal.streams.listeners.ListenerAdapter;
40 import org.opendaylight.controller.sal.streams.listeners.Notificator;
41 import org.opendaylight.yangtools.concepts.ListenerRegistration;
42 import org.opendaylight.yangtools.yang.common.QName;
43 import org.opendaylight.yangtools.yang.common.RpcResult;
44 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
45 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
46 import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
49 * Unit tests for BrokerFacade.
51 * @author Thomas Pantelis
53 public class BrokerFacadeTest {
56 DataBrokerService dataBroker;
59 DataModificationTransaction mockTransaction;
62 ConsumerSession mockConsumerSession;
65 MountInstance mockMountInstance;
67 BrokerFacade brokerFacade = BrokerFacade.getInstance();
69 CompositeNode dataNode = TestUtils.readInputToCnSn( "/parts/ietf-interfaces_interfaces.xml",
70 XmlToCompositeNodeProvider.INSTANCE );
72 QName qname = QName.create( "node" );
74 InstanceIdentifier instanceID = InstanceIdentifier.builder().node( qname ).toInstance();
77 public void setUp() throws Exception {
78 MockitoAnnotations.initMocks( this );
80 brokerFacade.setDataService( dataBroker );
81 brokerFacade.setContext( mockConsumerSession );
85 public void testReadConfigurationData() {
86 when( dataBroker.readConfigurationData( instanceID ) ).thenReturn( dataNode );
88 CompositeNode actualNode = brokerFacade.readConfigurationData( instanceID );
90 assertSame( "readConfigurationData", dataNode, actualNode );
94 public void testReadConfigurationDataBehindMountPoint() {
95 when( mockMountInstance.readConfigurationData( instanceID ) ).thenReturn( dataNode );
97 CompositeNode actualNode = brokerFacade.readConfigurationDataBehindMountPoint(
98 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(
117 mockMountInstance, instanceID );
119 assertSame( "readOperationalDataBehindMountPoint", dataNode, actualNode );
122 @Test(expected=RestconfDocumentedException.class)
123 public void testReadOperationalDataWithNoDataBroker() {
124 brokerFacade.setDataService( null );
126 brokerFacade.readOperationalData( instanceID );
129 @SuppressWarnings("unchecked")
131 public void testInvokeRpc() throws Exception {
132 RpcResult<CompositeNode> expResult = mock( RpcResult.class );
133 Future<RpcResult<CompositeNode>> future = Futures.immediateFuture( expResult );
134 when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future );
136 Future<RpcResult<CompositeNode>> actualFuture = brokerFacade.invokeRpc( qname, dataNode );
137 assertNotNull( "Future is null", actualFuture );
138 RpcResult<CompositeNode> actualResult = actualFuture.get();
140 assertSame( "invokeRpc", expResult, actualResult );
143 @Test(expected=RestconfDocumentedException.class)
144 public void testInvokeRpcWithNoConsumerSession() {
145 brokerFacade.setContext( null );
147 brokerFacade.invokeRpc( qname, dataNode );
151 public void testCommitConfigurationDataPut() {
152 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
154 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
155 mockTransaction.putConfigurationData( instanceID, dataNode );
156 when( mockTransaction.commit() ).thenReturn( expFuture );
158 Future<RpcResult<TransactionStatus>> actualFuture =
159 brokerFacade.commitConfigurationDataPut( instanceID, dataNode );
161 assertSame( "invokeRpc", expFuture, actualFuture );
163 InOrder inOrder = inOrder( dataBroker, mockTransaction );
164 inOrder.verify( dataBroker ).beginTransaction();
165 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
166 inOrder.verify( mockTransaction ).commit();
170 public void testCommitConfigurationDataPutBehindMountPoint() {
171 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
173 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
174 mockTransaction.putConfigurationData( instanceID, dataNode );
175 when( mockTransaction.commit() ).thenReturn( expFuture );
177 Future<RpcResult<TransactionStatus>> actualFuture =
178 brokerFacade.commitConfigurationDataPutBehindMountPoint(
179 mockMountInstance, instanceID, dataNode );
181 assertSame( "invokeRpc", expFuture, actualFuture );
183 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
184 inOrder.verify( mockMountInstance ).beginTransaction();
185 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
186 inOrder.verify( mockTransaction ).commit();
190 public void testCommitConfigurationDataPost() {
191 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
193 Map<InstanceIdentifier, CompositeNode> nodeMap =
194 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
195 .put( instanceID, dataNode ).build();
197 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
198 mockTransaction.putConfigurationData( instanceID, dataNode );
199 when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
200 when( mockTransaction.commit() ).thenReturn( expFuture );
202 Future<RpcResult<TransactionStatus>> actualFuture =
203 brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
205 assertSame( "commitConfigurationDataPut", expFuture, actualFuture );
207 InOrder inOrder = inOrder( dataBroker, mockTransaction );
208 inOrder.verify( dataBroker ).beginTransaction();
209 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
210 inOrder.verify( mockTransaction ).commit();
213 @Test(expected=RestconfDocumentedException.class)
214 public void testCommitConfigurationDataPostAlreadyExists() {
215 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
216 mockTransaction.putConfigurationData( instanceID, dataNode );
217 when ( mockTransaction.readConfigurationData( instanceID ) )
218 .thenReturn( dataNode );
220 brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
222 catch (RestconfDocumentedException e) {
223 assertEquals("getErrorTag",
224 RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag());
230 public void testCommitConfigurationDataPostBehindMountPoint() {
231 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
233 Map<InstanceIdentifier, CompositeNode> nodeMap =
234 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
235 .put( instanceID, dataNode ).build();
237 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
238 mockTransaction.putConfigurationData( instanceID, dataNode );
239 when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
240 when( mockTransaction.commit() ).thenReturn( expFuture );
242 Future<RpcResult<TransactionStatus>> actualFuture =
243 brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
244 instanceID, dataNode );
246 assertSame( "commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture );
248 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
249 inOrder.verify( mockMountInstance ).beginTransaction();
250 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
251 inOrder.verify( mockTransaction ).commit();
254 @Test(expected=RestconfDocumentedException.class)
255 public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() {
257 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
258 mockTransaction.putConfigurationData( instanceID, dataNode );
259 when ( mockTransaction.readConfigurationData( instanceID ) )
260 .thenReturn( dataNode );
262 brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
263 instanceID, dataNode );
265 catch (RestconfDocumentedException e) {
266 assertEquals("getErrorTag",
267 RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag());
273 public void testCommitConfigurationDataDelete() {
274 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
276 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
277 when(mockTransaction.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(
278 ImmutableCompositeNode.builder().toInstance());
279 mockTransaction.removeConfigurationData( instanceID );
280 when( mockTransaction.commit() ).thenReturn( expFuture );
282 Future<RpcResult<TransactionStatus>> actualFuture =
283 brokerFacade.commitConfigurationDataDelete( instanceID );
285 assertSame( "commitConfigurationDataDelete", expFuture, actualFuture );
287 InOrder inOrder = inOrder( dataBroker, mockTransaction );
288 inOrder.verify( dataBroker ).beginTransaction();
289 inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
290 inOrder.verify( mockTransaction ).commit();
294 public void testCommitConfigurationDataDeleteBehindMountPoint() {
295 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
297 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
298 when(mockTransaction.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(
299 ImmutableCompositeNode.builder().toInstance());
300 mockTransaction.removeConfigurationData( instanceID );
301 when( mockTransaction.commit() ).thenReturn( expFuture );
303 Future<RpcResult<TransactionStatus>> actualFuture =
304 brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
305 mockMountInstance, instanceID );
307 assertSame( "commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture );
309 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
310 inOrder.verify( mockMountInstance ).beginTransaction();
311 inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
312 inOrder.verify( mockTransaction ).commit();
315 @SuppressWarnings("unchecked")
317 public void testRegisterToListenDataChanges() {
318 ListenerAdapter listener = Notificator.createListener( instanceID, "stream" );
320 ListenerRegistration<DataChangeListener> mockRegistration = mock( ListenerRegistration.class );
321 when( dataBroker.registerDataChangeListener( instanceID, listener ) )
322 .thenReturn( mockRegistration );
324 brokerFacade.registerToListenDataChanges( listener );
326 verify( dataBroker ).registerDataChangeListener( instanceID, listener );
328 assertEquals( "isListening", true, listener.isListening() );
330 brokerFacade.registerToListenDataChanges( listener );
331 verifyNoMoreInteractions( dataBroker );