From a811087c7d00be7341fb0129a6943e5c504e5154 Mon Sep 17 00:00:00 2001 From: Rashmi Pujar Date: Fri, 23 Oct 2015 15:09:25 -0400 Subject: [PATCH] UT for ovsdb.southbound transact package 1. TransactInvokerImpl.java 2. TransactCommandAggregator.java 3. TransactUtils.java Change-Id: If360ba8f07a9715ff60225809fbc987afba59516 Signed-off-by: Rashmi Pujar --- .../ovsdb/transact/TransactInvokerImpl.java | 2 +- .../TransactCommandAggregatorTest.java | 81 ++++++ .../transact/TransactInvokerImplTest.java | 78 ++++++ .../ovsdb/transact/TransactUtilsTest.java | 262 ++++++++++++++++++ 4 files changed, 422 insertions(+), 1 deletion(-) create mode 100644 southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactCommandAggregatorTest.java create mode 100644 southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactInvokerImplTest.java create mode 100644 southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtilsTest.java diff --git a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactInvokerImpl.java b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactInvokerImpl.java index ce35156e6..0b3088fa7 100644 --- a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactInvokerImpl.java +++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactInvokerImpl.java @@ -19,7 +19,7 @@ import org.slf4j.LoggerFactory; import com.google.common.util.concurrent.ListenableFuture; public class TransactInvokerImpl implements TransactInvoker { - private static final Logger LOG = LoggerFactory.getLogger(BridgeUpdateCommand.class); + private static final Logger LOG = LoggerFactory.getLogger(TransactInvokerImpl.class); private OvsdbConnectionInstance connectionInstance; private DatabaseSchema dbSchema; diff --git a/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactCommandAggregatorTest.java b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactCommandAggregatorTest.java new file mode 100644 index 000000000..e87f55ac2 --- /dev/null +++ b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactCommandAggregatorTest.java @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2015 Inocybe Technologies and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.ovsdb.southbound.ovsdb.transact; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.ovsdb.lib.operations.TransactionBuilder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.api.support.membermodification.MemberModifier; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.powermock.reflect.Whitebox; + +@PrepareForTest({}) +@RunWith(PowerMockRunner.class) +public class TransactCommandAggregatorTest { + private static final int NUMBER_OF_COMMANDS = 11; + private List commands = new ArrayList(); + private TransactCommandAggregator transactCommandAggregator; + @Mock private AsyncDataChangeEvent, DataObject> changes; + @Mock private BridgeOperationalState operationalState; + + @Before + public void setUp() throws Exception { + transactCommandAggregator = PowerMockito.mock(TransactCommandAggregator.class, Mockito.CALLS_REAL_METHODS); + + //mock commands field + commands.add(mock(BridgeUpdateCommand.class)); + commands.add(mock(OpenVSwitchBridgeAddCommand.class)); + commands.add(mock(ControllerUpdateCommand.class)); + commands.add(mock(ControllerRemovedCommand.class)); + commands.add(mock(ProtocolUpdateCommand.class)); + commands.add(mock(ProtocolRemovedCommand.class)); + commands.add(mock(BridgeRemovedCommand.class)); + commands.add(mock(TerminationPointCreateCommand.class)); + commands.add(mock(TerminationPointDeleteCommand.class)); + commands.add(mock(OvsdbNodeUpdateCommand.class)); + commands.add(mock(TerminationPointUpdateCommand.class)); + MemberModifier.field(TransactCommandAggregator.class, "commands").set(transactCommandAggregator, commands); + } + + @Test + public void testOvsdbOperationalCommandAggregator() throws Exception { + TransactCommandAggregator transactCommandAggregator1 = new TransactCommandAggregator(operationalState, changes); + List testCommands = Whitebox.getInternalState(transactCommandAggregator1, "commands"); + assertEquals(NUMBER_OF_COMMANDS, testCommands.size()); + } + + @Test + public void testExecute() { + TransactionBuilder transaction = mock(TransactionBuilder.class); + for (TransactCommand command: commands) { + doNothing().when(command).execute(any(TransactionBuilder.class)); + } + transactCommandAggregator.execute(transaction); + for (TransactCommand command: commands) { + verify(command).execute(any(TransactionBuilder.class)); + } + } +} diff --git a/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactInvokerImplTest.java b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactInvokerImplTest.java new file mode 100644 index 000000000..e867ca11d --- /dev/null +++ b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactInvokerImplTest.java @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2015 Inocybe Technologies and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.ovsdb.southbound.ovsdb.transact; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.opendaylight.ovsdb.lib.operations.Operation; +import org.opendaylight.ovsdb.lib.operations.OperationResult; +import org.opendaylight.ovsdb.lib.operations.TransactionBuilder; +import org.opendaylight.ovsdb.lib.schema.DatabaseSchema; +import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.api.support.membermodification.MemberModifier; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.powermock.reflect.Whitebox; + +import com.google.common.util.concurrent.ListenableFuture; + +@PrepareForTest({TransactInvokerImpl.class}) +@RunWith(PowerMockRunner.class) +public class TransactInvokerImplTest { + @Mock private OvsdbConnectionInstance connectionInstance; + @Mock private DatabaseSchema dbSchema; + private TransactInvokerImpl transactInvokerImpl; + + @Before + public void setUp() throws Exception { + transactInvokerImpl = PowerMockito.mock(TransactInvokerImpl.class, Mockito.CALLS_REAL_METHODS); + MemberModifier.field(TransactInvokerImpl.class, "connectionInstance").set(transactInvokerImpl, connectionInstance); + MemberModifier.field(TransactInvokerImpl.class, "dbSchema").set(transactInvokerImpl, dbSchema); + } + + @Test + public void testTransactionInvokerImpl() { + TransactInvokerImpl transactInvokerImpl1 = new TransactInvokerImpl(connectionInstance, dbSchema); + assertEquals(connectionInstance, Whitebox.getInternalState(transactInvokerImpl1, "connectionInstance")); + assertEquals(dbSchema, Whitebox.getInternalState(transactInvokerImpl1, "dbSchema")); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Test + public void testInvoke() throws Exception { + TransactCommand command = mock(TransactCommand.class); + TransactionBuilder tb = mock(TransactionBuilder.class); + PowerMockito.whenNew(TransactionBuilder.class).withAnyArguments().thenReturn(tb); + doNothing().when(command).execute(any(TransactionBuilder.class)); + + ListenableFuture> result = mock(ListenableFuture.class); + when(tb.execute()).thenReturn(result); + List operation = new ArrayList<>(); + operation.add(mock(Operation.class)); + when(tb.getOperations()).thenReturn(operation); + List got = new ArrayList<>(); + when(result.get()).thenReturn(got); + transactInvokerImpl.invoke(command); + verify(result).get(); + } +} diff --git a/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtilsTest.java b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtilsTest.java new file mode 100644 index 000000000..8f5c7c936 --- /dev/null +++ b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtilsTest.java @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2015 Inocybe Technologies and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.ovsdb.southbound.ovsdb.transact; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.ovsdb.lib.notation.Mutation; +import org.opendaylight.ovsdb.lib.notation.Mutator; +import org.opendaylight.ovsdb.lib.notation.OvsdbSet; +import org.opendaylight.ovsdb.lib.notation.UUID; +import org.opendaylight.ovsdb.lib.operations.Insert; +import org.opendaylight.ovsdb.lib.operations.Mutate; +import org.opendaylight.ovsdb.lib.operations.Operation; +import org.opendaylight.ovsdb.lib.operations.Operations; +import org.opendaylight.ovsdb.lib.operations.TransactionBuilder; +import org.opendaylight.ovsdb.lib.schema.ColumnSchema; +import org.opendaylight.ovsdb.lib.schema.GenericTableSchema; +import org.opendaylight.ovsdb.lib.schema.TableSchema; +import org.opendaylight.ovsdb.southbound.SouthboundMapper; +import org.opendaylight.ovsdb.southbound.SouthboundUtil; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.api.support.membermodification.MemberMatcher; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import com.google.common.base.Predicates; +import com.google.common.collect.Maps; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({TransactUtils.class, SouthboundMapper.class, SouthboundUtil.class, OvsdbSet.class, Operations.class}) +public class TransactUtilsTest { + + private static final String UUID_NAME = "uuid name"; + private static final String IID_STRING = "iid string"; + private static final String COLUMN_SCHEMA_NAME = "column schema name"; + + @Before + public void setUp() { + PowerMockito.mockStatic(TransactUtils.class, Mockito.CALLS_REAL_METHODS); + } + + @Test + public void testExtractNode() { + Map, DataObject> changes = new HashMap<>(); + assertEquals(HashMap.class, TransactUtils.extractNode(changes).getClass()); + } + + @SuppressWarnings("unchecked") + @Test + public void testExtractCreatedAndExtractUpdated() { + AsyncDataChangeEvent, DataObject> changes = mock(AsyncDataChangeEvent.class); + Class klazz = DataObject.class; + Map, DataObject> map = new HashMap<>(); + when(changes.getCreatedData()).thenReturn(map); + when(TransactUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(map); + + //test extractCreated() + assertEquals(map, TransactUtils.extractCreated(changes, klazz)); + + //test extractUpdated() + assertEquals(map, TransactUtils.extractUpdated(changes, klazz)); + } + + @SuppressWarnings("unchecked") + @Test + public void testExtractCreatedOrUpdated() { + AsyncDataChangeEvent, DataObject> changes = mock(AsyncDataChangeEvent.class); + Class klazz = DataObject.class; + Map, DataObject> result = new HashMap<>(); + + PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractUpdated", AsyncDataChangeEvent.class, Class.class)); + PowerMockito.when(TransactUtils.extractUpdated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result); + + Map, DataObject> map = new HashMap, DataObject>(); + InstanceIdentifier iid = mock(InstanceIdentifier.class); + DataObject db = mock(DataObject.class); + map.put(iid, db); + PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractCreated", AsyncDataChangeEvent.class, Class.class)); + PowerMockito.when(TransactUtils.extractCreated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(map); + + Map, DataObject> testResult = new HashMap<>(); + testResult.put(iid, db); + assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, klazz)); + } + + @SuppressWarnings("unchecked") + @Test + public void testExtractCreatedOrUpdatedOrRemoved() { + AsyncDataChangeEvent, DataObject> changes = mock(AsyncDataChangeEvent.class); + Class klazz = DataObject.class; + Map, DataObject> result = new HashMap<>(); + + PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractCreatedOrUpdated", AsyncDataChangeEvent.class, Class.class)); + PowerMockito.when(TransactUtils.extractCreatedOrUpdated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result); + + Map, DataObject> map = new HashMap, DataObject>(); + InstanceIdentifier iid = mock(InstanceIdentifier.class); + DataObject db = mock(DataObject.class); + map.put(iid, db); + PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractRemovedObjects", AsyncDataChangeEvent.class, Class.class)); + PowerMockito.when(TransactUtils.extractRemovedObjects(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(map); + + Map, DataObject> testResult = new HashMap<>(); + testResult.put(iid, db); + assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, klazz)); + } + + @SuppressWarnings("unchecked") + @Test + public void testExtractOriginal() { + AsyncDataChangeEvent, DataObject> changes = mock(AsyncDataChangeEvent.class); + Class klazz = DataObject.class; + Map, DataObject> map = new HashMap<>(); + when(changes.getOriginalData()).thenReturn(map); + when(TransactUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(map); + + //test extractOriginal() + assertEquals(map, TransactUtils.extractCreated(changes, klazz)); + } + + @SuppressWarnings("unchecked") + @Test + public void testExtractRemoved() { + AsyncDataChangeEvent, DataObject> changes = mock(AsyncDataChangeEvent.class); + Class klazz = DataObject.class; + assertEquals(HashSet.class, TransactUtils.extractRemoved(changes, klazz).getClass()); + } + + @SuppressWarnings("unchecked") + @Test + public void testExtractRemovedObjects() { + AsyncDataChangeEvent, DataObject> changes = mock(AsyncDataChangeEvent.class); + Class klazz = DataObject.class; + Set> iids = new HashSet<>(); + PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractRemoved", AsyncDataChangeEvent.class, Class.class)); + PowerMockito.when(TransactUtils.extractRemoved(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(iids); + + Map, DataObject> result = new HashMap<>(); + PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractOriginal", AsyncDataChangeEvent.class, Class.class)); + PowerMockito.when(TransactUtils.extractOriginal(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result); + assertEquals(Maps.filterKeys(result, Predicates.in(iids)), TransactUtils.extractRemovedObjects(changes, klazz)); + } + + @Test + public void testExtract() { + Map, DataObject> changes = new HashMap<>(); + Class klazz = DataObject.class; + assertEquals(HashMap.class, TransactUtils.extract(changes, klazz).getClass()); + } + + @SuppressWarnings("rawtypes") + @Test + public void testExtractInsert() { + TransactionBuilder transaction = mock(TransactionBuilder.class); + GenericTableSchema schema = mock(GenericTableSchema.class); + + List operations = new ArrayList(); + Operation operation = mock(Insert.class); + operations.add(operation); + when(transaction.getOperations()).thenReturn(operations); + when(operation.getTableSchema()).thenReturn(schema); + + List inserts = TransactUtils.extractInsert(transaction, schema); + assertEquals((Insert)operation, inserts.get(0)); + } + + @SuppressWarnings("rawtypes") + @Test + public void testExtractNamedUuid() throws Exception { + Insert insert = mock(Insert.class); + when(insert.getUuidName()).thenReturn(UUID_NAME); + PowerMockito.mockStatic(SouthboundMapper.class); + PowerMockito.when(SouthboundMapper.getRandomUUID()).thenReturn(UUID_NAME); + doNothing().when(insert).setUuidName(anyString()); + + UUID uuid = mock(UUID.class); + PowerMockito.whenNew(UUID.class).withAnyArguments().thenReturn(uuid); + assertEquals(uuid, TransactUtils.extractNamedUuid(insert)); + } + + @SuppressWarnings("unchecked") + @Test + public void testStampInstanceIdentifier() { + TransactionBuilder transaction = mock(TransactionBuilder.class); + InstanceIdentifier iid = mock(InstanceIdentifier.class); + TableSchema tableSchema = mock(TableSchema.class); + ColumnSchema> columnSchema = mock(ColumnSchema.class); + + PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "stampInstanceIdentifierMutation", + TransactionBuilder.class, + InstanceIdentifier.class, + TableSchema.class, + ColumnSchema.class)); + when(TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema)).thenReturn(mock(Mutate.class)); + when(transaction.add(any(Operation.class))).thenReturn(transaction); + TransactUtils.stampInstanceIdentifier(transaction, iid, tableSchema, columnSchema); + verify(transaction).add(any(Operation.class)); + } + + @SuppressWarnings({ "unchecked" }) + @Test + public void testStampInstanceIdentifierMutation() throws Exception { + TransactionBuilder transaction = mock(TransactionBuilder.class); + InstanceIdentifier iid = mock(InstanceIdentifier.class); + TableSchema tableSchema = mock(TableSchema.class); + ColumnSchema> columnSchema = mock(ColumnSchema.class); + + PowerMockito.mockStatic(SouthboundUtil.class); + PowerMockito.when(SouthboundUtil.serializeInstanceIdentifier(any(InstanceIdentifier.class))).thenReturn(IID_STRING); + + Mutate mutate = mock(Mutate.class); + Operations op = (Operations) setField("op"); + when(op.mutate(any(TableSchema.class))).thenReturn(mutate); + when(mutate.addMutation(any(ColumnSchema.class), any(Mutator.class), any(Map.class))).thenReturn(mutate); + + Mutation deleteIidMutation = mock(Mutation.class); + when(columnSchema.getName()).thenReturn(COLUMN_SCHEMA_NAME); + PowerMockito.mockStatic(OvsdbSet.class); + PowerMockito.when(OvsdbSet.fromSet(any(Set.class))).thenReturn(mock(OvsdbSet.class)); + PowerMockito.whenNew(Mutation.class).withAnyArguments().thenReturn(deleteIidMutation); + + List listMutations = new ArrayList<>(); + when(mutate.getMutations()).thenReturn(listMutations); + doNothing().when(mutate).setMutations(any(List.class)); + assertEquals(mutate, TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema)); + } + + private Object setField(String fieldName) throws Exception { + Field field = Operations.class.getDeclaredField(fieldName); + field.setAccessible(true); + field.set(field.get(Operations.class), mock(Operations.class)); + return field.get(Operations.class); + } +} -- 2.36.6