/*
- * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ * Copyright (c) 2016, 2017 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.ovsdb.hwvtepsouthbound;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.util.concurrent.ListenableFuture;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.net.InetAddress;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import org.apache.commons.lang3.reflect.FieldUtils;
import org.junit.After;
import org.junit.Before;
import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractDataBrokerTest;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.TransactionInvoker;
import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.TransactionInvokerImpl;
import org.opendaylight.ovsdb.lib.OvsdbClient;
+import org.opendaylight.ovsdb.lib.OvsdbConnection;
import org.opendaylight.ovsdb.lib.OvsdbConnectionInfo;
import org.opendaylight.ovsdb.lib.operations.Delete;
import org.opendaylight.ovsdb.lib.operations.Insert;
import org.opendaylight.ovsdb.lib.operations.OperationResult;
import org.opendaylight.ovsdb.lib.operations.Operations;
+import org.opendaylight.ovsdb.lib.operations.Select;
import org.opendaylight.ovsdb.lib.operations.Update;
import org.opendaylight.ovsdb.lib.operations.Where;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
+import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
import org.opendaylight.ovsdb.lib.schema.typed.TypedBaseTable;
+import org.opendaylight.ovsdb.lib.schema.typed.TypedDatabaseSchema;
+import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionHistory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.powermock.api.mockito.PowerMockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.io.InputStream;
-import java.net.InetAddress;
-import java.util.List;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
-import static org.powermock.api.support.membermodification.MemberMatcher.field;
-import static org.powermock.api.support.membermodification.MemberModifier.suppress;
-
public class DataChangeListenerTestBase extends AbstractDataBrokerTest {
static Logger LOG = LoggerFactory.getLogger(DataChangeListenerTestBase.class);
EntityOwnershipService entityOwnershipService;
OvsdbClient ovsdbClient;
- DatabaseSchema dbSchema;
- ListenableFuture<DatabaseSchema> listenableDbSchema = mock(ListenableFuture.class);
+ TypedDatabaseSchema dbSchema;
+ ListenableFuture<TypedDatabaseSchema> listenableDbSchema = mock(ListenableFuture.class);
TransactionInvoker transactionInvoker;
OvsdbConnectionInfo connectionInfo;
Operations operations;
entityOwnershipService = mock(EntityOwnershipService.class);
nodeUuid = java.util.UUID.randomUUID().toString();
nodeIid = createInstanceIdentifier(nodeUuid);
- ls0Iid = nodeIid.augmentation(HwvtepGlobalAugmentation.class).
- child(LogicalSwitches.class, new LogicalSwitchesKey(new HwvtepNodeName("ls0")));
- ls1Iid = nodeIid.augmentation(HwvtepGlobalAugmentation.class).
- child(LogicalSwitches.class, new LogicalSwitchesKey(new HwvtepNodeName("ls1")));
+ ls0Iid = nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(LogicalSwitches.class,
+ new LogicalSwitchesKey(new HwvtepNodeName("ls0")));
+ ls1Iid = nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(LogicalSwitches.class,
+ new LogicalSwitchesKey(new HwvtepNodeName("ls1")));
loadSchema();
mockConnectionInstance();
mockConnectionManager();
mockOperations();
- addNode(OPERATIONAL);
- addNode(CONFIGURATION);
+ addNode(LogicalDatastoreType.OPERATIONAL);
+ addNode(LogicalDatastoreType.CONFIGURATION);
hwvtepDataChangeListener = new HwvtepDataChangeListener(dataBroker, hwvtepConnectionManager);
}
@After
public void tearDown() throws Exception {
hwvtepDataChangeListener.close();
- deleteNode(OPERATIONAL);
- deleteNode(CONFIGURATION);
+ deleteNode(LogicalDatastoreType.OPERATIONAL);
+ deleteNode(LogicalDatastoreType.CONFIGURATION);
+ }
+
+ static final void setFinalStatic(final Class<?> cls, final String fieldName, final Object newValue)
+ throws SecurityException, ReflectiveOperationException {
+ Field[] fields = FieldUtils.getAllFields(cls);
+ for (Field field : fields) {
+ if (fieldName.equals(field.getName())) {
+ field.setAccessible(true);
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+ field.set(null, newValue);
+ break;
+ }
+ }
}
void loadSchema() {
- try (InputStream resourceAsStream = DataChangeListenerTestBase.class.getResourceAsStream("hwvtep_schema.json")) {
+ try (InputStream resourceAsStream = DataChangeListenerTestBase.class.getResourceAsStream(
+ "hwvtep_schema.json")) {
ObjectMapper mapper = new ObjectMapper();
JsonNode jsonNode = mapper.readTree(resourceAsStream);
- dbSchema = DatabaseSchema.fromJson(HwvtepSchemaConstants.HARDWARE_VTEP,
- jsonNode.get("result"));
+ dbSchema = TypedDatabaseSchema.of(DatabaseSchema.fromJson(HwvtepSchemaConstants.HARDWARE_VTEP,
+ jsonNode.get("result")));
listenableDbSchema = mock(ListenableFuture.class);
- when(listenableDbSchema.get()).thenReturn(dbSchema);
- } catch (Exception e) {
+ doReturn(dbSchema).when(listenableDbSchema).get();
+ } catch (IOException | ExecutionException | InterruptedException e) {
LOG.error("Failed to load schema", e);
}
}
private void mockConnectionManager() throws IllegalAccessException {
- hwvtepConnectionManager = PowerMockito.mock(HwvtepConnectionManager.class, Mockito.CALLS_REAL_METHODS);
- field(HwvtepConnectionManager.class, "db").set(hwvtepConnectionManager, dataBroker);
- field(HwvtepConnectionManager.class, "txInvoker").set(hwvtepConnectionManager, transactionInvoker);
- field(HwvtepConnectionManager.class, "entityOwnershipService").set(hwvtepConnectionManager, entityOwnershipService);
- suppress(PowerMockito.method(HwvtepConnectionManager.class, "getConnectionInstance", HwvtepPhysicalSwitchAttributes.class));
- when(hwvtepConnectionManager.getConnectionInstance(Mockito.any(HwvtepPhysicalSwitchAttributes.class))).
- thenReturn(connectionInstance);
- when(hwvtepConnectionManager.getConnectionInstance(Mockito.any(Node.class))).
- thenReturn(connectionInstance);
+ hwvtepConnectionManager = spy(new HwvtepConnectionManager(dataBroker, transactionInvoker,
+ entityOwnershipService, mock(OvsdbConnection.class)));
+ doReturn(connectionInstance).when(hwvtepConnectionManager).getConnectionInstance(
+ any(HwvtepPhysicalSwitchAttributes.class));
+ doReturn(connectionInstance).when(hwvtepConnectionManager).getConnectionInstance(any(Node.class));
+ doReturn(connectionInstance).when(hwvtepConnectionManager).getConnectionInstanceFromNodeIid(
+ any(InstanceIdentifier.class));
}
void mockConnectionInstance() throws IllegalAccessException {
connectionInfo = mock(OvsdbConnectionInfo.class);
+ doReturn(mock(InetAddress.class)).when(connectionInfo).getRemoteAddress();
+
ovsdbClient = mock(OvsdbClient.class);
- transactionInvoker = new TransactionInvokerImpl(dataBroker);
-
- connectionInstance = PowerMockito.mock(HwvtepConnectionInstance.class, Mockito.CALLS_REAL_METHODS);
- field(HwvtepConnectionInstance.class, "instanceIdentifier").set(connectionInstance, nodeIid);
- field(HwvtepConnectionInstance.class, "txInvoker").set(connectionInstance, transactionInvoker);
- field(HwvtepConnectionInstance.class, "deviceInfo").set(connectionInstance, new HwvtepDeviceInfo(connectionInstance));
- field(HwvtepConnectionInstance.class, "client").set(connectionInstance, ovsdbClient);
- when(connectionInstance.getConnectionInfo()).thenReturn(connectionInfo);
- when(connectionInstance.getConnectionInfo().getRemoteAddress()).thenReturn(mock(InetAddress.class));
- when(connectionInstance.getInstanceIdentifier()).thenReturn(nodeIid);
- doReturn(listenableDbSchema).when(connectionInstance).getSchema(anyString());
- when(connectionInstance.getDataBroker()).thenReturn(dataBroker);
- when(connectionInstance.getInstanceIdentifier()).thenReturn(nodeIid);
+ doReturn(true).when(ovsdbClient).isActive();
+ doReturn(connectionInfo).when(ovsdbClient).getConnectionInfo();
+ doReturn(listenableDbSchema).when(ovsdbClient).getSchema(anyString());
+
+ transactionInvoker = new TransactionInvokerImpl(dataBroker);
+
+ connectionInstance = new HwvtepConnectionInstance(null, null, ovsdbClient, nodeIid, transactionInvoker,
+ dataBroker);
+ connectionInstance.reconciliationFt.set(Boolean.TRUE);
+ connectionInstance.firstUpdateTriggered.set(true);
+ connectionInstance.setControllerTxHistory(new TransactionHistory(10000, 7500));
+ connectionInstance.setDeviceUpdateHistory(new TransactionHistory(10000, 7500));
connectionInstance.createTransactInvokers();
}
}
/**
- * resets the captures so that we can validate the captors of the immediate next execution
+ * Resets the captures so that we can validate the captors of the immediate next execution.
*/
void resetOperations() {
insertOpCapture = ArgumentCaptor.forClass(TypedBaseTable.class);
- Update update = mock(Update.class);
- Insert insert = mock(Insert.class);
Delete delete = mock(Delete.class);
Where where = mock(Where.class);
- when(delete.where(any())).thenReturn(where);
- when(insert.withId(any(String.class))).thenReturn(insert);
- Operations.op = PowerMockito.mock(Operations.class);
- when(Operations.op.insert(insertOpCapture.capture())).thenReturn(insert);
- when(Operations.op.update(insertOpCapture.capture())).thenReturn(update);
- when(update.where(any())).thenReturn(where);
- when(Operations.op.delete(any())).thenReturn(delete);
+ doReturn(where).when(delete).where(any());
+ Insert insert = mock(Insert.class);
+ doReturn(insert).when(insert).withId(any(String.class));
+ Operations mockOp = mock(Operations.class);
+ doReturn(insert).when(mockOp).insert(insertOpCapture.capture());
+ Update update = mock(Update.class);
+ doReturn(update).when(mockOp).update(insertOpCapture.capture());
+ Select select = mock(Select.class);
+ doReturn(select).when(mockOp).select(any(GenericTableSchema.class));
+ doReturn(where).when(update).where(any());
+ doReturn(delete).when(mockOp).delete(any());
+
+
+
+ try {
+ setFinalStatic(Operations.class, "op", mockOp);
+ } catch (SecurityException | ReflectiveOperationException e) {
+ throw new AssertionError("Set of Operations.op field failed", e);
+ }
+
ListenableFuture<List<OperationResult>> ft = mock(ListenableFuture.class);
transactCaptor = ArgumentCaptor.forClass(List.class);
- when(ovsdbClient.transact(any(DatabaseSchema.class), transactCaptor.capture())).thenReturn(ft);
+ doReturn(ft).when(ovsdbClient).transact(any(DatabaseSchema.class), transactCaptor.capture());
}
- void addNode(LogicalDatastoreType logicalDatastoreType) throws Exception {
+ void addNode(final LogicalDatastoreType logicalDatastoreType) throws Exception {
NodeBuilder nodeBuilder = prepareNode(nodeIid);
HwvtepGlobalAugmentationBuilder builder = new HwvtepGlobalAugmentationBuilder();
nodeBuilder.addAugmentation(HwvtepGlobalAugmentation.class, builder.build());
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
transaction.put(logicalDatastoreType, nodeIid, nodeBuilder.build(), WriteTransaction.CREATE_MISSING_PARENTS);
- transaction.submit();
+ transaction.commit();
}
- void deleteNode(LogicalDatastoreType logicalDatastoreType) {
+ void deleteNode(final LogicalDatastoreType logicalDatastoreType) {
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
tx.delete(logicalDatastoreType, nodeIid);
- tx.submit();
+ tx.commit();
}
- Node addData(LogicalDatastoreType logicalDatastoreType, Class<? extends DataObject> dataObject,
- String[]... data) {
+ Node addData(final LogicalDatastoreType logicalDatastoreType, final Class<? extends DataObject> dataObject,
+ final String[]... data) {
NodeBuilder nodeBuilder = prepareNode(nodeIid);
HwvtepGlobalAugmentationBuilder builder = new HwvtepGlobalAugmentationBuilder();
if (LogicalSwitches.class == dataObject) {
return mergeNode(logicalDatastoreType, nodeIid, nodeBuilder);
}
- void deleteData(LogicalDatastoreType logicalDatastoreType, Class<? extends DataObject> dataObject,
- String[]... data) {
+ void deleteData(final LogicalDatastoreType logicalDatastoreType, final Class<? extends DataObject> dataObject,
+ final String[]... data) {
NodeBuilder nodeBuilder = prepareNode(nodeIid);
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
HwvtepGlobalAugmentationBuilder builder = new HwvtepGlobalAugmentationBuilder();
List<LogicalSwitches> logicalSwitches = TestBuilders.addLogicalSwitches(builder, data);
for (LogicalSwitches ls : logicalSwitches) {
- InstanceIdentifier<LogicalSwitches> key = nodeIid.augmentation(HwvtepGlobalAugmentation.class).
- child(LogicalSwitches.class, ls.getKey());
+ InstanceIdentifier<LogicalSwitches> key =
+ nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(LogicalSwitches.class, ls.key());
tx.delete(logicalDatastoreType, key);
}
}
if (RemoteUcastMacs.class == dataObject) {
List<RemoteUcastMacs> macs = TestBuilders.addRemoteUcastMacs(nodeIid, builder, data);
for (RemoteUcastMacs mac : macs) {
- InstanceIdentifier<RemoteUcastMacs> key = nodeIid.augmentation(HwvtepGlobalAugmentation.class).
- child(RemoteUcastMacs.class, mac.getKey());
+ InstanceIdentifier<RemoteUcastMacs> key =
+ nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(RemoteUcastMacs.class, mac.key());
tx.delete(logicalDatastoreType, key);
}
}
if (RemoteMcastMacs.class == dataObject) {
List<RemoteMcastMacs> macs = TestBuilders.addRemoteMcastMacs(nodeIid, builder, data);
for (RemoteMcastMacs mac : macs) {
- InstanceIdentifier<RemoteMcastMacs> key = nodeIid.augmentation(HwvtepGlobalAugmentation.class).
- child(RemoteMcastMacs.class, mac.getKey());
+ InstanceIdentifier<RemoteMcastMacs> key =
+ nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(RemoteMcastMacs.class, mac.key());
tx.delete(logicalDatastoreType, key);
}
}
- tx.submit();
+ tx.commit();
}
- NodeBuilder prepareNode(InstanceIdentifier<Node> iid) {
+ NodeBuilder prepareNode(final InstanceIdentifier<Node> iid) {
NodeBuilder nodeBuilder = new NodeBuilder();
nodeBuilder.setNodeId(iid.firstKeyOf(Node.class).getNodeId());
return nodeBuilder;
}
- Node mergeNode(LogicalDatastoreType datastoreType, InstanceIdentifier<Node> id, NodeBuilder nodeBuilder) {
+ Node mergeNode(final LogicalDatastoreType datastoreType, final InstanceIdentifier<Node> id,
+ final NodeBuilder nodeBuilder) {
Node node = nodeBuilder.build();
WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
transaction.merge(datastoreType, id, node, WriteTransaction.CREATE_MISSING_PARENTS);
- transaction.submit();
+ transaction.commit();
return node;
}
- public InstanceIdentifier<Node> createInstanceIdentifier(String nodeIdString) {
+ public InstanceIdentifier<Node> createInstanceIdentifier(final String nodeIdString) {
NodeId nodeId = new NodeId(new Uri(nodeIdString));
NodeKey nodeKey = new NodeKey(nodeId);
TopologyKey topoKey = new TopologyKey(HwvtepSouthboundConstants.HWVTEP_TOPOLOGY_ID);
Code Review / ovsdb.git / blobdiff