* 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.Matchers.any;
-import static org.mockito.Matchers.anyString;
+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.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;
+import static org.mockito.Mockito.spy;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
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;
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;
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);
}
- void setFinalStatic(Class cls, String fieldName, Object newValue) throws Exception {
+ 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())) {
"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);
doReturn(dbSchema).when(listenableDbSchema).get();
} catch (IOException | ExecutionException | InterruptedException 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));
- suppress(PowerMockito.method(HwvtepConnectionManager.class, "getConnectionInstanceFromNodeIid",
- InstanceIdentifier.class));
- doReturn(connectionInstance).when(
- hwvtepConnectionManager).getConnectionInstance(Mockito.any(HwvtepPhysicalSwitchAttributes.class));
- doReturn(connectionInstance).when(
- hwvtepConnectionManager).getConnectionInstance(Mockito.any(Node.class));
- doReturn(connectionInstance).when(
- hwvtepConnectionManager).getConnectionInstanceFromNodeIid(Mockito.any(InstanceIdentifier.class));
+ 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 {
ovsdbClient = mock(OvsdbClient.class);
doReturn(true).when(ovsdbClient).isActive();
doReturn(connectionInfo).when(ovsdbClient).getConnectionInfo();
+ doReturn(listenableDbSchema).when(ovsdbClient).getSchema(anyString());
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, "client").set(connectionInstance, ovsdbClient);
- doReturn(nodeIid).when(connectionInstance).getInstanceIdentifier();
- doReturn(listenableDbSchema).when(connectionInstance).getSchema(anyString());
- doReturn(dataBroker).when(connectionInstance).getDataBroker();
- doReturn(nodeIid).when(connectionInstance).getInstanceIdentifier();
- field(HwvtepConnectionInstance.class, "deviceInfo").set(connectionInstance,
- new HwvtepDeviceInfo(connectionInstance));
+ 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();
}
doReturn(where).when(delete).where(any());
Insert insert = mock(Insert.class);
doReturn(insert).when(insert).withId(any(String.class));
- Operations.op = PowerMockito.mock(Operations.class);
- doReturn(insert).when(Operations.op).insert(insertOpCapture.capture());
+ Operations mockOp = mock(Operations.class);
+ doReturn(insert).when(mockOp).insert(insertOpCapture.capture());
Update update = mock(Update.class);
- doReturn(update).when(Operations.op).update(insertOpCapture.capture());
+ 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(Operations.op).delete(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);
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();
for (LogicalSwitches ls : logicalSwitches) {
InstanceIdentifier<LogicalSwitches> key =
- nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(LogicalSwitches.class, ls.getKey());
+ nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(LogicalSwitches.class, ls.key());
tx.delete(logicalDatastoreType, key);
}
}
List<RemoteUcastMacs> macs = TestBuilders.addRemoteUcastMacs(nodeIid, builder, data);
for (RemoteUcastMacs mac : macs) {
InstanceIdentifier<RemoteUcastMacs> key =
- nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(RemoteUcastMacs.class, mac.getKey());
+ nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(RemoteUcastMacs.class, mac.key());
tx.delete(logicalDatastoreType, key);
}
}
List<RemoteMcastMacs> macs = TestBuilders.addRemoteMcastMacs(nodeIid, builder, data);
for (RemoteMcastMacs mac : macs) {
InstanceIdentifier<RemoteMcastMacs> key =
- nodeIid.augmentation(HwvtepGlobalAugmentation.class).child(RemoteMcastMacs.class, mac.getKey());
+ 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