opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/BrokerFacadeTest.java

   1 /*
   2  * Copyright (c) ${year} Brocade Communications Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.controller.sal.restconf.impl.test;
  10
  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;
  20
  21 import com.google.common.collect.ImmutableMap;
  22 import com.google.common.util.concurrent.Futures;
  23 import java.util.Map;
  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;
  48
  49 /**
  50  * Unit tests for BrokerFacade.
  51  *
  52  * @author Thomas Pantelis
  53  */
  54 public class BrokerFacadeTest {
  55
  56     @Mock
  57     DataBrokerService dataBroker;
  58
  59     @Mock
  60     DataModificationTransaction mockTransaction;
  61
  62     @Mock
  63     ConsumerSession mockConsumerSession;
  64
  65     @Mock
  66     MountInstance mockMountInstance;
  67
  68     BrokerFacade brokerFacade = BrokerFacade.getInstance();
  69
  70     CompositeNode dataNode = TestUtils.readInputToCnSn("/parts/ietf-interfaces_interfaces.xml",
  71             XmlToCompositeNodeProvider.INSTANCE);
  72
  73     QName qname = QName.create("node");
  74
  75     YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).toInstance();
  76
  77     @Before
  78     public void setUp() throws Exception {
  79         MockitoAnnotations.initMocks(this);
  80
  81         brokerFacade.setDataService(dataBroker);
  82         brokerFacade.setContext(mockConsumerSession);
  83     }
  84
  85     @Test
  86     public void testReadConfigurationData() {
  87         when(dataBroker.readConfigurationData(instanceID)).thenReturn(dataNode);
  88
  89         CompositeNode actualNode = brokerFacade.readConfigurationData(instanceID);
  90
  91         assertSame("readConfigurationData", dataNode, actualNode);
  92     }
  93
  94     @Test
  95     public void testReadConfigurationDataBehindMountPoint() {
  96         when(mockMountInstance.readConfigurationData(instanceID)).thenReturn(dataNode);
  97
  98         CompositeNode actualNode = brokerFacade.readConfigurationDataBehindMountPoint(mockMountInstance, instanceID);
  99
 100         assertSame("readConfigurationDataBehindMountPoint", dataNode, actualNode);
 101     }
 102
 103     @Test
 104     public void testReadOperationalData() {
 105         when(dataBroker.readOperationalData(instanceID)).thenReturn(dataNode);
 106
 107         CompositeNode actualNode = brokerFacade.readOperationalData(instanceID);
 108
 109         assertSame("readOperationalData", dataNode, actualNode);
 110     }
 111
 112     @Test
 113     public void testReadOperationalDataBehindMountPoint() {
 114         when(mockMountInstance.readOperationalData(instanceID)).thenReturn(dataNode);
 115
 116         CompositeNode actualNode = brokerFacade.readOperationalDataBehindMountPoint(mockMountInstance, instanceID);
 117
 118         assertSame("readOperationalDataBehindMountPoint", dataNode, actualNode);
 119     }
 120
 121     @Test(expected = RestconfDocumentedException.class)
 122     public void testReadOperationalDataWithNoDataBroker() {
 123         brokerFacade.setDataService(null);
 124
 125         brokerFacade.readOperationalData(instanceID);
 126     }
 127
 128     @SuppressWarnings("unchecked")
 129     @Test
 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);
 134
 135         Future<RpcResult<CompositeNode>> actualFuture = brokerFacade.invokeRpc(qname, dataNode);
 136         assertNotNull("Future is null", actualFuture);
 137         RpcResult<CompositeNode> actualResult = actualFuture.get();
 138
 139         assertSame("invokeRpc", expResult, actualResult);
 140     }
 141
 142     @Test(expected = RestconfDocumentedException.class)
 143     public void testInvokeRpcWithNoConsumerSession() {
 144         brokerFacade.setContext(null);
 145
 146         brokerFacade.invokeRpc(qname, dataNode);
 147     }
 148
 149     @Test
 150     public void testCommitConfigurationDataPut() {
 151         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 152
 153         when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
 154         mockTransaction.putConfigurationData(instanceID, dataNode);
 155         when(mockTransaction.commit()).thenReturn(expFuture);
 156
 157         Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPut(instanceID,
 158                 dataNode);
 159
 160         assertSame("invokeRpc", expFuture, actualFuture);
 161
 162         InOrder inOrder = inOrder(dataBroker, mockTransaction);
 163         inOrder.verify(dataBroker).beginTransaction();
 164         inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
 165         inOrder.verify(mockTransaction).commit();
 166     }
 167
 168     @Test
 169     public void testCommitConfigurationDataPutBehindMountPoint() {
 170         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 171
 172         when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
 173         mockTransaction.putConfigurationData(instanceID, dataNode);
 174         when(mockTransaction.commit()).thenReturn(expFuture);
 175
 176         Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPutBehindMountPoint(
 177                 mockMountInstance, instanceID, dataNode);
 178
 179         assertSame("invokeRpc", expFuture, actualFuture);
 180
 181         InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
 182         inOrder.verify(mockMountInstance).beginTransaction();
 183         inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
 184         inOrder.verify(mockTransaction).commit();
 185     }
 186
 187     @Test
 188     public void testCommitConfigurationDataPost() {
 189         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 190
 191         Map<YangInstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<YangInstanceIdentifier, CompositeNode>()
 192                 .put(instanceID, dataNode).build();
 193
 194         when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
 195         mockTransaction.putConfigurationData(instanceID, dataNode);
 196         when(mockTransaction.getCreatedConfigurationData()).thenReturn(nodeMap);
 197         when(mockTransaction.commit()).thenReturn(expFuture);
 198
 199         Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPost(instanceID,
 200                 dataNode);
 201
 202         assertSame("commitConfigurationDataPut", expFuture, actualFuture);
 203
 204         InOrder inOrder = inOrder(dataBroker, mockTransaction);
 205         inOrder.verify(dataBroker).beginTransaction();
 206         inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
 207         inOrder.verify(mockTransaction).commit();
 208     }
 209
 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);
 215         try {
 216             brokerFacade.commitConfigurationDataPost(instanceID, dataNode);
 217         } catch (RestconfDocumentedException e) {
 218             assertEquals("getErrorTag", RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag());
 219             throw e;
 220         }
 221     }
 222
 223     @Test
 224     public void testCommitConfigurationDataPostBehindMountPoint() {
 225         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 226
 227         Map<YangInstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<YangInstanceIdentifier, CompositeNode>()
 228                 .put(instanceID, dataNode).build();
 229
 230         when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
 231         mockTransaction.putConfigurationData(instanceID, dataNode);
 232         when(mockTransaction.getCreatedConfigurationData()).thenReturn(nodeMap);
 233         when(mockTransaction.commit()).thenReturn(expFuture);
 234
 235         Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataPostBehindMountPoint(
 236                 mockMountInstance, instanceID, dataNode);
 237
 238         assertSame("commitConfigurationDataPostBehindMountPoint", expFuture, actualFuture);
 239
 240         InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
 241         inOrder.verify(mockMountInstance).beginTransaction();
 242         inOrder.verify(mockTransaction).putConfigurationData(instanceID, dataNode);
 243         inOrder.verify(mockTransaction).commit();
 244     }
 245
 246     @Test(expected = RestconfDocumentedException.class)
 247     public void testCommitConfigurationDataPostBehindMountPointAlreadyExists() {
 248
 249         when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
 250         mockTransaction.putConfigurationData(instanceID, dataNode);
 251         when(mockTransaction.readConfigurationData(instanceID)).thenReturn(dataNode);
 252         try {
 253             brokerFacade.commitConfigurationDataPostBehindMountPoint(mockMountInstance, instanceID, dataNode);
 254         } catch (RestconfDocumentedException e) {
 255             assertEquals("getErrorTag", RestconfError.ErrorTag.DATA_EXISTS, e.getErrors().get(0).getErrorTag());
 256             throw e;
 257         }
 258     }
 259
 260     @Test
 261     public void testCommitConfigurationDataDelete() {
 262         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 263
 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);
 269
 270         Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataDelete(instanceID);
 271
 272         assertSame("commitConfigurationDataDelete", expFuture, actualFuture);
 273
 274         InOrder inOrder = inOrder(dataBroker, mockTransaction);
 275         inOrder.verify(dataBroker).beginTransaction();
 276         inOrder.verify(mockTransaction).removeConfigurationData(instanceID);
 277         inOrder.verify(mockTransaction).commit();
 278     }
 279
 280     @Test
 281     public void testCommitConfigurationDataDeleteBehindMountPoint() {
 282         Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
 283
 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);
 289
 290         Future<RpcResult<TransactionStatus>> actualFuture = brokerFacade.commitConfigurationDataDeleteBehindMountPoint(
 291                 mockMountInstance, instanceID);
 292
 293         assertSame("commitConfigurationDataDeleteBehindMountPoint", expFuture, actualFuture);
 294
 295         InOrder inOrder = inOrder(mockMountInstance, mockTransaction);
 296         inOrder.verify(mockMountInstance).beginTransaction();
 297         inOrder.verify(mockTransaction).removeConfigurationData(instanceID);
 298         inOrder.verify(mockTransaction).commit();
 299     }
 300
 301     @SuppressWarnings("unchecked")
 302     @Test
 303     public void testRegisterToListenDataChanges() {
 304         ListenerAdapter listener = Notificator.createListener(instanceID, "stream");
 305
 306         ListenerRegistration<DataChangeListener> mockRegistration = mock(ListenerRegistration.class);
 307         when(dataBroker.registerDataChangeListener(instanceID, listener)).thenReturn(mockRegistration);
 308
 309         brokerFacade.registerToListenDataChanges(listener);
 310
 311         verify(dataBroker).registerDataChangeListener(instanceID, listener);
 312
 313         assertEquals("isListening", true, listener.isListening());
 314
 315         brokerFacade.registerToListenDataChanges(listener);
 316         verifyNoMoreInteractions(dataBroker);
 317     }
 318 }