2 * Copyright (c) 2015 Inocybe Technologies 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.ovsdb.southbound.ovsdb.transact;
11 import static org.junit.Assert.assertEquals;
12 import static org.mockito.Matchers.any;
13 import static org.mockito.Matchers.anyString;
14 import static org.mockito.Matchers.eq;
15 import static org.mockito.Mockito.doNothing;
16 import static org.mockito.Mockito.mock;
17 import static org.mockito.Mockito.verify;
18 import static org.mockito.Mockito.when;
20 import java.lang.reflect.Field;
21 import java.util.ArrayList;
22 import java.util.HashMap;
23 import java.util.HashSet;
24 import java.util.List;
28 import org.junit.Before;
29 import org.junit.Test;
30 import org.junit.runner.RunWith;
31 import org.mockito.Mockito;
32 import org.mockito.stubbing.OngoingStubbing;
33 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
34 import org.opendaylight.ovsdb.lib.notation.Mutation;
35 import org.opendaylight.ovsdb.lib.notation.Mutator;
36 import org.opendaylight.ovsdb.lib.notation.OvsdbSet;
37 import org.opendaylight.ovsdb.lib.notation.UUID;
38 import org.opendaylight.ovsdb.lib.operations.Insert;
39 import org.opendaylight.ovsdb.lib.operations.Mutate;
40 import org.opendaylight.ovsdb.lib.operations.Operation;
41 import org.opendaylight.ovsdb.lib.operations.Operations;
42 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
43 import org.opendaylight.ovsdb.lib.schema.ColumnSchema;
44 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
45 import org.opendaylight.ovsdb.lib.schema.TableSchema;
46 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
47 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
48 import org.opendaylight.yangtools.yang.binding.DataObject;
49 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
50 import org.powermock.api.mockito.PowerMockito;
51 import org.powermock.api.support.membermodification.MemberMatcher;
52 import org.powermock.core.classloader.annotations.PrepareForTest;
53 import org.powermock.modules.junit4.PowerMockRunner;
55 import com.google.common.base.Predicates;
56 import com.google.common.collect.Maps;
58 @RunWith(PowerMockRunner.class)
59 @PrepareForTest({TransactUtils.class, SouthboundMapper.class, SouthboundUtil.class, OvsdbSet.class, Operations.class})
60 public class TransactUtilsTest {
62 private static final String UUID_NAME = "uuid name";
63 private static final String IID_STRING = "iid string";
64 private static final String COLUMN_SCHEMA_NAME = "column schema name";
68 PowerMockito.mockStatic(TransactUtils.class, Mockito.CALLS_REAL_METHODS);
72 public void testExtractNode() {
73 Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
74 assertEquals(HashMap.class, TransactUtils.extractNode(changes).getClass());
77 @SuppressWarnings("unchecked")
79 public void testExtractCreatedAndExtractUpdated() {
80 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
81 Class<DataObject> klazz = DataObject.class;
82 Map<InstanceIdentifier<?>, DataObject> map = new HashMap<>();
83 when(changes.getCreatedData()).thenReturn(map);
84 when(TransactUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(new HashMap<>());
86 //test extractCreated()
87 assertEquals(map, TransactUtils.extractCreated(changes, klazz));
89 //test extractUpdated()
90 assertEquals(map, TransactUtils.extractUpdated(changes, klazz));
93 @SuppressWarnings("unchecked")
95 public void testExtractCreatedOrUpdated() {
96 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
97 Class<DataObject> klazz = DataObject.class;
98 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
100 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractUpdated", AsyncDataChangeEvent.class, Class.class));
101 PowerMockito.when(TransactUtils.extractUpdated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result);
103 Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
104 InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
105 DataObject db = mock(DataObject.class);
107 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractCreated", AsyncDataChangeEvent.class, Class.class));
108 PowerMockito.when(TransactUtils.extractCreated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(map);
110 Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
111 testResult.put(iid, db);
112 assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, klazz));
115 @SuppressWarnings("unchecked")
117 public void testExtractCreatedOrUpdatedOrRemoved() {
118 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
119 Class<DataObject> klazz = DataObject.class;
120 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
122 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractCreatedOrUpdated", AsyncDataChangeEvent.class, Class.class));
123 PowerMockito.when(TransactUtils.extractCreatedOrUpdated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result);
125 Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
126 InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
127 DataObject db = mock(DataObject.class);
129 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractRemovedObjects", AsyncDataChangeEvent.class, Class.class));
130 PowerMockito.when(TransactUtils.extractRemovedObjects(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(map);
132 Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
133 testResult.put(iid, db);
134 assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, klazz));
137 @SuppressWarnings("unchecked")
139 public void testExtractOriginal() {
140 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
141 Class<DataObject> klazz = DataObject.class;
142 Map<InstanceIdentifier<?>, DataObject> map = new HashMap<>();
143 when(changes.getOriginalData()).thenReturn(map);
144 when(TransactUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(new HashMap<>());
146 //test extractOriginal()
147 assertEquals(map, TransactUtils.extractCreated(changes, klazz));
150 @SuppressWarnings("unchecked")
152 public void testExtractRemoved() {
153 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
154 Class<DataObject> klazz = DataObject.class;
155 assertEquals(HashSet.class, TransactUtils.extractRemoved(changes, klazz).getClass());
158 @SuppressWarnings("unchecked")
160 public void testExtractRemovedObjects() {
161 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
162 Class<DataObject> klazz = DataObject.class;
163 Set<InstanceIdentifier<DataObject>> iids = new HashSet<>();
164 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractRemoved", AsyncDataChangeEvent.class, Class.class));
165 PowerMockito.when(TransactUtils.extractRemoved(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(iids);
167 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
168 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractOriginal", AsyncDataChangeEvent.class, Class.class));
169 PowerMockito.when(TransactUtils.extractOriginal(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result);
170 assertEquals(Maps.filterKeys(result, Predicates.in(iids)), TransactUtils.extractRemovedObjects(changes, klazz));
174 public void testExtract() {
175 Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
176 Class<DataObject> klazz = DataObject.class;
177 assertEquals(HashMap.class, TransactUtils.extract(changes, klazz).getClass());
180 @SuppressWarnings("rawtypes")
182 public void testExtractInsert() {
183 TransactionBuilder transaction = mock(TransactionBuilder.class);
184 GenericTableSchema schema = mock(GenericTableSchema.class);
186 List<Operation> operations = new ArrayList<>();
187 Operation operation = mock(Insert.class);
188 operations.add(operation);
189 when(transaction.getOperations()).thenReturn(operations);
190 when(operation.getTableSchema()).thenReturn(schema);
192 List<Insert> inserts = TransactUtils.extractInsert(transaction, schema);
193 assertEquals(operation, inserts.get(0));
196 @SuppressWarnings("rawtypes")
198 public void testExtractNamedUuid() throws Exception {
199 Insert insert = mock(Insert.class);
200 when(insert.getUuidName()).thenReturn(UUID_NAME);
201 PowerMockito.mockStatic(SouthboundMapper.class);
202 PowerMockito.when(SouthboundMapper.getRandomUUID()).thenReturn(UUID_NAME);
203 doNothing().when(insert).setUuidName(anyString());
205 UUID uuid = mock(UUID.class);
206 PowerMockito.whenNew(UUID.class).withAnyArguments().thenReturn(uuid);
207 assertEquals(uuid, TransactUtils.extractNamedUuid(insert));
210 @SuppressWarnings("unchecked")
212 public void testStampInstanceIdentifier() {
213 TransactionBuilder transaction = mock(TransactionBuilder.class);
214 InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
215 TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
216 ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
218 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "stampInstanceIdentifierMutation",
219 TransactionBuilder.class,
220 InstanceIdentifier.class,
222 ColumnSchema.class));
223 when(TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema)).thenReturn(mock(Mutate.class));
224 when(transaction.add(any(Operation.class))).thenReturn(transaction);
225 TransactUtils.stampInstanceIdentifier(transaction, iid, tableSchema, columnSchema);
226 verify(transaction).add(any(Operation.class));
229 @SuppressWarnings({ "unchecked" })
231 public void testStampInstanceIdentifierMutation() throws Exception {
232 TransactionBuilder transaction = mock(TransactionBuilder.class);
233 InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
234 TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
235 ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
237 PowerMockito.mockStatic(SouthboundUtil.class);
238 PowerMockito.when(SouthboundUtil.serializeInstanceIdentifier(any(InstanceIdentifier.class))).thenReturn(IID_STRING);
240 Mutate<GenericTableSchema> mutate = mock(Mutate.class);
241 Operations op = (Operations) setField("op");
242 Mockito.<Mutate<GenericTableSchema>>when(op.mutate(any(TableSchema.class))).thenReturn(mutate);
243 when(mutate.addMutation(any(ColumnSchema.class), any(Mutator.class), any(Map.class))).thenReturn(mutate);
245 Mutation deleteIidMutation = mock(Mutation.class);
246 when(columnSchema.getName()).thenReturn(COLUMN_SCHEMA_NAME);
247 PowerMockito.mockStatic(OvsdbSet.class);
248 PowerMockito.when(OvsdbSet.fromSet(any(Set.class))).thenReturn(mock(OvsdbSet.class));
249 PowerMockito.whenNew(Mutation.class).withAnyArguments().thenReturn(deleteIidMutation);
251 List<Mutation> listMutations = new ArrayList<>();
252 when(mutate.getMutations()).thenReturn(listMutations);
253 doNothing().when(mutate).setMutations(any(List.class));
254 assertEquals(mutate, TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema));
257 private Object setField(String fieldName) throws Exception {
258 Field field = Operations.class.getDeclaredField(fieldName);
259 field.setAccessible(true);
260 field.set(field.get(Operations.class), mock(Operations.class));
261 return field.get(Operations.class);