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.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;
  53
  54 import com.google.common.base.Predicates;
  55 import com.google.common.collect.Maps;
  56
  57 @RunWith(PowerMockRunner.class)
  58 @PrepareForTest({TransactUtils.class, SouthboundMapper.class, SouthboundUtil.class, OvsdbSet.class, Operations.class})
  59 public class TransactUtilsTest {
  60
  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";
  64
  65     @Before
  66     public void setUp() {
  67         PowerMockito.mockStatic(TransactUtils.class, Mockito.CALLS_REAL_METHODS);
  68     }
  69
  70     @Test
  71     public void testExtractNode() {
  72         Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
  73         assertEquals(HashMap.class, TransactUtils.extractNode(changes).getClass());
  74     }
  75
  76     @SuppressWarnings("unchecked")
  77     @Test
  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<>());
  84
  85         //test extractCreated()
  86         assertEquals(map, TransactUtils.extractCreated(changes, klazz));
  87
  88         //test extractUpdated()
  89         assertEquals(map, TransactUtils.extractUpdated(changes, klazz));
  90     }
  91
  92     @SuppressWarnings("unchecked")
  93     @Test
  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<>();
  98
  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);
 101
 102         Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
 103         InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
 104         DataObject db = mock(DataObject.class);
 105         map.put(iid, db);
 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);
 108
 109         Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
 110         testResult.put(iid, db);
 111         assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, klazz));
 112     }
 113
 114     @SuppressWarnings("unchecked")
 115     @Test
 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<>();
 120
 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);
 123
 124         Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
 125         InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
 126         DataObject db = mock(DataObject.class);
 127         map.put(iid, db);
 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);
 130
 131         Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
 132         testResult.put(iid, db);
 133         assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, klazz));
 134     }
 135
 136     @SuppressWarnings("unchecked")
 137     @Test
 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<>());
 144
 145         //test extractOriginal()
 146         assertEquals(map, TransactUtils.extractCreated(changes, klazz));
 147     }
 148
 149     @SuppressWarnings("unchecked")
 150     @Test
 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());
 155     }
 156
 157     @SuppressWarnings("unchecked")
 158     @Test
 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);
 165
 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));
 170     }
 171
 172     @Test
 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());
 177     }
 178
 179     @SuppressWarnings("rawtypes")
 180     @Test
 181     public void testExtractInsert() {
 182         TransactionBuilder transaction = mock(TransactionBuilder.class);
 183         GenericTableSchema schema = mock(GenericTableSchema.class);
 184
 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);
 190
 191         List<Insert> inserts = TransactUtils.extractInsert(transaction, schema);
 192         assertEquals(operation, inserts.get(0));
 193     }
 194
 195     @SuppressWarnings("rawtypes")
 196     @Test
 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());
 203
 204         UUID uuid = mock(UUID.class);
 205         PowerMockito.whenNew(UUID.class).withAnyArguments().thenReturn(uuid);
 206         assertEquals(uuid, TransactUtils.extractNamedUuid(insert));
 207     }
 208
 209     @SuppressWarnings("unchecked")
 210     @Test
 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);
 216
 217         PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "stampInstanceIdentifierMutation",
 218                 TransactionBuilder.class,
 219                 InstanceIdentifier.class,
 220                 TableSchema.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));
 226     }
 227
 228     @SuppressWarnings({ "unchecked" })
 229     @Test
 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);
 235
 236         PowerMockito.mockStatic(SouthboundUtil.class);
 237         PowerMockito.when(SouthboundUtil.serializeInstanceIdentifier(any(InstanceIdentifier.class))).thenReturn(IID_STRING);
 238
 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);
 243
 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);
 249
 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));
 254     }
 255
 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);
 261     }
 262 }