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.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;
  19
  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;
  27 import java.util.Map;
  28 import java.util.Set;
  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;
  53
  54 @RunWith(PowerMockRunner.class)
  55 @PrepareForTest({TransactUtils.class, SouthboundMapper.class, SouthboundUtil.class, OvsdbSet.class, Operations.class})
  56 public class TransactUtilsTest {
  57
  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";
  61
  62     @Before
  63     public void setUp() {
  64         PowerMockito.mockStatic(TransactUtils.class, Mockito.CALLS_REAL_METHODS);
  65     }
  66
  67     @Test
  68     public void testExtractNode() {
  69         Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
  70         assertEquals(HashMap.class, TransactUtils.extractNode(changes).getClass());
  71     }
  72
  73     @SuppressWarnings("unchecked")
  74     @Test
  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<>());
  81
  82         //test extractCreated()
  83         assertEquals(map, TransactUtils.extractCreated(changes, klazz));
  84
  85         //test extractUpdated()
  86         assertEquals(map, TransactUtils.extractUpdated(changes, klazz));
  87     }
  88
  89     @SuppressWarnings("unchecked")
  90     @Test
  91     public void testExtractCreatedOrUpdated() {
  92         Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
  93
  94         PowerMockito.doReturn(result).when(TransactUtils.class);
  95         TransactUtils.extractUpdated(any(DataChangeEvent.class), eq(DataObject.class));
  96
  97         Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
  98         InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
  99
 100         DataObject db = mock(DataObject.class);
 101         map.put(iid, db);
 102
 103         PowerMockito.doReturn(map).when(TransactUtils.class);
 104         TransactUtils.extractCreated(any(DataChangeEvent.class), eq(DataObject.class));
 105
 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));
 111     }
 112
 113     @Test
 114     @SuppressWarnings("unchecked")
 115     public void testExtractCreatedOrUpdatedOrRemoved() {
 116         Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
 117
 118         PowerMockito.doReturn(result).when(TransactUtils.class);
 119         TransactUtils.extractCreatedOrUpdated(any(DataChangeEvent.class), eq(DataObject.class));
 120
 121         Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
 122         InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
 123         DataObject db = mock(DataObject.class);
 124         map.put(iid, db);
 125
 126         PowerMockito.doReturn(map).when(TransactUtils.class);
 127         TransactUtils.extractRemovedObjects(any(DataChangeEvent.class), eq(DataObject.class));
 128
 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));
 134     }
 135
 136     @SuppressWarnings("unchecked")
 137     @Test
 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<>());
 144
 145         //test extractOriginal()
 146         assertEquals(map, TransactUtils.extractCreated(changes, klazz));
 147     }
 148
 149     @Test
 150     public void testExtractRemoved() {
 151         DataChangeEvent changes = mock(DataChangeEvent.class);
 152         Class<DataObject> klazz = DataObject.class;
 153         assertEquals(HashSet.class, TransactUtils.extractRemoved(changes, klazz).getClass());
 154     }
 155
 156     @Test
 157     public void testExtractRemovedObjects() {
 158         Set<InstanceIdentifier<DataObject>> iids = new HashSet<>();
 159
 160         PowerMockito.doReturn(iids).when(TransactUtils.class);
 161         TransactUtils.extractRemoved(any(DataChangeEvent.class), eq(DataObject.class));
 162
 163         Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
 164
 165         PowerMockito.doReturn(result).when(TransactUtils.class);
 166         TransactUtils.extractOriginal(any(DataChangeEvent.class), eq(DataObject.class));
 167
 168         Class<DataObject> klazz = DataObject.class;
 169         DataChangeEvent changes = mock(DataChangeEvent.class);
 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         InstanceIdentifierCodec instanceIdentifierCodec = mock(InstanceIdentifierCodec.class);
 218
 219         PowerMockito.doReturn(mock(Mutate.class)).when(TransactUtils.class);
 220         TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema,
 221             instanceIdentifierCodec);
 222
 223         when(transaction.add(any(Operation.class))).thenReturn(transaction);
 224         TransactUtils.stampInstanceIdentifier(transaction, iid, tableSchema, columnSchema, instanceIdentifierCodec);
 225         verify(transaction).add(any(Operation.class));
 226     }
 227
 228     @SuppressWarnings({ "unchecked" })
 229     @Test
 230     public void testStampInstanceIdentifierMutation() throws Exception {
 231         InstanceIdentifierCodec instanceIdentifierCodec = Mockito.mock(InstanceIdentifierCodec.class);
 232         when(instanceIdentifierCodec.serialize(any(InstanceIdentifier.class))).thenReturn(IID_STRING);
 233
 234         Mutate<GenericTableSchema> mutate = mock(Mutate.class);
 235         Operations op = (Operations) setField("op");
 236         Mockito.<Mutate<GenericTableSchema>>when(op.mutate(any(TableSchema.class))).thenReturn(mutate);
 237         when(mutate.addMutation(any(ColumnSchema.class), any(Mutator.class), any(Map.class))).thenReturn(mutate);
 238
 239         ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
 240         when(columnSchema.getName()).thenReturn(COLUMN_SCHEMA_NAME);
 241         PowerMockito.mockStatic(OvsdbSet.class);
 242         PowerMockito.when(OvsdbSet.fromSet(any(Set.class))).thenReturn(mock(OvsdbSet.class));
 243         Mutation deleteIidMutation = mock(Mutation.class);
 244         PowerMockito.whenNew(Mutation.class).withAnyArguments().thenReturn(deleteIidMutation);
 245
 246         List<Mutation> listMutations = new ArrayList<>();
 247         when(mutate.getMutations()).thenReturn(listMutations);
 248         doNothing().when(mutate).setMutations(any(List.class));
 249
 250         InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
 251         TransactionBuilder transaction = mock(TransactionBuilder.class);
 252         TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
 253         assertEquals(mutate, TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema,
 254                 instanceIdentifierCodec));
 255     }
 256
 257     private static Object setField(final 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 }