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.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;
21 import java.util.concurrent.Future;
23 import org.junit.Before;
24 import org.junit.Test;
25 import org.mockito.InOrder;
26 import org.mockito.Mock;
27 import org.mockito.MockitoAnnotations;
28 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
29 import org.opendaylight.controller.sal.core.api.Broker.ConsumerSession;
30 import org.opendaylight.controller.sal.core.api.data.DataBrokerService;
31 import org.opendaylight.controller.sal.core.api.data.DataChangeListener;
32 import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
33 import org.opendaylight.controller.sal.core.api.mount.MountInstance;
34 import org.opendaylight.controller.sal.rest.impl.XmlToCompositeNodeProvider;
35 import org.opendaylight.controller.sal.restconf.impl.BrokerFacade;
36 import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
37 import org.opendaylight.controller.sal.restconf.impl.RestconfError;
38 import org.opendaylight.controller.sal.streams.listeners.ListenerAdapter;
39 import org.opendaylight.controller.sal.streams.listeners.Notificator;
40 import org.opendaylight.yangtools.concepts.ListenerRegistration;
41 import org.opendaylight.yangtools.yang.common.QName;
42 import org.opendaylight.yangtools.yang.common.RpcResult;
43 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
44 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
46 import com.google.common.collect.ImmutableMap;
47 import com.google.common.util.concurrent.Futures;
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 InstanceIdentifier instanceID = InstanceIdentifier.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(
99 mockMountInstance, instanceID );
101 assertSame( "readConfigurationDataBehindMountPoint", dataNode, actualNode );
105 public void testReadOperationalData() {
106 when( dataBroker.readOperationalData( instanceID ) ).thenReturn( dataNode );
108 CompositeNode actualNode = brokerFacade.readOperationalData( instanceID );
110 assertSame( "readOperationalData", dataNode, actualNode );
114 public void testReadOperationalDataBehindMountPoint() {
115 when( mockMountInstance.readOperationalData( instanceID ) ).thenReturn( dataNode );
117 CompositeNode actualNode = brokerFacade.readOperationalDataBehindMountPoint(
118 mockMountInstance, instanceID );
120 assertSame( "readOperationalDataBehindMountPoint", dataNode, actualNode );
123 @Test(expected=RestconfDocumentedException.class)
124 public void testReadOperationalDataWithNoDataBroker() {
125 brokerFacade.setDataService( null );
127 brokerFacade.readOperationalData( instanceID );
130 @SuppressWarnings("unchecked")
132 public void testInvokeRpc() throws Exception {
133 RpcResult<CompositeNode> expResult = mock( RpcResult.class );
134 Future<RpcResult<CompositeNode>> future = Futures.immediateFuture( expResult );
135 when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future );
137 Future<RpcResult<CompositeNode>> actualFuture = brokerFacade.invokeRpc( qname, dataNode );
138 assertNotNull( "Future is null", actualFuture );
139 RpcResult<CompositeNode> actualResult = actualFuture.get();
141 assertSame( "invokeRpc", expResult, actualResult );
144 @Test(expected=RestconfDocumentedException.class)
145 public void testInvokeRpcWithNoConsumerSession() {
146 brokerFacade.setContext( null );
148 brokerFacade.invokeRpc( qname, dataNode );
152 public void testCommitConfigurationDataPut() {
153 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
155 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
156 mockTransaction.putConfigurationData( instanceID, dataNode );
157 when( mockTransaction.commit() ).thenReturn( expFuture );
159 Future<RpcResult<TransactionStatus>> actualFuture =
160 brokerFacade.commitConfigurationDataPut( instanceID, dataNode );
162 assertSame( "invokeRpc", expFuture, actualFuture );
164 InOrder inOrder = inOrder( dataBroker, mockTransaction );
165 inOrder.verify( dataBroker ).beginTransaction();
166 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
167 inOrder.verify( mockTransaction ).commit();
171 public void testCommitConfigurationDataPutBehindMountPoint() {
172 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
174 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
175 mockTransaction.putConfigurationData( instanceID, dataNode );
176 when( mockTransaction.commit() ).thenReturn( expFuture );
178 Future<RpcResult<TransactionStatus>> actualFuture =
179 brokerFacade.commitConfigurationDataPutBehindMountPoint(
180 mockMountInstance, instanceID, dataNode );
182 assertSame( "invokeRpc", expFuture, actualFuture );
184 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
185 inOrder.verify( mockMountInstance ).beginTransaction();
186 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
187 inOrder.verify( mockTransaction ).commit();
191 public void testCommitConfigurationDataPost() {
192 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
194 Map<InstanceIdentifier, CompositeNode> nodeMap =
195 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
196 .put( instanceID, dataNode ).build();
198 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
199 mockTransaction.putConfigurationData( instanceID, dataNode );
200 when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
201 when( mockTransaction.commit() ).thenReturn( expFuture );
203 Future<RpcResult<TransactionStatus>> actualFuture =
204 brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
206 assertSame( "commitConfigurationDataPut", expFuture, actualFuture );
208 InOrder inOrder = inOrder( dataBroker, mockTransaction );
209 inOrder.verify( dataBroker ).beginTransaction();
210 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
211 inOrder.verify( mockTransaction ).commit();
214 @Test(expected=RestconfDocumentedException.class)
215 public void testCommitConfigurationDataPostAlreadyExists() {
216 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
217 mockTransaction.putConfigurationData( instanceID, dataNode );
218 when ( mockTransaction.readConfigurationData( instanceID ) )
219 .thenReturn( dataNode );
221 brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
223 catch (RestconfDocumentedException e) {
224 assertEquals("getErrorTag",
225 RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag());
231 public void testCommitConfigurationDataPostBehindMountPoint() {
232 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
234 Map<InstanceIdentifier, CompositeNode> nodeMap =
235 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
236 .put( instanceID, dataNode ).build();
238 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
239 mockTransaction.putConfigurationData( instanceID, dataNode );
240 when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
241 when( mockTransaction.commit() ).thenReturn( expFuture );
243 Future<RpcResult<TransactionStatus>> actualFuture =
244 brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
245 instanceID, dataNode );
247 assertSame( "commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture );
249 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
250 inOrder.verify( mockMountInstance ).beginTransaction();
251 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
252 inOrder.verify( mockTransaction ).commit();
255 @Test(expected=RestconfDocumentedException.class)
256 public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() {
258 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
259 mockTransaction.putConfigurationData( instanceID, dataNode );
260 when ( mockTransaction.readConfigurationData( instanceID ) )
261 .thenReturn( dataNode );
263 brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
264 instanceID, dataNode );
266 catch (RestconfDocumentedException e) {
267 assertEquals("getErrorTag",
268 RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get( 0 ).getErrorTag());
274 public void testCommitConfigurationDataDelete() {
275 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
277 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
278 mockTransaction.removeConfigurationData( instanceID );
279 when( mockTransaction.commit() ).thenReturn( expFuture );
281 Future<RpcResult<TransactionStatus>> actualFuture =
282 brokerFacade.commitConfigurationDataDelete( instanceID );
284 assertSame( "commitConfigurationDataDelete", expFuture, actualFuture );
286 InOrder inOrder = inOrder( dataBroker, mockTransaction );
287 inOrder.verify( dataBroker ).beginTransaction();
288 inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
289 inOrder.verify( mockTransaction ).commit();
293 public void testCommitConfigurationDataDeleteBehindMountPoint() {
294 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
296 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
297 mockTransaction.removeConfigurationData( instanceID );
298 when( mockTransaction.commit() ).thenReturn( expFuture );
300 Future<RpcResult<TransactionStatus>> actualFuture =
301 brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
302 mockMountInstance, instanceID );
304 assertSame( "commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture );
306 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
307 inOrder.verify( mockMountInstance ).beginTransaction();
308 inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
309 inOrder.verify( mockTransaction ).commit();
312 @SuppressWarnings("unchecked")
314 public void testRegisterToListenDataChanges() {
315 ListenerAdapter listener = Notificator.createListener( instanceID, "stream" );
317 ListenerRegistration<DataChangeListener> mockRegistration = mock( ListenerRegistration.class );
318 when( dataBroker.registerDataChangeListener( instanceID, listener ) )
319 .thenReturn( mockRegistration );
321 brokerFacade.registerToListenDataChanges( listener );
323 verify( dataBroker ).registerDataChangeListener( instanceID, listener );
325 assertEquals( "isListening", true, listener.isListening() );
327 brokerFacade.registerToListenDataChanges( listener );
328 verifyNoMoreInteractions( dataBroker );