import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Test;
+import org.mockito.Mockito;
import org.opendaylight.controller.md.sal.binding.api.MountPoint;
import org.opendaylight.controller.md.sal.binding.api.MountPointService;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.mapping.PortMappingImpl;
+import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServicePathDirection;
import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
-import org.opendaylight.transportpce.renderer.stub.MountPointStub;
import org.opendaylight.transportpce.renderer.utils.MountPointUtils;
-import org.opendaylight.transportpce.renderer.utils.ServiceDataUtils;
+import org.opendaylight.transportpce.renderer.utils.ServiceImplementationDataUtils;
import org.opendaylight.transportpce.test.AbstractTest;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.node.interfaces.NodeInterface;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.node.interfaces.NodeInterfaceBuilder;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.node.interfaces.NodeInterfaceKey;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.olm.renderer.input.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.RendererRollbackInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.RendererRollbackInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.RendererRollbackOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.ServicePathInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.ServicePathOutput;
-public class DeviceRendererServiceImplTest extends AbstractTest {
-
- private MountPointService mountPointService;
+public class DeviceRendererServiceImplSetupTest extends AbstractTest {
private DeviceTransactionManager deviceTransactionManager;
private DeviceRendererService deviceRendererService;
+ private CrossConnect crossConnect;
+ private PortMapping portMapping;
+ private OpenRoadmInterfaces openRoadmInterfaces;
+
private void setMountPoint(MountPoint mountPoint) {
- this.mountPointService = new MountPointServiceStub(mountPoint);
- this.deviceTransactionManager = new DeviceTransactionManagerImpl(this.mountPointService, 3000);
- OpenRoadmInterfaces openRoadmInterfaces = new OpenRoadmInterfacesImpl(this.deviceTransactionManager);
- PortMapping portMapping = new PortMappingImpl(this.getDataBroker(), this.deviceTransactionManager,
- openRoadmInterfaces);
- OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(portMapping,
- openRoadmInterfaces);
- CrossConnect crossConnect = new CrossConnectImpl(this.deviceTransactionManager);
+ MountPointService mountPointService = new MountPointServiceStub(mountPoint);
+ this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000);
+ this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(this.deviceTransactionManager);
+ this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces);
+ this.portMapping = new PortMappingImpl(this.getDataBroker(), this.deviceTransactionManager,
+ this.openRoadmInterfaces);
+ this.portMapping = Mockito.spy(this.portMapping);
+ OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.portMapping,
+ this.openRoadmInterfaces);
+ this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager);
+ this.crossConnect = Mockito.spy(this.crossConnect);
this.deviceRendererService = new DeviceRendererServiceImpl(this.getDataBroker(),
this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect,
portMapping);
@Test
public void testSetupServiceWhenDeviceIsNotMounted() {
setMountPoint(null);
- ServicePathInput servicePathInput = ServiceDataUtils.buildServicePathInputs();
+ ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs();
for (ServicePathDirection servicePathDirection : ServicePathDirection.values()) {
ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput,
servicePathDirection);
}
@Test
- public void testSetupServiceUsingCrossConnectEmptyPorts() throws ExecutionException, InterruptedException {
+ public void testSetupServicemptyPorts() {
setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker()));
- testSetupService(true);
+ String nodeId = "node1";
+ String srcTP = OpenRoadmInterfacesImpl.TTP_TOKEN;
+ String dstTp = OpenRoadmInterfacesImpl.PP_TOKEN;
+ List<Nodes> nodes = new ArrayList<>();
+ nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp));
+ ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes);
+ for (ServicePathDirection servicePathDirection : ServicePathDirection.values()) {
+ ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput,
+ servicePathDirection);
+ Assert.assertFalse(servicePathOutput.isSuccess());
+ }
}
@Test
- public void testSetupServiceUsingCrossConnectWithPorts() throws ExecutionException, InterruptedException {
+ public void testSetupServiceCannotCrossConnect() {
setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker()));
- testSetupService(true);
+ String nodeId = "node1";
+ String srcTP = OpenRoadmInterfacesImpl.TTP_TOKEN;
+ String dstTp = OpenRoadmInterfacesImpl.PP_TOKEN;
+ MountPointUtils.writeMapping(nodeId, srcTP, this.deviceTransactionManager);
+ MountPointUtils.writeMapping(nodeId, dstTp, this.deviceTransactionManager);
+ List<Nodes> nodes = new ArrayList<>();
+ nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp));
+ ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes);
+ Mockito.doReturn(java.util.Optional.empty()).when(this.crossConnect).postCrossConnect(nodeId, 20L, srcTP,
+ dstTp);
+ ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput,
+ ServicePathDirection.A_TO_Z);
+ Assert.assertFalse(servicePathOutput.isSuccess());
}
-// @Test
-// public void testSetupServiceWithoutCrossConnect() throws ExecutionException, InterruptedException {
-// setMountPoint(new MountPointStub(getDataBroker()));
-//
-// testSetupService(false);
-// }
-
- private void testSetupService(boolean crossConnect) throws ExecutionException, InterruptedException {
+ @Test
+ public void testSetupService() throws OpenRoadmInterfaceException {
+ setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker()));
+ Mockito.doNothing().when(this.openRoadmInterfaces).postEquipmentState(Mockito.anyString(),
+ Mockito.anyString(), Mockito.anyBoolean());
String [] interfaceTokens = {
OpenRoadmInterfacesImpl.NETWORK_TOKEN,
OpenRoadmInterfacesImpl.CLIENT_TOKEN,
OpenRoadmInterfacesImpl.TTP_TOKEN,
- OpenRoadmInterfacesImpl.PP_TOKEN,
- ""
+ OpenRoadmInterfacesImpl.PP_TOKEN
};
String nodeId = "node1";
connectingUsingCrossConnect = false;
}
- if (connectingUsingCrossConnect != crossConnect) {
- continue;
- }
-
List<Nodes> nodes = new ArrayList<>();
- nodes.add(ServiceDataUtils.createNode(nodeId, srcTP, dstTp));
- ServicePathInput servicePathInput = ServiceDataUtils.buildServicePathInputs(nodes);
+ nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp));
+ ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes);
for (ServicePathDirection servicePathDirection : ServicePathDirection.values()) {
ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput,
servicePathDirection);
Assert.assertTrue(servicePathOutput.isSuccess());
String expectedResult = "Roadm-connection successfully created for nodes: ";
- if (crossConnect) {
+ if (connectingUsingCrossConnect) {
expectedResult = expectedResult + nodeId;
}
Assert.assertEquals(expectedResult, servicePathOutput.getResult());
Assert.assertEquals(1, servicePathOutput.getNodeInterface().size());
Assert.assertEquals(nodeId, servicePathOutput.getNodeInterface().get(0).getNodeId());
+ if (!connectingUsingCrossConnect) { // No need to try both directions if not cross connect
+ break;
+ }
}
}
}
}
@Test
- public void testRollbackEmptyInterface() {
- setMountPoint(new MountPointStub(getDataBroker()));
- RendererRollbackInput rendererRollbackInput = ServiceDataUtils.buildRendererRollbackInput();
- RendererRollbackOutput rendererRollbackOutput =
- this.deviceRendererService.rendererRollback(rendererRollbackInput);
- Assert.assertTrue(rendererRollbackOutput.isSuccess());
- Assert.assertTrue(rendererRollbackOutput.getFailedToRollback().isEmpty());
- }
+ public void testSetupServiceNulls() throws OpenRoadmInterfaceException {
+ setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker()));
+ String nodeId = "node1";
+ String srcTP = null;
+ String dstTp = null;
+ boolean connectingUsingCrossConnect = true;
- @Test
- public void testRollbackConnectionIdNotExist() {
- setMountPoint(new MountPointStub(getDataBroker()));
-
- NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder();
- nodeInterfaceBuilder.setNodeId("node1");
- nodeInterfaceBuilder.withKey(new NodeInterfaceKey("node1"));
- List<String> connectionID = new ArrayList<>();
- connectionID.add("node1-PP");
- nodeInterfaceBuilder.setConnectionId(connectionID);
- List<NodeInterface> nodeInterfaces = new ArrayList<>();
- nodeInterfaces.add(nodeInterfaceBuilder.build());
- RendererRollbackInputBuilder rendererRollbackInputBuilder = new RendererRollbackInputBuilder();
- rendererRollbackInputBuilder.setNodeInterface(nodeInterfaces);
-
- RendererRollbackOutput rendererRollbackOutput =
- this.deviceRendererService.rendererRollback(rendererRollbackInputBuilder.build());
- Assert.assertFalse(rendererRollbackOutput.isSuccess());
- Assert.assertEquals(1, rendererRollbackOutput.getFailedToRollback().size());
- Assert.assertEquals("node1", rendererRollbackOutput.getFailedToRollback().get(0).getNodeId());
+ List<Nodes> nodes = new ArrayList<>();
+ nodes.add(ServiceImplementationDataUtils.createNode(nodeId, srcTP, dstTp));
+ ServicePathInput servicePathInput = ServiceImplementationDataUtils.buildServicePathInputs(nodes);
+
+ for (ServicePathDirection servicePathDirection : ServicePathDirection.values()) {
+ ServicePathOutput servicePathOutput = deviceRendererService.setupServicePath(servicePathInput,
+ servicePathDirection);
+ Assert.assertTrue(servicePathOutput.isSuccess());
+ String expectedResult = "Roadm-connection successfully created for nodes: ";
+ expectedResult = expectedResult + nodeId;
+ Assert.assertEquals(expectedResult, servicePathOutput.getResult());
+ Assert.assertEquals(1, servicePathOutput.getNodeInterface().size());
+ Assert.assertEquals(nodeId, servicePathOutput.getNodeInterface().get(0).getNodeId());
+ }
}
}
Code Review / transportpce.git / blobdiff