*/
package org.opendaylight.ovsdb.southbound;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.FluentFuture;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
private static final Logger LOG = LoggerFactory.getLogger(SouthboundProvider.class);
private static final String ENTITY_TYPE = "ovsdb-southbound-provider";
- // FIXME: get rid of this static
- @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
- private static DataBroker db;
// FIXME: get rid of this static
private static List<String> reconcileBridgeInclusionList = List.of();
// FIXME: get rid of this static
private static List<String> reconcileBridgeExclusionList = List.of();
- public static DataBroker getDb() {
- return db;
- }
-
public static List<String> getBridgesReconciliationInclusionList() {
return reconcileBridgeInclusionList;
}
private final SystemReadyMonitor systemReadyMonitor;
private final AtomicBoolean registered = new AtomicBoolean(false);
private final OvsdbDiagStatusProvider ovsdbStatusProvider;
+ private final DataBroker dataBroker;
private Registration registration;
private Registration operTopologyRegistration;
final boolean skipMonitoringManagerStatus,
final List<String> bridgeReconciliationInclusions,
final List<String> bridgeReconciliationExclusions) {
+ this.dataBroker = requireNonNull(dataBroker);
// FIXME: get rid of this static wiring
- db = dataBroker;
reconcileBridgeInclusionList = bridgeReconciliationInclusions;
reconcileBridgeExclusionList = bridgeReconciliationExclusions;
LOG.debug("skipManagerStatus set to {}", skipMonitoringManagerStatus);
ovsdbStatusProvider.close();
}
- private static void initializeOvsdbTopology(final @NonNull LogicalDatastoreType type) {
+ private void initializeOvsdbTopology(final @NonNull LogicalDatastoreType type) {
InstanceIdentifier<Topology> path = InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
- ReadWriteTransaction transaction = db.newReadWriteTransaction();
+ ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
FluentFuture<Boolean> ovsdbTp = transaction.exists(type, path);
try {
if (!ovsdbTp.get().booleanValue()) {
import org.opendaylight.ovsdb.schema.openvswitch.AutoAttach;
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
-import org.opendaylight.ovsdb.southbound.SouthboundProvider;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Autoattach;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.AutoattachKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> original,
final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> updated) {
-
- for (final Map.Entry<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> originalEntry :
- original.entrySet()) {
+ for (var originalEntry : original.entrySet()) {
final InstanceIdentifier<OvsdbNodeAugmentation> ovsdbNodeIid = originalEntry.getKey();
final OvsdbNodeAugmentation ovsdbNodeAugmentation = originalEntry.getValue();
final OvsdbNodeAugmentation deletedOvsdbNodeAugmentation = updated.get(ovsdbNodeIid);
state.getBridgeNode(ovsdbNodeIid).orElseThrow().augmentation(OvsdbNodeAugmentation.class);
final Map<AutoattachKey, Autoattach> currentAutoAttach = currentOvsdbNode.getAutoattach();
for (final Autoattach origAutoattach : origAutoattachList.values()) {
- deleteAutoAttach(transaction, ovsdbNodeIid, getAutoAttachUuid(currentAutoAttach,
- origAutoattach.key()));
+ deleteAutoAttach(state, transaction, ovsdbNodeIid,
+ getAutoAttachUuid(currentAutoAttach, origAutoattach.key()));
}
}
}
}
}
- private static void deleteAutoAttach(final TransactionBuilder transaction,
+ private static void deleteAutoAttach(final BridgeOperationalState state, final TransactionBuilder transaction,
final InstanceIdentifier<OvsdbNodeAugmentation> ovsdbNodeIid,
final Uuid autoattachUuid) {
LOG.debug("Received request to delete Autoattach entry {}", autoattachUuid);
- final OvsdbBridgeAugmentation bridgeAugmentation = getBridge(ovsdbNodeIid, autoattachUuid);
+ final OvsdbBridgeAugmentation bridgeAugmentation = getBridge(state, ovsdbNodeIid, autoattachUuid);
if (autoattachUuid != null && bridgeAugmentation != null) {
final UUID uuid = new UUID(autoattachUuid.getValue());
final AutoAttach autoattach = transaction.getTypedRowSchema(AutoAttach.class);
return null;
}
- private static OvsdbBridgeAugmentation getBridge(final InstanceIdentifier<OvsdbNodeAugmentation> key,
- final Uuid aaUuid) {
+ private static OvsdbBridgeAugmentation getBridge(final BridgeOperationalState state,
+ final InstanceIdentifier<OvsdbNodeAugmentation> key, final Uuid aaUuid) {
if (aaUuid == null) {
return null;
}
- OvsdbBridgeAugmentation bridge = null;
- final InstanceIdentifier<Node> nodeIid = key.firstIdentifierOf(Node.class);
- try (ReadTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
- final Optional<Node> nodeOptional = SouthboundUtil.readNode(transaction, nodeIid);
+ try (ReadTransaction transaction = state.dataBroker().newReadOnlyTransaction()) {
+ final var nodeOptional = SouthboundUtil.readNode(transaction, key.firstIdentifierOf(Node.class));
if (nodeOptional.isPresent()) {
- final Map<ManagedNodeEntryKey, ManagedNodeEntry> managedNodes =
- nodeOptional.orElseThrow().augmentation(OvsdbNodeAugmentation.class).getManagedNodeEntry();
+ final var managedNodes = nodeOptional.orElseThrow()
+ .augmentation(OvsdbNodeAugmentation.class).getManagedNodeEntry();
for (final ManagedNodeEntry managedNode : managedNodes.values()) {
final OvsdbBridgeRef ovsdbBridgeRef = managedNode.getBridgeRef();
final InstanceIdentifier<OvsdbBridgeAugmentation> brIid = ovsdbBridgeRef.getValue()
.firstIdentifierOf(Node.class).augmentation(OvsdbBridgeAugmentation.class);
final Optional<OvsdbBridgeAugmentation> optionalBridge =
transaction.read(LogicalDatastoreType.OPERATIONAL, brIid).get();
- bridge = optionalBridge.orElseThrow();
+ OvsdbBridgeAugmentation bridge = optionalBridge.orElseThrow();
if (bridge != null && bridge.getAutoAttach() != null
&& bridge.getAutoAttach().equals(aaUuid)) {
return bridge;
}
}
} catch (InterruptedException | ExecutionException e) {
- LOG.warn("Error reading from datastore",e);
+ LOG.warn("Error reading from datastore", e);
}
return null;
}
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
-import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Optional;
+import java.util.Set;
import java.util.concurrent.ExecutionException;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
-import org.opendaylight.ovsdb.southbound.SouthboundProvider;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
execute(transaction, state, TransactUtils.extractCreatedOrUpdated(modifications, OvsdbNodeAugmentation.class));
}
- private void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
- final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> createdOrUpdated) {
-
- for (final Entry<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> ovsdbNodeEntry
- : createdOrUpdated.entrySet()) {
+ private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
+ final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> createdOrUpdated) {
+ for (var ovsdbNodeEntry : createdOrUpdated.entrySet()) {
updateAutoAttach(transaction, state, ovsdbNodeEntry.getKey(), ovsdbNodeEntry.getValue());
}
}
final String namedUuid = SouthboundMapper.getRandomUuid();
final Bridge bridge = transaction.getTypedRowWrapper(Bridge.class);
transaction.add(op.insert(autoAttachWrapper).withId(namedUuid));
- final OvsdbBridgeAugmentation ovsdbBridgeAugmentation = getBridge(iid, bridgeUri);
+
+ final var ovsdbBridgeAugmentation = getBridge(state, iid, bridgeUri);
if (ovsdbBridgeAugmentation != null) {
- bridge.setName(ovsdbBridgeAugmentation.getBridgeName().getValue());
- bridge.setAutoAttach(Collections.singleton(new UUID(namedUuid)));
+ final var bridgeName = ovsdbBridgeAugmentation.getBridgeName().getValue();
+ bridge.setName(bridgeName);
+ bridge.setAutoAttach(Set.of(new UUID(namedUuid)));
LOG.trace("Create Autoattach table {}, and mutate the bridge {}",
- autoAttach.getAutoattachId(), getBridge(iid, bridgeUri).getBridgeName().getValue());
+ autoAttach.getAutoattachId(), bridgeName);
transaction.add(op.mutate(bridge)
.addMutation(bridge.getAutoAttachColumn().getSchema(),
Mutator.INSERT,bridge.getAutoAttachColumn().getData())
.where(bridge.getNameColumn().getSchema()
.opEqual(bridge.getNameColumn().getData())).build());
- transaction.add(
- op.comment("Bridge: Mutating " + ovsdbBridgeAugmentation.getBridgeName().getValue()
- + " to add autoattach column " + namedUuid));
+ transaction.add(op.comment(
+ "Bridge: Mutating " + bridgeName + " to add autoattach column " + namedUuid));
}
}
}
}
}
- private static OvsdbBridgeAugmentation getBridge(final InstanceIdentifier<OvsdbNodeAugmentation> key,
- final Uri bridgeUri) {
- final InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid = InstanceIdentifier
- .create(NetworkTopology.class)
+ private static OvsdbBridgeAugmentation getBridge(final BridgeOperationalState state,
+ final InstanceIdentifier<OvsdbNodeAugmentation> key, final Uri bridgeUri) {
+ final InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid = InstanceIdentifier.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
.child(Node.class, new NodeKey(new NodeId(bridgeUri)))
.augmentation(OvsdbBridgeAugmentation.class);
- OvsdbBridgeAugmentation bridge = null;
- try (ReadTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
- final Optional<OvsdbBridgeAugmentation> bridgeOptional =
- transaction.read(LogicalDatastoreType.OPERATIONAL, bridgeIid).get();
+ try (ReadTransaction transaction = state.dataBroker().newReadOnlyTransaction()) {
+ final var bridgeOptional = transaction.read(LogicalDatastoreType.OPERATIONAL, bridgeIid).get();
if (bridgeOptional.isPresent()) {
- bridge = bridgeOptional.orElseThrow();
+ return bridgeOptional.orElseThrow();
}
+ LOG.debug("No bridge found for {}", bridgeUri);
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Error reading from datastore", e);
}
- return bridge;
+ return null;
}
private static Uuid getAutoAttachUuid(final Map<AutoattachKey, Autoattach> currentAutoAttach,
*/
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
public class BridgeOperationalState {
private static final Logger LOG = LoggerFactory.getLogger(BridgeOperationalState.class);
- private final DataBroker db;
- public BridgeOperationalState(DataBroker db, DataChangeEvent changes) {
- this.db = db;
+ private final DataBroker dataBroker;
+
+ public BridgeOperationalState(DataBroker dataBroker) {
+ this.dataBroker = requireNonNull(dataBroker);
+ }
+
+ @Deprecated
+ public BridgeOperationalState(DataBroker dataBroker, DataChangeEvent changes) {
+ this.dataBroker = requireNonNull(dataBroker);
+ }
+
+ @Deprecated
+ public BridgeOperationalState(DataBroker dataBroker, Collection<DataTreeModification<Node>> changes) {
+ this.dataBroker = requireNonNull(dataBroker);
}
- public BridgeOperationalState(DataBroker db, Collection<DataTreeModification<Node>> changes) {
- this.db = db;
+ // FIXME: this instance should not be exposed and users just use methods of this class
+ @Deprecated
+ final DataBroker dataBroker() {
+ return dataBroker;
}
@SuppressWarnings("IllegalCatch")
public Optional<Node> getBridgeNode(InstanceIdentifier<?> iid) {
InstanceIdentifier<Node> nodeIid = iid.firstIdentifierOf(Node.class);
- try (ReadTransaction transaction = db.newReadOnlyTransaction()) {
+ try (ReadTransaction transaction = dataBroker.newReadOnlyTransaction()) {
return SouthboundUtil.readNode(transaction, nodeIid);
} catch (Exception exp) {
LOG.error("Error in getting the brideNode for {}", iid, exp);
import org.opendaylight.ovsdb.schema.openvswitch.Port;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
-import org.opendaylight.ovsdb.southbound.SouthboundProvider;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
import org.opendaylight.ovsdb.utils.yang.YangUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.slf4j.LoggerFactory;
public class TerminationPointUpdateCommand implements TransactCommand {
-
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointUpdateCommand.class);
@Override
OvsdbBridgeAugmentation operBridge = ovsdbBridgeOptional.orElseThrow();
if (operBridge != null) {
Port port = transaction.getTypedRowWrapper(Port.class);
- updatePort(terminationPoint, port, operBridge, opendaylightIid);
+ updatePort(state, terminationPoint, port, operBridge, opendaylightIid);
Port extraPort = transaction.getTypedRowWrapper(Port.class);
extraPort.setName("");
transaction.add(op.update(port)
updateInterfacePolicing(terminationPoint, ovsInterface);
}
- private static void updatePort(final OvsdbTerminationPointAugmentation terminationPoint,
- final Port port, final OvsdbBridgeAugmentation operBridge, final String opendaylightIid) {
+ private static void updatePort(final BridgeOperationalState state,
+ final OvsdbTerminationPointAugmentation terminationPoint, final Port port,
+ final OvsdbBridgeAugmentation operBridge, final String opendaylightIid) {
updatePortOtherConfig(terminationPoint, port);
updatePortVlanTag(terminationPoint, port);
updatePortVlanTrunk(terminationPoint, port);
updatePortVlanMode(terminationPoint, port);
updatePortExternalIds(terminationPoint, port, opendaylightIid);
- updatePortQos(terminationPoint, port, operBridge);
+ updatePortQos(state, terminationPoint, port, operBridge);
}
- private static void updatePortQos(final OvsdbTerminationPointAugmentation terminationPoint,
- final Port port, final OvsdbBridgeAugmentation operBridge) {
-
- Set<UUID> uuidSet = new HashSet<>();
+ private static void updatePortQos(final BridgeOperationalState state,
+ final OvsdbTerminationPointAugmentation terminationPoint, final Port port,
+ final OvsdbBridgeAugmentation operBridge) {
+ final var uuidSet = new HashSet<UUID>();
// First check if QosEntry is present and use that
- if (terminationPoint.getQosEntry() != null && !terminationPoint.getQosEntry().isEmpty()) {
- OvsdbQosRef qosRef = terminationPoint.getQosEntry().values().iterator().next().getQosRef();
+ final var tpQosEntry = terminationPoint.getQosEntry();
+ if (tpQosEntry != null && !tpQosEntry.isEmpty()) {
+ OvsdbQosRef qosRef = tpQosEntry.values().iterator().next().getQosRef();
Uri qosId = qosRef.getValue().firstKeyOf(QosEntries.class).getQosId();
- OvsdbNodeAugmentation operNode = getOperNode(operBridge);
+ OvsdbNodeAugmentation operNode = getOperNode(state, operBridge);
if (operNode != null) {
Map<QosEntriesKey, QosEntries> entries = operNode.getQosEntries();
if (entries != null) {
}
@SuppressWarnings("IllegalCatch")
- private static OvsdbNodeAugmentation getOperNode(final OvsdbBridgeAugmentation operBridge) {
+ private static OvsdbNodeAugmentation getOperNode(final BridgeOperationalState state,
+ final OvsdbBridgeAugmentation operBridge) {
@SuppressWarnings("unchecked")
InstanceIdentifier<Node> iidNode = (InstanceIdentifier<Node>)operBridge.getManagedBy().getValue();
OvsdbNodeAugmentation operNode = null;
- try (ReadTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
+ try (ReadTransaction transaction = state.dataBroker().newReadOnlyTransaction()) {
Optional<Node> nodeOptional = SouthboundUtil.readNode(transaction, iidNode);
if (nodeOptional.isPresent()) {
operNode = nodeOptional.orElseThrow().augmentation(OvsdbNodeAugmentation.class);
*/
package org.opendaylight.ovsdb.southbound;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import com.google.common.base.Stopwatch;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
@Test
public void testInit() throws CandidateAlreadyRegisteredException {
// Indicate that this is the owner
- when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
- java.util.Optional.of(EntityOwnershipState.from(true, true)));
+ when(entityOwnershipService.getOwnershipState(any(Entity.class)))
+ .thenReturn(Optional.of(EntityOwnershipState.from(true, true)));
try (SouthboundProvider southboundProvider = new SouthboundProvider(
getDataBroker(),
@Test
public void testInitWithClose() throws CandidateAlreadyRegisteredException {
// Indicate that this is the owner
- when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
- java.util.Optional.of(EntityOwnershipState.from(true, true)));
+ when(entityOwnershipService.getOwnershipState(any(Entity.class)))
+ .thenReturn(Optional.of(EntityOwnershipState.from(true, true)));
try (SouthboundProvider southboundProvider = new SouthboundProvider(
getDataBroker(),
}
}
- @Test
- public void testGetDb() {
- when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
- java.util.Optional.of(EntityOwnershipState.from(true, true)));
-
- try (SouthboundProvider southboundProvider = new SouthboundProvider(
- getDataBroker(),
- entityOwnershipService,
- Mockito.mock(OvsdbConnection.class),
- Mockito.mock(DOMSchemaService.class),
- Mockito.mock(BindingNormalizedNodeSerializer.class),
- new TestSystemReadyMonitor(IMMEDIATE),
- diagStatusService)) {
-
- assertEquals(getDataBroker(), SouthboundProvider.getDb());
- }
- }
-
@Test
public void testHandleOwnershipChange() throws ExecutionException, InterruptedException {
when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
- java.util.Optional.of(EntityOwnershipState.from(false, true)));
+ Optional.of(EntityOwnershipState.from(false, true)));
Entity entity = new Entity("ovsdb-southbound-provider", "ovsdb-southbound-provider");
KeyedInstanceIdentifier<Topology, TopologyKey> topologyIid = InstanceIdentifier
.create(NetworkTopology.class)
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.powermock.reflect.Whitebox.getField;
import java.util.Map;
import java.util.Optional;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
.child(Topology.class).child(Node.class);
private final Node brNode = new NodeBuilder().setNodeId(new NodeId("bar")).build();
- @Mock private BridgeOperationalState briOperationState;
- @Mock private DataBroker db;
- @Mock ReadTransaction mockReadTx;
+ @Mock
+ private BridgeOperationalState briOperationState;
+ @Mock
+ private DataBroker db;
+ @Mock
+ private ReadTransaction mockReadTx;
private InstanceIdentifier<ProtocolEntry> protocolEntry;
private InstanceIdentifier<Node> iidNode;
- private Map<InstanceIdentifier<Node>, Node> operationalNodes;
@Before
public void setUp() throws Exception {
.child(Node.class, new NodeKey(nd.getNodeId()));
protocolEntry = InstanceIdentifier.create(NetworkTopology.class).child(Topology.class).child(Node.class)
.augmentation(OvsdbBridgeAugmentation.class).child(ProtocolEntry.class);
-
- briOperationState = mock(BridgeOperationalState.class, Mockito.CALLS_REAL_METHODS);
-
- getField(BridgeOperationalState.class,"db").set(briOperationState, db);
doReturn(mockReadTx).when(db).newReadOnlyTransaction();
OvsdbOperGlobalListener.OPER_NODE_CACHE.put(nodeIid, brNode);
+
+ briOperationState = spy(new BridgeOperationalState(db));
}
@Test
Code Review / ovsdb.git / commitdiff