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.assertSame;
13 import static org.mockito.Mockito.inOrder;
14 import static org.mockito.Mockito.mock;
15 import static org.mockito.Mockito.verify;
16 import static org.mockito.Mockito.verifyNoMoreInteractions;
17 import static org.mockito.Mockito.when;
20 import java.util.concurrent.Future;
22 import javax.ws.rs.core.Response.Status;
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.ResponseException;
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=ResponseException.class)
124 public void testReadOperationalDataWithNoDataBroker() {
125 brokerFacade.setDataService( null );
127 brokerFacade.readOperationalData( instanceID );
130 @SuppressWarnings("unchecked")
132 public void testInvokeRpc() {
133 RpcResult<CompositeNode> expResult = mock( RpcResult.class );
134 Future<RpcResult<CompositeNode>> future = Futures.immediateFuture( expResult );
135 when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future );
137 RpcResult<CompositeNode> actualResult = brokerFacade.invokeRpc( qname, dataNode );
139 assertSame( "invokeRpc", expResult, actualResult );
142 @Test(expected=ResponseException.class)
143 public void testInvokeRpcWithException() {
144 Exception mockEx = new Exception( "mock" );
145 Future<RpcResult<CompositeNode>> future = Futures.immediateFailedFuture( mockEx );
146 when( mockConsumerSession.rpc( qname, dataNode ) ).thenReturn( future );
148 brokerFacade.invokeRpc( qname, dataNode );
151 @Test(expected=ResponseException.class)
152 public void testInvokeRpcWithNoConsumerSession() {
153 brokerFacade.setContext( null );
155 brokerFacade.invokeRpc( qname, dataNode );
159 public void testCommitConfigurationDataPut() {
160 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
162 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
163 mockTransaction.putConfigurationData( instanceID, dataNode );
164 when( mockTransaction.commit() ).thenReturn( expFuture );
166 Future<RpcResult<TransactionStatus>> actualFuture =
167 brokerFacade.commitConfigurationDataPut( instanceID, dataNode );
169 assertSame( "invokeRpc", expFuture, actualFuture );
171 InOrder inOrder = inOrder( dataBroker, mockTransaction );
172 inOrder.verify( dataBroker ).beginTransaction();
173 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
174 inOrder.verify( mockTransaction ).commit();
178 public void testCommitConfigurationDataPutBehindMountPoint() {
179 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
181 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
182 mockTransaction.putConfigurationData( instanceID, dataNode );
183 when( mockTransaction.commit() ).thenReturn( expFuture );
185 Future<RpcResult<TransactionStatus>> actualFuture =
186 brokerFacade.commitConfigurationDataPutBehindMountPoint(
187 mockMountInstance, instanceID, dataNode );
189 assertSame( "invokeRpc", expFuture, actualFuture );
191 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
192 inOrder.verify( mockMountInstance ).beginTransaction();
193 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
194 inOrder.verify( mockTransaction ).commit();
198 public void testCommitConfigurationDataPost() {
199 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
201 Map<InstanceIdentifier, CompositeNode> nodeMap =
202 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
203 .put( instanceID, dataNode ).build();
205 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
206 mockTransaction.putConfigurationData( instanceID, dataNode );
207 when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
208 when( mockTransaction.commit() ).thenReturn( expFuture );
210 Future<RpcResult<TransactionStatus>> actualFuture =
211 brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
213 assertSame( "commitConfigurationDataPut", expFuture, actualFuture );
215 InOrder inOrder = inOrder( dataBroker, mockTransaction );
216 inOrder.verify( dataBroker ).beginTransaction();
217 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
218 inOrder.verify( mockTransaction ).commit();
221 @Test(expected=ResponseException.class)
222 public void testCommitConfigurationDataPostAlreadyExists() {
223 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
224 mockTransaction.putConfigurationData( instanceID, dataNode );
225 when ( mockTransaction.readConfigurationData( instanceID ) )
226 .thenReturn( dataNode );
228 brokerFacade.commitConfigurationDataPost( instanceID, dataNode );
229 } catch (ResponseException e) {
230 assertEquals("Unexpect Exception Status -> "
231 + "http://tools.ietf.org/html/draft-bierman-netconf-restconf-03#page-48",
232 (e.getResponse().getStatus()), Status.CONFLICT.getStatusCode());
238 public void testCommitConfigurationDataPostBehindMountPoint() {
239 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
241 Map<InstanceIdentifier, CompositeNode> nodeMap =
242 new ImmutableMap.Builder<InstanceIdentifier,CompositeNode>()
243 .put( instanceID, dataNode ).build();
245 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
246 mockTransaction.putConfigurationData( instanceID, dataNode );
247 when( mockTransaction.getCreatedConfigurationData() ).thenReturn( nodeMap );
248 when( mockTransaction.commit() ).thenReturn( expFuture );
250 Future<RpcResult<TransactionStatus>> actualFuture =
251 brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
252 instanceID, dataNode );
254 assertSame( "commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture );
256 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
257 inOrder.verify( mockMountInstance ).beginTransaction();
258 inOrder.verify( mockTransaction ).putConfigurationData( instanceID, dataNode );
259 inOrder.verify( mockTransaction ).commit();
262 @Test(expected=ResponseException.class)
263 public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() {
265 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
266 mockTransaction.putConfigurationData( instanceID, dataNode );
267 when ( mockTransaction.readConfigurationData( instanceID ) )
268 .thenReturn( dataNode );
270 brokerFacade.commitConfigurationDataPostBehindMountPoint( mockMountInstance,
271 instanceID, dataNode );
272 } catch (ResponseException e) {
273 assertEquals("Unexpect Exception Status -> "
274 + "http://tools.ietf.org/html/draft-bierman-netconf-restconf-03#page-48",
275 e.getResponse().getStatus(), Status.CONFLICT.getStatusCode());
281 public void testCommitConfigurationDataDelete() {
282 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
284 when( dataBroker.beginTransaction() ).thenReturn( mockTransaction );
285 mockTransaction.removeConfigurationData( instanceID );
286 when( mockTransaction.commit() ).thenReturn( expFuture );
288 Future<RpcResult<TransactionStatus>> actualFuture =
289 brokerFacade.commitConfigurationDataDelete( instanceID );
291 assertSame( "commitConfigurationDataDelete", expFuture, actualFuture );
293 InOrder inOrder = inOrder( dataBroker, mockTransaction );
294 inOrder.verify( dataBroker ).beginTransaction();
295 inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
296 inOrder.verify( mockTransaction ).commit();
300 public void testCommitConfigurationDataDeleteBehindMountPoint() {
301 Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture( null );
303 when( mockMountInstance.beginTransaction() ).thenReturn( mockTransaction );
304 mockTransaction.removeConfigurationData( instanceID );
305 when( mockTransaction.commit() ).thenReturn( expFuture );
307 Future<RpcResult<TransactionStatus>> actualFuture =
308 brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
309 mockMountInstance, instanceID );
311 assertSame( "commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture );
313 InOrder inOrder = inOrder( mockMountInstance, mockTransaction );
314 inOrder.verify( mockMountInstance ).beginTransaction();
315 inOrder.verify( mockTransaction ).removeConfigurationData( instanceID );
316 inOrder.verify( mockTransaction ).commit();
319 @SuppressWarnings("unchecked")
321 public void testRegisterToListenDataChanges() {
322 ListenerAdapter listener = Notificator.createListener( instanceID, "stream" );
324 ListenerRegistration<DataChangeListener> mockRegistration = mock( ListenerRegistration.class );
325 when( dataBroker.registerDataChangeListener( instanceID, listener ) )
326 .thenReturn( mockRegistration );
328 brokerFacade.registerToListenDataChanges( listener );
330 verify( dataBroker ).registerDataChangeListener( instanceID, listener );
332 assertEquals( "isListening", true, listener.isListening() );
334 brokerFacade.registerToListenDataChanges( listener );
335 verifyNoMoreInteractions( dataBroker );