package org.opendaylight.ovsdb.southbound.ovsdb.transact;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+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.ArrayList;
-import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
+import java.util.Optional;
import org.junit.Before;
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;
+import org.opendaylight.ovsdb.southbound.OvsdbOperGlobalListener;
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.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
-
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.api.support.membermodification.MemberModifier;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-
-import com.google.common.base.Optional;
-import org.powermock.api.support.membermodification.MemberMatcher;
-@PrepareForTest({BridgeOperationalState.class, Optional.class, InstanceIdentifier.class, Node.class, OvsdbBridgeAugmentation.class})
-@RunWith(PowerMockRunner.class)
+@RunWith(MockitoJUnitRunner.class)
public class BridgeOperationalStateTest {
+ private final Node nd = new NodeBuilder().setNodeId(new NodeId("foo")).build();
+ private final InstanceIdentifier<?> iid = InstanceIdentifier.create(Topology.class);
+
+ private final InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class).child(Node.class);
+ private final Node brNode = new NodeBuilder().build();
@Mock private BridgeOperationalState briOperationState;
- @Mock private InstanceIdentifier<ProtocolEntry> protocolEntry;
- @Mock private InstanceIdentifier<?> iid;
- @Mock private InstanceIdentifier<Node> iidNode;
- @Mock private Node nd;
+ @Mock private DataBroker db;
+ @Mock ReadTransaction mockReadTx;
+ private InstanceIdentifier<ProtocolEntry> protocolEntry;
+ private InstanceIdentifier<Node> iidNode;
private Map<InstanceIdentifier<Node>, Node> operationalNodes;
@Before
public void setUp() throws Exception {
+ iidNode = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("foo")))
+ .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);
- iid = mock(InstanceIdentifier.class, Mockito.RETURNS_MOCKS);
- protocolEntry = mock(InstanceIdentifier.class, Mockito.RETURNS_MOCKS);
- iidNode = mock(InstanceIdentifier.class, Mockito.RETURNS_MOCKS);
- nd = mock(Node.class, Mockito.RETURNS_MOCKS);
-
- operationalNodes = new HashMap<>();
- operationalNodes.put(iidNode, nd);
- MemberModifier.field(BridgeOperationalState.class,"operationalNodes").set(briOperationState, operationalNodes);
- PowerMockito.suppress(MemberMatcher.methodsDeclaredIn(InstanceIdentifier.class));
+
+ getField(BridgeOperationalState.class,"db").set(briOperationState, db);
+ doReturn(mockReadTx).when(db).newReadOnlyTransaction();
+ OvsdbOperGlobalListener.OPER_NODE_CACHE.put(nodeIid, brNode);
}
@Test
- public void testGetBridgeNode() throws Exception {
- Optional<Node> optNodes = briOperationState.getBridgeNode(iid);
- verify(iid, times(1)).firstIdentifierOf(Node.class);
- assertNotNull(optNodes);
- assertTrue(optNodes.equals(Optional.absent()));
+ public void testGetBridgeNode() {
+ Optional<Node> optNodes = briOperationState.getBridgeNode(nodeIid);
+ assertEquals(brNode, optNodes.get());
}
@Test
public void testGetOvsdbBridgeAugmentation() throws Exception {
- Optional<OvsdbBridgeAugmentation> optOvsdbBri = briOperationState.getOvsdbBridgeAugmentation(iid);
+ Optional<OvsdbBridgeAugmentation> optOvsdbBri = briOperationState.getOvsdbBridgeAugmentation(nodeIid);
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertNotNull(optOvsdbBri);
- assertTrue(optOvsdbBri.equals(Optional.absent()));
+ assertTrue(optOvsdbBri.equals(Optional.empty()));
Node node = mock(Node.class);
- Optional<Node> optNode = mock(Optional.class);
+ Optional<Node> optNode = Optional.of(node);
+ doReturn(optNode).when(briOperationState).getBridgeNode(any(InstanceIdentifier.class));
OvsdbBridgeAugmentation ovsdbBriAug = mock(OvsdbBridgeAugmentation.class);
- PowerMockito.suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeNode", InstanceIdentifier.class));
- when(briOperationState.getBridgeNode(any(InstanceIdentifier.class))).thenReturn(optNode);
- when(optNode.isPresent()).thenReturn(true);
- when(optNode.get()).thenReturn(node);
- when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(ovsdbBriAug);
+ doReturn(ovsdbBriAug).when(node).augmentation(OvsdbBridgeAugmentation.class);
Optional<OvsdbBridgeAugmentation> ovsdbBriAugOptional = briOperationState.getOvsdbBridgeAugmentation(iid);
assertNotNull(ovsdbBriAugOptional);
assertTrue(ovsdbBriAugOptional.get() instanceof OvsdbBridgeAugmentation);
@Test
public void testGetBridgeTerminationPoint() throws Exception {
- Optional<TerminationPoint> optTerm = briOperationState.getBridgeTerminationPoint(iid);
+ Optional<TerminationPoint> optTerm = briOperationState.getBridgeTerminationPoint(nodeIid);
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertNotNull(optTerm);
- assertTrue(optTerm.equals(Optional.absent()));
+ assertTrue(optTerm.equals(Optional.empty()));
- Node node = mock(Node.class);
- Optional<Node> optNode = mock(Optional.class);
TerminationPoint termPnt = mock(TerminationPoint.class);
List<TerminationPoint> termPntList = new ArrayList<>();
termPntList.add(termPnt);
- TerminationPointKey termPntKey = mock(TerminationPointKey.class);
- PowerMockito.suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeNode", InstanceIdentifier.class));
- when(briOperationState.getBridgeNode(any(InstanceIdentifier.class))).thenReturn(optNode);
- when(optNode.isPresent()).thenReturn(true);
- when(optNode.get()).thenReturn(node);
+ Node node = mock(Node.class);
+ Optional<Node> optNode = Optional.of(node);
+ doReturn(optNode).when(briOperationState).getBridgeNode(any(InstanceIdentifier.class));
when(node.getTerminationPoint()).thenReturn(termPntList);
- when(termPnt.getKey()).thenReturn(termPntKey);
-
- final InstanceIdentifier<?> iid2 = PowerMockito.mock(InstanceIdentifier.class);
- //PowerMockito.suppress(MemberMatcher.method(InstanceIdentifier.class, "firstKeyOf", Class.class, Class.class));
- //PowerMockito.when(iid2.firstKeyOf(TerminationPoint.class, TerminationPointKey.class)).thenReturn(termPntKey);
- Optional<TerminationPoint> optTermPnt = briOperationState.getBridgeTerminationPoint(iid2);
- assertNotNull(optTermPnt);
- //assertTrue(optTermPnt.get() instanceof TerminationPoint);
+ TerminationPointKey termPntKey = mock(TerminationPointKey.class);
+ when(termPnt.key()).thenReturn(termPntKey);
+
+ Optional<TerminationPoint> optTermPnt = briOperationState.getBridgeTerminationPoint(
+ iidNode.child(TerminationPoint.class, termPntKey));
+ assertTrue(optTermPnt.isPresent());
}
@Test
public void testGetOvsdbTerminationPointAugmentation() {
- Optional<OvsdbTerminationPointAugmentation> optOvsdbTermPoint = briOperationState.getOvsdbTerminationPointAugmentation(iid);
+ Optional<OvsdbTerminationPointAugmentation> optOvsdbTermPoint = briOperationState
+ .getOvsdbTerminationPointAugmentation(nodeIid);
assertNotNull(optOvsdbTermPoint);
verify(briOperationState, times(1)).getBridgeTerminationPoint(any(InstanceIdentifier.class));
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
- assertTrue(optOvsdbTermPoint.equals(Optional.absent()));
+ assertTrue(optOvsdbTermPoint.equals(Optional.empty()));
TerminationPoint termPoint = mock(TerminationPoint.class);
- Optional<TerminationPoint> termPntOptional = mock(Optional.class);
+ Optional<TerminationPoint> termPntOptional = Optional.of(termPoint);
+ doReturn(termPntOptional).when(briOperationState).getBridgeTerminationPoint(any(InstanceIdentifier.class));
OvsdbTerminationPointAugmentation ovsdbTermPntAug = mock(OvsdbTerminationPointAugmentation.class);
- PowerMockito.suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeTerminationPoint", InstanceIdentifier.class));
- when(briOperationState.getBridgeTerminationPoint(any(InstanceIdentifier.class))).thenReturn(termPntOptional);
- when(termPntOptional.isPresent()).thenReturn(true);
- when(termPntOptional.get()).thenReturn(termPoint);
- when(termPoint.getAugmentation(OvsdbTerminationPointAugmentation.class)).thenReturn(ovsdbTermPntAug);
- Optional<OvsdbTerminationPointAugmentation> ovsdbTermPointOpt = briOperationState.getOvsdbTerminationPointAugmentation(iid);
+ doReturn(ovsdbTermPntAug).when(termPoint).augmentation(OvsdbTerminationPointAugmentation.class);
+ Optional<OvsdbTerminationPointAugmentation> ovsdbTermPointOpt = briOperationState
+ .getOvsdbTerminationPointAugmentation(iid);
assertNotNull(ovsdbTermPointOpt);
assertTrue(ovsdbTermPointOpt.get() instanceof OvsdbTerminationPointAugmentation);
}
@Test
public void testGetControllerEntry() {
- Optional<ControllerEntry> optController= briOperationState.getControllerEntry(iid);
+ Optional<ControllerEntry> optController = briOperationState.getControllerEntry(nodeIid);
verify(briOperationState, times(1)).getOvsdbBridgeAugmentation(any(InstanceIdentifier.class));
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertNotNull(optController);
- assertTrue(optController.equals(Optional.absent()));
+ assertTrue(optController.equals(Optional.empty()));
}
@Test
verify(briOperationState, times(1)).getOvsdbBridgeAugmentation(any(InstanceIdentifier.class));
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertNotNull(optProtocolEntry);
- assertTrue(optProtocolEntry.equals(Optional.absent()));
+ assertTrue(optProtocolEntry.equals(Optional.empty()));
}
}
Code Review / ovsdb.git / blobdiff