southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtilsTest.java

   1 /*
   2  * Copyright (c) 2015 Inocybe Technologies and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.ovsdb.southbound.ovsdb.transact;
  10
  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;
  19
  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;
  25 import java.util.Map;
  26 import java.util.Set;
  27
  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;
  54
  55 import com.google.common.base.Predicates;
  56 import com.google.common.collect.Maps;
  57
  58 @RunWith(PowerMockRunner.class)
  59 @PrepareForTest({TransactUtils.class, SouthboundMapper.class, SouthboundUtil.class, OvsdbSet.class, Operations.class})
  60 public class TransactUtilsTest {
  61
  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";
  65
  66     @Before
  67     public void setUp() {
  68         PowerMockito.mockStatic(TransactUtils.class, Mockito.CALLS_REAL_METHODS);
  69     }
  70
  71     @Test
  72     public void testExtractNode() {
  73         Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
  74         assertEquals(HashMap.class, TransactUtils.extractNode(changes).getClass());
  75     }
  76
  77     @SuppressWarnings("unchecked")
  78     @Test
  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<>());
  85
  86         //test extractCreated()
  87         assertEquals(map, TransactUtils.extractCreated(changes, klazz));
  88
  89         //test extractUpdated()
  90         assertEquals(map, TransactUtils.extractUpdated(changes, klazz));
  91     }
  92
  93     @SuppressWarnings("unchecked")
  94     @Test
  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<>();
  99
 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);
 102
 103         Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
 104         InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
 105         DataObject db = mock(DataObject.class);
 106         map.put(iid, db);
 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);
 109
 110         Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
 111         testResult.put(iid, db);
 112         assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, klazz));
 113     }
 114
 115     @SuppressWarnings("unchecked")
 116     @Test
 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<>();
 121
 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);
 124
 125         Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
 126         InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
 127         DataObject db = mock(DataObject.class);
 128         map.put(iid, db);
 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);
 131
 132         Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
 133         testResult.put(iid, db);
 134         assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, klazz));
 135     }
 136
 137     @SuppressWarnings("unchecked")
 138     @Test
 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<>());
 145
 146         //test extractOriginal()
 147         assertEquals(map, TransactUtils.extractCreated(changes, klazz));
 148     }
 149
 150     @SuppressWarnings("unchecked")
 151     @Test
 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());
 156     }
 157
 158     @SuppressWarnings("unchecked")
 159     @Test
 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);
 166
 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));
 171     }
 172
 173     @Test
 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());
 178     }
 179
 180     @SuppressWarnings("rawtypes")
 181     @Test
 182     public void testExtractInsert() {
 183         TransactionBuilder transaction = mock(TransactionBuilder.class);
 184         GenericTableSchema schema = mock(GenericTableSchema.class);
 185
 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);
 191
 192         List<Insert> inserts = TransactUtils.extractInsert(transaction, schema);
 193         assertEquals(operation, inserts.get(0));
 194     }
 195
 196     @SuppressWarnings("rawtypes")
 197     @Test
 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());
 204
 205         UUID uuid = mock(UUID.class);
 206         PowerMockito.whenNew(UUID.class).withAnyArguments().thenReturn(uuid);
 207         assertEquals(uuid, TransactUtils.extractNamedUuid(insert));
 208     }
 209
 210     @SuppressWarnings("unchecked")
 211     @Test
 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);
 217
 218         PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "stampInstanceIdentifierMutation",
 219                 TransactionBuilder.class,
 220                 InstanceIdentifier.class,
 221                 TableSchema.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));
 227     }
 228
 229     @SuppressWarnings({ "unchecked" })
 230     @Test
 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);
 236
 237         PowerMockito.mockStatic(SouthboundUtil.class);
 238         PowerMockito.when(SouthboundUtil.serializeInstanceIdentifier(any(InstanceIdentifier.class))).thenReturn(IID_STRING);
 239
 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);
 244
 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);
 250
 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));
 255     }
 256
 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);
 262     }
 263 }