*/
package org.opendaylight.controller.cluster.databroker;
-import java.lang.reflect.Field;
-import org.junit.Assert;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
import org.opendaylight.controller.cluster.access.concepts.FrontendIdentifier;
import org.opendaylight.controller.cluster.access.concepts.FrontendType;
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.controller.cluster.databroker.actors.dds.AbstractClientHandle;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientLocalHistory;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientSnapshot;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientTransaction;
import org.opendaylight.controller.cluster.databroker.actors.dds.DataStoreClient;
import org.opendaylight.controller.cluster.datastore.DatastoreContext;
-import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
-import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.controller.cluster.datastore.utils.ActorUtils;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
+import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class ClientBackedDataStoreTest {
private static final ClientIdentifier UNKNOWN_ID = ClientIdentifier.create(
FrontendIdentifier.create(MemberName.forName("local"), FrontendType.forName("unknown")), 0);
- private static FrontendIdentifier FRONTEND_IDENTIFIER = FrontendIdentifier.create(
+ private static final FrontendIdentifier FRONTEND_IDENTIFIER = FrontendIdentifier.create(
MemberName.forName("member"), FrontendType.forName("frontend"));
private static final ClientIdentifier CLIENT_IDENTIFIER = ClientIdentifier.create(FRONTEND_IDENTIFIER, 0);
- private static LocalHistoryIdentifier HISTORY_ID = new LocalHistoryIdentifier(CLIENT_IDENTIFIER, 0);
- private static final TransactionIdentifier TRANSACTION_IDENTIFIER = new TransactionIdentifier(HISTORY_ID, 0);
+ private static final TransactionIdentifier TRANSACTION_IDENTIFIER =
+ new TransactionIdentifier(new LocalHistoryIdentifier(CLIENT_IDENTIFIER, 0), 0);
@Mock
private DataStoreClient clientActor;
@Mock
- private ActorContext actorContext;
+ private ActorUtils actorUtils;
@Mock
private ClientLocalHistory clientLocalHistory;
private ClientSnapshot clientSnapshot;
@Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
-
- final SchemaContext schemaContext = TestModel.createTestContext();
-
- Mockito.when(actorContext.getSchemaContext()).thenReturn(schemaContext);
- Mockito.when(actorContext.getDatastoreContext()).thenReturn(DatastoreContext.newBuilder().build());
-
- final Field transactionIdField = AbstractClientHandle.class.getDeclaredField("transactionId");
- transactionIdField.setAccessible(true);
-
- // set transaction ids to mocked objects
- transactionIdField.set(clientTransaction, TRANSACTION_IDENTIFIER);
- transactionIdField.set(clientSnapshot, TRANSACTION_IDENTIFIER);
-
- Mockito.when(clientActor.getIdentifier()).thenReturn(CLIENT_IDENTIFIER);
- Mockito.when(clientActor.createTransaction()).thenReturn(clientTransaction);
- Mockito.when(clientActor.createLocalHistory()).thenReturn(clientLocalHistory);
- Mockito.when(clientActor.createSnapshot()).thenReturn(clientSnapshot);
+ public void setUp() {
+ doReturn(DatastoreContext.newBuilder().build()).when(actorUtils).getDatastoreContext();
+ doReturn(TRANSACTION_IDENTIFIER).when(clientTransaction).getIdentifier();
+ doReturn(TRANSACTION_IDENTIFIER).when(clientSnapshot).getIdentifier();
+
+ doReturn(clientTransaction).when(clientActor).createTransaction();
+ doReturn(clientLocalHistory).when(clientActor).createLocalHistory();
+ doReturn(clientSnapshot).when(clientActor).createSnapshot();
}
@Test
- public void testCreateTransactionChain() throws Exception {
- try (final ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore(
- actorContext, UNKNOWN_ID, clientActor)) {
+ public void testCreateTransactionChain() {
+ try (ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore(
+ actorUtils, UNKNOWN_ID, clientActor)) {
final DOMStoreTransactionChain txChain = clientBackedDataStore.createTransactionChain();
- Assert.assertNotNull(txChain);
- Mockito.verify(clientActor, Mockito.times(1)).createLocalHistory();
+ assertNotNull(txChain);
+ verify(clientActor, times(1)).createLocalHistory();
}
}
@Test
- public void testNewReadOnlyTransaction() throws Exception {
- try (final ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore(
- actorContext, UNKNOWN_ID, clientActor)) {
+ public void testNewReadOnlyTransaction() {
+ try (ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore(
+ actorUtils, UNKNOWN_ID, clientActor)) {
final DOMStoreReadTransaction tx = clientBackedDataStore.newReadOnlyTransaction();
- Assert.assertNotNull(tx);
- Mockito.verify(clientActor, Mockito.times(1)).createSnapshot();
+ assertNotNull(tx);
+ verify(clientActor, times(1)).createSnapshot();
}
}
@Test
- public void testNewWriteOnlyTransaction() throws Exception {
- try (final ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore(
- actorContext, UNKNOWN_ID, clientActor)) {
+ public void testNewWriteOnlyTransaction() {
+ try (ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore(
+ actorUtils, UNKNOWN_ID, clientActor)) {
final DOMStoreWriteTransaction tx = clientBackedDataStore.newWriteOnlyTransaction();
- Assert.assertNotNull(tx);
- Mockito.verify(clientActor, Mockito.times(1)).createTransaction();
+ assertNotNull(tx);
+ verify(clientActor, times(1)).createTransaction();
}
}
@Test
- public void testNewReadWriteTransaction() throws Exception {
- try (final ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore(
- actorContext, UNKNOWN_ID, clientActor)) {
+ public void testNewReadWriteTransaction() {
+ try (ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore(
+ actorUtils, UNKNOWN_ID, clientActor)) {
final DOMStoreReadWriteTransaction tx = clientBackedDataStore.newReadWriteTransaction();
- Assert.assertNotNull(tx);
- Mockito.verify(clientActor, Mockito.times(1)).createTransaction();
+ assertNotNull(tx);
+ verify(clientActor, times(1)).createTransaction();
}
}
-}
\ No newline at end of file
+}