2 * Copyright © 2017 Orange, 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.transportpce.common.device;
11 import static org.mockito.Matchers.any;
13 import com.google.common.base.Optional;
14 import com.google.common.util.concurrent.Futures;
15 import com.google.common.util.concurrent.ListenableFuture;
16 import com.google.common.util.concurrent.ListeningExecutorService;
17 import com.google.common.util.concurrent.MoreExecutors;
19 import java.util.LinkedList;
20 import java.util.List;
21 import java.util.concurrent.ExecutionException;
22 import java.util.concurrent.Executors;
23 import java.util.concurrent.Future;
24 import java.util.concurrent.TimeUnit;
25 import java.util.concurrent.TimeoutException;
27 import org.junit.After;
28 import org.junit.Assert;
29 import org.junit.Before;
30 import org.junit.Test;
31 import org.junit.runner.RunWith;
32 import org.mockito.Mock;
33 import org.mockito.Mockito;
34 import org.mockito.runners.MockitoJUnitRunner;
35 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
36 import org.opendaylight.controller.md.sal.binding.api.MountPoint;
37 import org.opendaylight.controller.md.sal.binding.api.MountPointService;
38 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
39 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.Network;
41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkBuilder;
42 import org.opendaylight.yangtools.yang.binding.DataObject;
43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
46 @RunWith(MockitoJUnitRunner.class)
47 public class DeviceTransactionManagerTest {
49 @Mock private MountPointService mountPointServiceMock;
50 @Mock private MountPoint mountPointMock;
51 @Mock private DataBroker dataBrokerMock;
52 @Mock private ReadWriteTransaction rwTransactionMock;
54 private DeviceTransactionManagerImpl transactionManager;
55 private String defaultDeviceId = "device-id";
56 private LogicalDatastoreType defaultDatastore = LogicalDatastoreType.OPERATIONAL;
57 private InstanceIdentifier<Network> defaultIid = InstanceIdentifier.create(Network.class);
58 private Network defaultData = new NetworkBuilder().build();
59 private long defaultTimeout = 1000;
60 private TimeUnit defaultTimeUnit = TimeUnit.MILLISECONDS;
63 public void before() {
64 Mockito.when(mountPointServiceMock.getMountPoint(any())).thenReturn(Optional.of(mountPointMock));
65 Mockito.when(mountPointMock.getService(any())).thenReturn(Optional.of(dataBrokerMock));
66 Mockito.when(dataBrokerMock.newReadWriteTransaction()).thenReturn(rwTransactionMock);
67 Mockito.when(rwTransactionMock.submit()).thenReturn(Futures.immediateCheckedFuture(null));
69 this.transactionManager = new DeviceTransactionManagerImpl(mountPointServiceMock, 3000);
74 transactionManager.preDestroy();
78 public void basicPositiveTransactionTest() {
80 putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData);
81 } catch (InterruptedException | ExecutionException e) {
82 Assert.fail("Exception catched! " + e);
86 Mockito.verify(rwTransactionMock, Mockito.times(1)).put(defaultDatastore, defaultIid, defaultData);
87 Mockito.verify(rwTransactionMock, Mockito.times(1)).submit();
91 public void advancedPositiveTransactionTest() {
93 Future<java.util.Optional<DeviceTransaction>> firstDeviceTxFuture =
94 transactionManager.getDeviceTransaction(defaultDeviceId);
95 DeviceTransaction firstDeviceTx = firstDeviceTxFuture.get().get();
97 Future<java.util.Optional<DeviceTransaction>> secondDeviceTxFuture =
98 transactionManager.getDeviceTransaction(defaultDeviceId);
99 Assert.assertFalse(secondDeviceTxFuture.isDone());
101 Future<java.util.Optional<DeviceTransaction>> thirdDeviceTxFuture =
102 transactionManager.getDeviceTransaction(defaultDeviceId);
103 Assert.assertFalse(thirdDeviceTxFuture.isDone());
105 firstDeviceTx.put(defaultDatastore, defaultIid, defaultData);
106 Assert.assertFalse(secondDeviceTxFuture.isDone());
107 Assert.assertFalse(thirdDeviceTxFuture.isDone());
109 Assert.assertFalse(secondDeviceTxFuture.isDone());
110 Assert.assertFalse(thirdDeviceTxFuture.isDone());
112 Future<java.util.Optional<DeviceTransaction>> anotherDeviceTxFuture =
113 transactionManager.getDeviceTransaction("another-id");
114 Assert.assertTrue(anotherDeviceTxFuture.isDone());
115 anotherDeviceTxFuture.get().get().submit(defaultTimeout, defaultTimeUnit);
117 firstDeviceTx.submit(defaultTimeout, defaultTimeUnit);
119 Assert.assertTrue(secondDeviceTxFuture.isDone());
120 Assert.assertFalse(thirdDeviceTxFuture.isDone());
122 DeviceTransaction secondDeviceTx = secondDeviceTxFuture.get().get();
123 secondDeviceTx.put(defaultDatastore, defaultIid, defaultData);
124 Assert.assertFalse(thirdDeviceTxFuture.isDone());
126 secondDeviceTx.submit(defaultTimeout, defaultTimeUnit);
128 Assert.assertTrue(thirdDeviceTxFuture.isDone());
130 DeviceTransaction thirdDeviceTx = thirdDeviceTxFuture.get().get();
131 thirdDeviceTx.put(defaultDatastore, defaultIid, defaultData);
132 thirdDeviceTx.submit(defaultTimeout, defaultTimeUnit);
134 Mockito.verify(rwTransactionMock, Mockito.times(3)).put(defaultDatastore, defaultIid, defaultData);
135 Mockito.verify(rwTransactionMock, Mockito.times(4)).submit();
136 } catch (InterruptedException | ExecutionException e) {
137 Assert.fail("Exception catched! " + e);
142 public void bigAmountOfTransactionsOnSameDeviceTest() {
143 int numberOfTxs = 100;
144 List<Future<java.util.Optional<DeviceTransaction>>> deviceTransactionFutures = new LinkedList<>();
145 List<DeviceTransaction> deviceTransactions = new LinkedList<>();
147 for (int i = 0; i < numberOfTxs; i++) {
148 deviceTransactionFutures.add(transactionManager.getDeviceTransaction(defaultDeviceId));
152 for (Future<java.util.Optional<DeviceTransaction>> futureTx : deviceTransactionFutures) {
153 DeviceTransaction deviceTx = futureTx.get().get();
154 deviceTx.submit(defaultTimeout, defaultTimeUnit);
155 deviceTransactions.add(deviceTx);
157 } catch (InterruptedException | ExecutionException e) {
158 Assert.fail("Exception catched! " + e);
161 for (DeviceTransaction deviceTx : deviceTransactions) {
162 Assert.assertTrue(deviceTx.wasSubmittedOrCancelled().get());
167 public void bigAmountOfTransactionsOnDifferentDevicesTest() {
168 int numberOfTxs = 1000;
169 List<DeviceTransaction> deviceTransactions = new LinkedList<>();
172 for (int i = 0; i < numberOfTxs; i++) {
173 deviceTransactions.add(transactionManager.getDeviceTransaction(defaultDeviceId + " " + i).get().get());
175 } catch (InterruptedException | ExecutionException e) {
176 Assert.fail("Exception catched! " + e);
179 deviceTransactions.parallelStream()
180 .forEach(deviceTransaction -> deviceTransaction.submit(defaultTimeout, defaultTimeUnit));
182 deviceTransactions.parallelStream()
183 .forEach(deviceTransaction -> Assert.assertTrue(deviceTransaction.wasSubmittedOrCancelled().get()));
187 public void bigAmountOfTransactionsOnDifferentDevicesWithoutSubmitTest() {
188 int numberOfTxs = 1000;
189 List<DeviceTransaction> deviceTransactions = new LinkedList<>();
192 for (int i = 0; i < numberOfTxs; i++) {
193 deviceTransactions.add(transactionManager.getDeviceTransaction(defaultDeviceId + " " + i).get().get());
195 } catch (InterruptedException | ExecutionException e) {
196 Assert.fail("Exception catched! " + e);
200 Thread.sleep(transactionManager.getMaxDurationToSubmitTransaction() + 1000);
201 } catch (InterruptedException e) {
202 Assert.fail("Exception catched! " + e);
204 deviceTransactions.parallelStream()
205 .forEach(deviceTransaction -> Assert.assertTrue(deviceTransaction.wasSubmittedOrCancelled().get()));
209 public void notSubmittedTransactionTest() {
210 Future<java.util.Optional<DeviceTransaction>> deviceTxFuture =
211 transactionManager.getDeviceTransaction(defaultDeviceId);
213 deviceTxFuture.get();
214 Thread.sleep(transactionManager.getMaxDurationToSubmitTransaction() + 1000);
215 } catch (InterruptedException | ExecutionException e) {
216 Assert.fail("Exception catched! " + e);
218 Mockito.verify(rwTransactionMock, Mockito.times(1)).cancel();
221 putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData);
222 } catch (InterruptedException | ExecutionException e) {
223 Assert.fail("Exception catched! " + e);
227 Mockito.verify(rwTransactionMock, Mockito.times(1)).cancel();
228 Mockito.verify(rwTransactionMock, Mockito.times(1)).put(defaultDatastore, defaultIid, defaultData);
229 Mockito.verify(rwTransactionMock, Mockito.times(1)).submit();
233 public void dataBrokerTimeoutTransactionTest() {
234 Mockito.when(dataBrokerMock.newReadWriteTransaction()).then(invocation -> {
235 Thread.sleep(transactionManager.getMaxDurationToSubmitTransaction() + 1000);
236 return rwTransactionMock;
240 putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData);
241 } catch (InterruptedException | ExecutionException e) {
242 Assert.fail("Exception catched! " + e);
245 Mockito.verify(rwTransactionMock, Mockito.times(1)).submit();
247 Mockito.when(dataBrokerMock.newReadWriteTransaction()).thenReturn(rwTransactionMock); // remove sleep
250 putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData);
251 } catch (InterruptedException | ExecutionException e) {
252 Assert.fail("Exception catched! " + e);
256 Mockito.verify(rwTransactionMock, Mockito.times(2)).put(defaultDatastore, defaultIid, defaultData);
257 Mockito.verify(rwTransactionMock, Mockito.times(2)).submit();
261 public void getFutureTimeoutTransactionTest() {
262 Mockito.when(dataBrokerMock.newReadWriteTransaction()).then(invocation -> {
264 return rwTransactionMock;
267 Exception throwedException = null;
269 Future<java.util.Optional<DeviceTransaction>> deviceTxFuture =
270 transactionManager.getDeviceTransaction(defaultDeviceId);
272 deviceTxFuture.get(1000, TimeUnit.MILLISECONDS);
273 } catch (InterruptedException | ExecutionException e) {
274 Assert.fail("Exception catched! " + e);
275 } catch (TimeoutException e) {
276 throwedException = e;
279 if (throwedException == null) {
280 Assert.fail("TimeoutException should be thrown!");
284 Mockito.when(dataBrokerMock.newReadWriteTransaction()).thenReturn(rwTransactionMock); // remove sleep
287 putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData);
288 } catch (InterruptedException | ExecutionException e) {
289 Assert.fail("Exception catched! " + e);
293 Mockito.verify(rwTransactionMock, Mockito.times(1)).put(defaultDatastore, defaultIid, defaultData);
294 Mockito.verify(rwTransactionMock, Mockito.times(1)).submit();
298 public void submitTxTimeoutTransactionTest() {
299 ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
300 Mockito.when(rwTransactionMock.submit()).then(invocation -> Futures.makeChecked(executor.submit(() -> {
303 } catch (InterruptedException e) {
304 Assert.fail("Exception catched in future! " + e);
307 }), input -> input));
309 Future<java.util.Optional<DeviceTransaction>> deviceTxFuture =
310 transactionManager.getDeviceTransaction(defaultDeviceId);
311 DeviceTransaction deviceTx;
313 deviceTx = deviceTxFuture.get().get();
314 } catch (InterruptedException | ExecutionException e) {
315 Assert.fail("Exception catched! " + e);
319 deviceTx.put(defaultDatastore, defaultIid, defaultData);
321 Exception throwedException = null;
323 ListenableFuture<Void> submitFuture = deviceTx.submit(200, defaultTimeUnit);
326 } catch (InterruptedException e) {
327 Assert.fail("Exception catched! " + e);
328 } catch (ExecutionException e) {
329 throwedException = e;
332 if (throwedException == null
333 || !throwedException.getMessage().contains(TimeoutException.class.getName())) {
334 Assert.fail("TimeoutException inside of should be thrown!");
339 Mockito.when(rwTransactionMock.submit()).thenReturn(Futures.immediateCheckedFuture(null));
342 putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData);
343 } catch (InterruptedException | ExecutionException e) {
344 Assert.fail("Exception catched! " + e);
348 Mockito.verify(rwTransactionMock, Mockito.times(2)).put(defaultDatastore, defaultIid, defaultData);
349 Mockito.verify(rwTransactionMock, Mockito.times(2)).submit();
354 private <T extends DataObject> void putAndSubmit(DeviceTransactionManagerImpl deviceTxManager, String deviceId,
355 LogicalDatastoreType store, InstanceIdentifier<T> path, T data)
356 throws ExecutionException, InterruptedException {
357 Future<java.util.Optional<DeviceTransaction>> deviceTxFuture = deviceTxManager.getDeviceTransaction(deviceId);
358 DeviceTransaction deviceTx = deviceTxFuture.get().get();
359 deviceTx.put(store, path, data);
360 deviceTx.submit(defaultTimeout, defaultTimeUnit);