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.ArgumentMatchers.any;
13 import static org.mockito.ArgumentMatchers.anyString;
14 import static org.mockito.ArgumentMatchers.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 com.google.common.base.Predicates;
21 import com.google.common.collect.Maps;
22 import java.lang.reflect.Field;
23 import java.util.ArrayList;
24 import java.util.HashMap;
25 import java.util.HashSet;
26 import java.util.List;
29 import org.junit.Before;
30 import org.junit.Test;
31 import org.junit.runner.RunWith;
32 import org.mockito.Mockito;
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.InstanceIdentifierCodec;
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.core.classloader.annotations.PrepareForTest;
52 import org.powermock.modules.junit4.PowerMockRunner;
54 @RunWith(PowerMockRunner.class)
55 @PrepareForTest({TransactUtils.class, SouthboundMapper.class, SouthboundUtil.class, OvsdbSet.class, Operations.class})
56 public class TransactUtilsTest {
58 private static final String UUID_NAME = "uuid name";
59 private static final String IID_STRING = "iid string";
60 private static final String COLUMN_SCHEMA_NAME = "column schema name";
64 PowerMockito.mockStatic(TransactUtils.class, Mockito.CALLS_REAL_METHODS);
68 public void testExtractNode() {
69 Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
70 assertEquals(HashMap.class, TransactUtils.extractNode(changes).getClass());
73 @SuppressWarnings("unchecked")
75 public void testExtractCreatedAndExtractUpdated() {
76 DataChangeEvent changes = mock(DataChangeEvent.class);
77 Class<DataObject> klazz = DataObject.class;
78 Map<InstanceIdentifier<?>, DataObject> map = new HashMap<>();
79 when(changes.getCreatedData()).thenReturn(map);
80 when(TransactUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(new HashMap<>());
82 //test extractCreated()
83 assertEquals(map, TransactUtils.extractCreated(changes, klazz));
85 //test extractUpdated()
86 assertEquals(map, TransactUtils.extractUpdated(changes, klazz));
89 @SuppressWarnings("unchecked")
91 public void testExtractCreatedOrUpdated() {
92 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
94 PowerMockito.doReturn(result).when(TransactUtils.class);
95 TransactUtils.extractUpdated(any(DataChangeEvent.class), eq(DataObject.class));
97 Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
98 InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
100 DataObject db = mock(DataObject.class);
103 PowerMockito.doReturn(map).when(TransactUtils.class);
104 TransactUtils.extractCreated(any(DataChangeEvent.class), eq(DataObject.class));
106 Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
107 testResult.put(iid, db);
108 Class<DataObject> klazz = DataObject.class;
109 DataChangeEvent changes = mock(DataChangeEvent.class);
110 assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, klazz));
114 @SuppressWarnings("unchecked")
115 public void testExtractCreatedOrUpdatedOrRemoved() {
116 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
118 PowerMockito.doReturn(result).when(TransactUtils.class);
119 TransactUtils.extractCreatedOrUpdated(any(DataChangeEvent.class), eq(DataObject.class));
121 Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
122 InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
123 DataObject db = mock(DataObject.class);
126 PowerMockito.doReturn(map).when(TransactUtils.class);
127 TransactUtils.extractRemovedObjects(any(DataChangeEvent.class), eq(DataObject.class));
129 Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
130 testResult.put(iid, db);
131 Class<DataObject> klazz = DataObject.class;
132 DataChangeEvent changes = mock(DataChangeEvent.class);
133 assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, klazz));
136 @SuppressWarnings("unchecked")
138 public void testExtractOriginal() {
139 DataChangeEvent changes = mock(DataChangeEvent.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 DataChangeEvent changes = mock(DataChangeEvent.class);
153 Class<DataObject> klazz = DataObject.class;
154 assertEquals(HashSet.class, TransactUtils.extractRemoved(changes, klazz).getClass());
158 public void testExtractRemovedObjects() {
159 Set<InstanceIdentifier<DataObject>> iids = new HashSet<>();
161 PowerMockito.doReturn(iids).when(TransactUtils.class);
162 TransactUtils.extractRemoved(any(DataChangeEvent.class), eq(DataObject.class));
164 Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
166 PowerMockito.doReturn(result).when(TransactUtils.class);
167 TransactUtils.extractOriginal(any(DataChangeEvent.class), eq(DataObject.class));
169 Class<DataObject> klazz = DataObject.class;
170 DataChangeEvent changes = mock(DataChangeEvent.class);
171 assertEquals(Maps.filterKeys(result, Predicates.in(iids)), TransactUtils.extractRemovedObjects(changes, klazz));
175 public void testExtract() {
176 Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
177 Class<DataObject> klazz = DataObject.class;
178 assertEquals(HashMap.class, TransactUtils.extract(changes, klazz).getClass());
181 @SuppressWarnings("rawtypes")
183 public void testExtractInsert() {
184 TransactionBuilder transaction = mock(TransactionBuilder.class);
185 GenericTableSchema schema = mock(GenericTableSchema.class);
187 List<Operation> operations = new ArrayList<>();
188 Operation operation = mock(Insert.class);
189 operations.add(operation);
190 when(transaction.getOperations()).thenReturn(operations);
191 when(operation.getTableSchema()).thenReturn(schema);
193 List<Insert> inserts = TransactUtils.extractInsert(transaction, schema);
194 assertEquals(operation, inserts.get(0));
197 @SuppressWarnings("rawtypes")
199 public void testExtractNamedUuid() throws Exception {
200 Insert insert = mock(Insert.class);
201 when(insert.getUuidName()).thenReturn(UUID_NAME);
202 PowerMockito.mockStatic(SouthboundMapper.class);
203 PowerMockito.when(SouthboundMapper.getRandomUuid()).thenReturn(UUID_NAME);
204 doNothing().when(insert).setUuidName(anyString());
206 UUID uuid = mock(UUID.class);
207 PowerMockito.whenNew(UUID.class).withAnyArguments().thenReturn(uuid);
208 assertEquals(uuid, TransactUtils.extractNamedUuid(insert));
211 @SuppressWarnings("unchecked")
213 public void testStampInstanceIdentifier() {
214 TransactionBuilder transaction = mock(TransactionBuilder.class);
215 InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
216 TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
217 ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
218 InstanceIdentifierCodec instanceIdentifierCodec = mock(InstanceIdentifierCodec.class);
220 PowerMockito.doReturn(mock(Mutate.class)).when(TransactUtils.class);
221 TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema,
222 instanceIdentifierCodec);
224 when(transaction.add(any(Operation.class))).thenReturn(transaction);
225 TransactUtils.stampInstanceIdentifier(transaction, iid, tableSchema, columnSchema, instanceIdentifierCodec);
226 verify(transaction).add(any(Operation.class));
229 @SuppressWarnings({ "unchecked" })
231 public void testStampInstanceIdentifierMutation() throws Exception {
232 InstanceIdentifierCodec instanceIdentifierCodec = Mockito.mock(InstanceIdentifierCodec.class);
233 when(instanceIdentifierCodec.serialize(any(InstanceIdentifier.class))).thenReturn(IID_STRING);
235 Mutate<GenericTableSchema> mutate = mock(Mutate.class);
236 Operations op = (Operations) setField("op");
237 Mockito.<Mutate<GenericTableSchema>>when(op.mutate(any(TableSchema.class))).thenReturn(mutate);
238 when(mutate.addMutation(any(ColumnSchema.class), any(Mutator.class), any(Map.class))).thenReturn(mutate);
240 ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
241 when(columnSchema.getName()).thenReturn(COLUMN_SCHEMA_NAME);
242 PowerMockito.mockStatic(OvsdbSet.class);
243 PowerMockito.when(OvsdbSet.fromSet(any(Set.class))).thenReturn(mock(OvsdbSet.class));
244 Mutation deleteIidMutation = mock(Mutation.class);
245 PowerMockito.whenNew(Mutation.class).withAnyArguments().thenReturn(deleteIidMutation);
247 List<Mutation> listMutations = new ArrayList<>();
248 when(mutate.getMutations()).thenReturn(listMutations);
249 doNothing().when(mutate).setMutations(any(List.class));
251 InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
252 TransactionBuilder transaction = mock(TransactionBuilder.class);
253 TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
254 assertEquals(mutate, TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema,
255 instanceIdentifierCodec));
258 private Object setField(String fieldName) throws Exception {
259 Field field = Operations.class.getDeclaredField(fieldName);
260 field.setAccessible(true);
261 field.set(field.get(Operations.class), mock(Operations.class));
262 return field.get(Operations.class);