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.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
33 import org.opendaylight.ovsdb.lib.notation.Mutation;
34 import org.opendaylight.ovsdb.lib.notation.Mutator;
35 import org.opendaylight.ovsdb.lib.notation.OvsdbSet;
36 import org.opendaylight.ovsdb.lib.notation.UUID;
37 import org.opendaylight.ovsdb.lib.operations.Insert;
38 import org.opendaylight.ovsdb.lib.operations.Mutate;
39 import org.opendaylight.ovsdb.lib.operations.Operation;
40 import org.opendaylight.ovsdb.lib.operations.Operations;
41 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
42 import org.opendaylight.ovsdb.lib.schema.ColumnSchema;
43 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
44 import org.opendaylight.ovsdb.lib.schema.TableSchema;
45 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
46 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
47 import org.opendaylight.yangtools.yang.binding.DataObject;
48 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
49 import org.powermock.api.mockito.PowerMockito;
50 import org.powermock.api.support.membermodification.MemberMatcher;
51 import org.powermock.core.classloader.annotations.PrepareForTest;
52 import org.powermock.modules.junit4.PowerMockRunner;
54 import com.google.common.base.Predicates;
55 import com.google.common.collect.Maps;
57 @RunWith(PowerMockRunner.class)
58 @PrepareForTest({TransactUtils.class, SouthboundMapper.class, SouthboundUtil.class, OvsdbSet.class, Operations.class})
59 public class TransactUtilsTest {
61 private static final String UUID_NAME = "uuid name";
62 private static final String IID_STRING = "iid string";
63 private static final String COLUMN_SCHEMA_NAME = "column schema name";
67 PowerMockito.mockStatic(TransactUtils.class, Mockito.CALLS_REAL_METHODS);
71 public void testExtractNode() {
72 Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
73 assertEquals(HashMap.class, TransactUtils.extractNode(changes).getClass());
76 @SuppressWarnings("unchecked")
78 public void testExtractCreatedAndExtractUpdated() {
79 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
80 Class<DataObject> klazz = DataObject.class;
81 Map<InstanceIdentifier<?>, DataObject> map = new HashMap<>();
82 when(changes.getCreatedData()).thenReturn(map);
83 when(TransactUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(new HashMap<>());
85 //test extractCreated()
86 assertEquals(map, TransactUtils.extractCreated(changes, klazz));
88 //test extractUpdated()
89 assertEquals(map, TransactUtils.extractUpdated(changes, klazz));
92 @SuppressWarnings("unchecked")
94 public void testExtractCreatedOrUpdated() {
95 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
96 Class<DataObject> klazz = DataObject.class;
97 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
99 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractUpdated", AsyncDataChangeEvent.class, Class.class));
100 PowerMockito.when(TransactUtils.extractUpdated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result);
102 Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
103 InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
104 DataObject db = mock(DataObject.class);
106 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractCreated", AsyncDataChangeEvent.class, Class.class));
107 PowerMockito.when(TransactUtils.extractCreated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(map);
109 Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
110 testResult.put(iid, db);
111 assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, klazz));
114 @SuppressWarnings("unchecked")
116 public void testExtractCreatedOrUpdatedOrRemoved() {
117 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
118 Class<DataObject> klazz = DataObject.class;
119 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
121 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractCreatedOrUpdated", AsyncDataChangeEvent.class, Class.class));
122 PowerMockito.when(TransactUtils.extractCreatedOrUpdated(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result);
124 Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
125 InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
126 DataObject db = mock(DataObject.class);
128 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractRemovedObjects", AsyncDataChangeEvent.class, Class.class));
129 PowerMockito.when(TransactUtils.extractRemovedObjects(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(map);
131 Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
132 testResult.put(iid, db);
133 assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, klazz));
136 @SuppressWarnings("unchecked")
138 public void testExtractOriginal() {
139 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
140 Class<DataObject> klazz = DataObject.class;
141 Map<InstanceIdentifier<?>, DataObject> map = new HashMap<>();
142 when(changes.getOriginalData()).thenReturn(map);
143 when(TransactUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(new HashMap<>());
145 //test extractOriginal()
146 assertEquals(map, TransactUtils.extractCreated(changes, klazz));
149 @SuppressWarnings("unchecked")
151 public void testExtractRemoved() {
152 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
153 Class<DataObject> klazz = DataObject.class;
154 assertEquals(HashSet.class, TransactUtils.extractRemoved(changes, klazz).getClass());
157 @SuppressWarnings("unchecked")
159 public void testExtractRemovedObjects() {
160 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
161 Class<DataObject> klazz = DataObject.class;
162 Set<InstanceIdentifier<DataObject>> iids = new HashSet<>();
163 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractRemoved", AsyncDataChangeEvent.class, Class.class));
164 PowerMockito.when(TransactUtils.extractRemoved(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(iids);
166 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
167 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractOriginal", AsyncDataChangeEvent.class, Class.class));
168 PowerMockito.when(TransactUtils.extractOriginal(any(AsyncDataChangeEvent.class),eq(DataObject.class))).thenReturn(result);
169 assertEquals(Maps.filterKeys(result, Predicates.in(iids)), TransactUtils.extractRemovedObjects(changes, klazz));
173 public void testExtract() {
174 Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
175 Class<DataObject> klazz = DataObject.class;
176 assertEquals(HashMap.class, TransactUtils.extract(changes, klazz).getClass());
179 @SuppressWarnings("rawtypes")
181 public void testExtractInsert() {
182 TransactionBuilder transaction = mock(TransactionBuilder.class);
183 GenericTableSchema schema = mock(GenericTableSchema.class);
185 List<Operation> operations = new ArrayList<>();
186 Operation operation = mock(Insert.class);
187 operations.add(operation);
188 when(transaction.getOperations()).thenReturn(operations);
189 when(operation.getTableSchema()).thenReturn(schema);
191 List<Insert> inserts = TransactUtils.extractInsert(transaction, schema);
192 assertEquals(operation, inserts.get(0));
195 @SuppressWarnings("rawtypes")
197 public void testExtractNamedUuid() throws Exception {
198 Insert insert = mock(Insert.class);
199 when(insert.getUuidName()).thenReturn(UUID_NAME);
200 PowerMockito.mockStatic(SouthboundMapper.class);
201 PowerMockito.when(SouthboundMapper.getRandomUuid()).thenReturn(UUID_NAME);
202 doNothing().when(insert).setUuidName(anyString());
204 UUID uuid = mock(UUID.class);
205 PowerMockito.whenNew(UUID.class).withAnyArguments().thenReturn(uuid);
206 assertEquals(uuid, TransactUtils.extractNamedUuid(insert));
209 @SuppressWarnings("unchecked")
211 public void testStampInstanceIdentifier() {
212 TransactionBuilder transaction = mock(TransactionBuilder.class);
213 InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
214 TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
215 ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
217 PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "stampInstanceIdentifierMutation",
218 TransactionBuilder.class,
219 InstanceIdentifier.class,
221 ColumnSchema.class));
222 when(TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema)).thenReturn(mock(Mutate.class));
223 when(transaction.add(any(Operation.class))).thenReturn(transaction);
224 TransactUtils.stampInstanceIdentifier(transaction, iid, tableSchema, columnSchema);
225 verify(transaction).add(any(Operation.class));
228 @SuppressWarnings({ "unchecked" })
230 public void testStampInstanceIdentifierMutation() throws Exception {
231 TransactionBuilder transaction = mock(TransactionBuilder.class);
232 InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
233 TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
234 ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
236 PowerMockito.mockStatic(SouthboundUtil.class);
237 PowerMockito.when(SouthboundUtil.serializeInstanceIdentifier(any(InstanceIdentifier.class))).thenReturn(IID_STRING);
239 Mutate<GenericTableSchema> mutate = mock(Mutate.class);
240 Operations op = (Operations) setField("op");
241 Mockito.<Mutate<GenericTableSchema>>when(op.mutate(any(TableSchema.class))).thenReturn(mutate);
242 when(mutate.addMutation(any(ColumnSchema.class), any(Mutator.class), any(Map.class))).thenReturn(mutate);
244 Mutation deleteIidMutation = mock(Mutation.class);
245 when(columnSchema.getName()).thenReturn(COLUMN_SCHEMA_NAME);
246 PowerMockito.mockStatic(OvsdbSet.class);
247 PowerMockito.when(OvsdbSet.fromSet(any(Set.class))).thenReturn(mock(OvsdbSet.class));
248 PowerMockito.whenNew(Mutation.class).withAnyArguments().thenReturn(deleteIidMutation);
250 List<Mutation> listMutations = new ArrayList<>();
251 when(mutate.getMutations()).thenReturn(listMutations);
252 doNothing().when(mutate).setMutations(any(List.class));
253 assertEquals(mutate, TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema));
256 private Object setField(String fieldName) throws Exception {
257 Field field = Operations.class.getDeclaredField(fieldName);
258 field.setAccessible(true);
259 field.set(field.get(Operations.class), mock(Operations.class));
260 return field.get(Operations.class);