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 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     @SuppressWarnings("unchecked")
 150     @Test
 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());
 155     }
 156
 157     @Test
 158     public void testExtractRemovedObjects() {
 159         Set<InstanceIdentifier<DataObject>> iids = new HashSet<>();
 160
 161         PowerMockito.doReturn(iids).when(TransactUtils.class);
 162         TransactUtils.extractRemoved(any(DataChangeEvent.class), eq(DataObject.class));
 163
 164         Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
 165
 166         PowerMockito.doReturn(result).when(TransactUtils.class);
 167         TransactUtils.extractOriginal(any(DataChangeEvent.class), eq(DataObject.class));
 168
 169         Class<DataObject> klazz = DataObject.class;
 170         DataChangeEvent changes = mock(DataChangeEvent.class);
 171         assertEquals(Maps.filterKeys(result, Predicates.in(iids)), TransactUtils.extractRemovedObjects(changes, klazz));
 172     }
 173
 174     @Test
 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());
 179     }
 180
 181     @SuppressWarnings("rawtypes")
 182     @Test
 183     public void testExtractInsert() {
 184         TransactionBuilder transaction = mock(TransactionBuilder.class);
 185         GenericTableSchema schema = mock(GenericTableSchema.class);
 186
 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);
 192
 193         List<Insert> inserts = TransactUtils.extractInsert(transaction, schema);
 194         assertEquals(operation, inserts.get(0));
 195     }
 196
 197     @SuppressWarnings("rawtypes")
 198     @Test
 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());
 205
 206         UUID uuid = mock(UUID.class);
 207         PowerMockito.whenNew(UUID.class).withAnyArguments().thenReturn(uuid);
 208         assertEquals(uuid, TransactUtils.extractNamedUuid(insert));
 209     }
 210
 211     @SuppressWarnings("unchecked")
 212     @Test
 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);
 219
 220         PowerMockito.doReturn(mock(Mutate.class)).when(TransactUtils.class);
 221         TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema,
 222             instanceIdentifierCodec);
 223
 224         when(transaction.add(any(Operation.class))).thenReturn(transaction);
 225         TransactUtils.stampInstanceIdentifier(transaction, iid, tableSchema, columnSchema, instanceIdentifierCodec);
 226         verify(transaction).add(any(Operation.class));
 227     }
 228
 229     @SuppressWarnings({ "unchecked" })
 230     @Test
 231     public void testStampInstanceIdentifierMutation() throws Exception {
 232         InstanceIdentifierCodec instanceIdentifierCodec = Mockito.mock(InstanceIdentifierCodec.class);
 233         when(instanceIdentifierCodec.serialize(any(InstanceIdentifier.class))).thenReturn(IID_STRING);
 234
 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);
 239
 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);
 246
 247         List<Mutation> listMutations = new ArrayList<>();
 248         when(mutate.getMutations()).thenReturn(listMutations);
 249         doNothing().when(mutate).setMutations(any(List.class));
 250
 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));
 256     }
 257
 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);
 263     }
 264 }