Remove AsyncWriteTransaction.submit() impls
[genius.git] / mdsalutil / mdsalutil-testutils / src / test / java / org / opendaylight / genius / datastoreutils / testutils / tests / DataBrokerFailuresTest.java
1 /*
2  * Copyright (c) 2017 Red Hat, 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 package org.opendaylight.genius.datastoreutils.testutils.tests;
9
10 import static org.junit.Assert.assertTrue;
11 import static org.junit.Assert.fail;
12 import static org.junit.runners.MethodSorters.NAME_ASCENDING;
13 import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
14
15 import java.util.concurrent.ExecutionException;
16 import java.util.concurrent.TimeUnit;
17 import java.util.concurrent.TimeoutException;
18 import javax.inject.Inject;
19 import org.junit.Before;
20 import org.junit.FixMethodOrder;
21 import org.junit.Rule;
22 import org.junit.Test;
23 import org.junit.rules.MethodRule;
24 import org.mockito.Mockito;
25 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
26 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
27 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
28 import org.opendaylight.genius.datastoreutils.testutils.DataBrokerFailures;
29 import org.opendaylight.genius.datastoreutils.testutils.DataBrokerFailuresModule;
30 import org.opendaylight.infrautils.inject.guice.testutils.AnnotationsModule;
31 import org.opendaylight.infrautils.inject.guice.testutils.GuiceRule;
32
33 /**
34  * Unit test for DataBrokerFailuresImpl.
35  *
36  * @author Michael Vorburger.ch
37  */
38 @FixMethodOrder(NAME_ASCENDING)
39 public class DataBrokerFailuresTest {
40
41     private final DataBroker mockDataBroker = Mockito.mock(DataBroker.class, RETURNS_DEEP_STUBS);
42
43     public @Rule MethodRule guice = new GuiceRule(
44             new DataBrokerFailuresModule(mockDataBroker), new AnnotationsModule());
45
46     @Inject DataBrokerFailures dbFailures;
47     @Inject DataBroker dataBroker;
48
49     @Before
50     public void setup() {
51
52     }
53
54     @Test
55     public void testFailReadWriteTransactionSubmit() throws TimeoutException, InterruptedException {
56         dbFailures.failSubmits(new OptimisticLockFailedException("bada boum bam!"));
57         checkSubmitFails();
58         // Now make sure that it still fails, and not just once:
59         checkSubmitFails();
60         // and still:
61         checkSubmitFails();
62     }
63
64     private void checkSubmitFails() throws TimeoutException, InterruptedException {
65         try {
66             dataBroker.newReadWriteTransaction().commit().get(5, TimeUnit.SECONDS);
67             fail("This should have lead to a TransactionCommitFailedException!");
68         } catch (ExecutionException e) {
69             assertTrue("Expected TransactionCommitFailedException",
70                     e.getCause() instanceof TransactionCommitFailedException);
71         }
72     }
73
74     @Test
75     public void testFailReadWriteTransactionSubmitNext()
76             throws TimeoutException, InterruptedException, ExecutionException {
77         // This must pass (the failSubmits from previous test cannot affect this)
78         // (It's a completely new instance of DataBroker & DataBrokerFailures anyways, but just to be to sure.)
79         dataBroker.newReadWriteTransaction().commit().get(5, TimeUnit.SECONDS);
80     }
81
82     @Test
83     public void testFailTwoReadWriteTransactionSubmit()
84             throws TimeoutException, InterruptedException, ExecutionException {
85         dbFailures.failSubmits(2, new OptimisticLockFailedException("bada boum bam!"));
86         checkSubmitFails();
87         // Now make sure that it still fails again a 2nd time, and not just once:
88         checkSubmitFails();
89         // But now it should pass.. because we specified howManyTimes = 2 above
90         dataBroker.newReadWriteTransaction().commit().get(5, TimeUnit.SECONDS);
91         dataBroker.newWriteOnlyTransaction().commit().get(5, TimeUnit.SECONDS);
92         dataBroker.newReadWriteTransaction().commit().get(5, TimeUnit.SECONDS);
93     }
94
95     @Test(expected = OptimisticLockFailedException.class)
96     @SuppressWarnings("checkstyle:AvoidHidingCauseException")
97     public void testFailWriteTransactionSubmit()
98             throws TimeoutException, InterruptedException, TransactionCommitFailedException {
99         dbFailures.failSubmits(new OptimisticLockFailedException("bada boum bam!"));
100         try {
101             dataBroker.newWriteOnlyTransaction().commit().get(5, TimeUnit.SECONDS);
102         } catch (ExecutionException e) {
103             assertTrue("Expected TransactionCommitFailedException",
104                     e.getCause() instanceof TransactionCommitFailedException);
105             throw (TransactionCommitFailedException)e.getCause();
106         }
107     }
108
109     @Test
110     public void testUnfailSubmits() throws TimeoutException, InterruptedException, ExecutionException {
111         dbFailures.failSubmits(new OptimisticLockFailedException("bada boum bam!"));
112         checkSubmitFails();
113         dbFailures.unfailSubmits();
114         dataBroker.newReadWriteTransaction().commit().get(5, TimeUnit.SECONDS);
115         dataBroker.newWriteOnlyTransaction().commit().get(5, TimeUnit.SECONDS);
116         dataBroker.newReadWriteTransaction().commit().get(5, TimeUnit.SECONDS);
117     }
118
119     @Test
120     public void testFailButSubmitsAnywaysReadWriteTransaction() throws TimeoutException, InterruptedException {
121         dbFailures.failButSubmitsAnyways();
122         checkSubmitFails();
123     }
124
125     // TODO make this work for TransactionChain as well ...
126
127 }