/*
* Copyright 2016-present Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.rest.resources;
import com.eclipsesource.json.Json;
import com.eclipsesource.json.JsonArray;
import com.eclipsesource.json.JsonObject;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import org.glassfish.jersey.client.ClientProperties;
import org.hamcrest.Description;
import org.hamcrest.Matchers;
import org.hamcrest.TypeSafeMatcher;
import org.junit.Before;
import org.junit.Test;
import org.onlab.osgi.ServiceDirectory;
import org.onlab.osgi.TestServiceDirectory;
import org.onlab.packet.IpAddress;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onlab.rest.BaseResource;
import org.onosproject.codec.CodecService;
import org.onosproject.codec.impl.CodecManager;
import org.onosproject.incubator.net.virtual.DefaultVirtualDevice;
import org.onosproject.incubator.net.virtual.DefaultVirtualHost;
import org.onosproject.incubator.net.virtual.DefaultVirtualLink;
import org.onosproject.incubator.net.virtual.DefaultVirtualNetwork;
import org.onosproject.incubator.net.virtual.DefaultVirtualPort;
import org.onosproject.incubator.net.virtual.NetworkId;
import org.onosproject.incubator.net.virtual.TenantId;
import org.onosproject.incubator.net.virtual.VirtualDevice;
import org.onosproject.incubator.net.virtual.VirtualHost;
import org.onosproject.incubator.net.virtual.VirtualLink;
import org.onosproject.incubator.net.virtual.VirtualNetwork;
import org.onosproject.incubator.net.virtual.VirtualNetworkAdminService;
import org.onosproject.incubator.net.virtual.VirtualNetworkService;
import org.onosproject.incubator.net.virtual.VirtualPort;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DefaultAnnotations;
import org.onosproject.net.DefaultDevice;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.onosproject.net.HostId;
import org.onosproject.net.HostLocation;
import org.onosproject.net.NetTestTools;
import org.onosproject.net.PortNumber;
import javax.ws.rs.BadRequestException;
import javax.ws.rs.NotFoundException;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Function;
import static org.easymock.EasyMock.*;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.onosproject.net.PortNumber.portNumber;
/**
* Unit tests for virtual network REST APIs.
*/
public class VirtualNetworkWebResourceTest extends ResourceTest {
private final VirtualNetworkAdminService mockVnetAdminService = createMock(VirtualNetworkAdminService.class);
private final VirtualNetworkService mockVnetService = createMock(VirtualNetworkService.class);
private CodecManager codecService;
private final HashSet<VirtualDevice> vdevSet = new HashSet<>();
private final HashSet<VirtualPort> vportSet = new HashSet<>();
private static final String ID = "networkId";
private static final String TENANT_ID = "tenantId";
private static final String DEVICE_ID = "deviceId";
private static final String PORT_NUM = "portNum";
private static final String PHYS_DEVICE_ID = "physDeviceId";
private static final String PHYS_PORT_NUM = "physPortNum";
private final TenantId tenantId2 = TenantId.tenantId("TenantId2");
private final TenantId tenantId3 = TenantId.tenantId("TenantId3");
private final TenantId tenantId4 = TenantId.tenantId("TenantId4");
private final NetworkId networkId1 = NetworkId.networkId(1);
private final NetworkId networkId2 = NetworkId.networkId(2);
private final NetworkId networkId3 = NetworkId.networkId(3);
private final NetworkId networkId4 = NetworkId.networkId(4);
private final VirtualNetwork vnet1 = new DefaultVirtualNetwork(networkId1, tenantId3);
private final VirtualNetwork vnet2 = new DefaultVirtualNetwork(networkId2, tenantId3);
private final VirtualNetwork vnet3 = new DefaultVirtualNetwork(networkId3, tenantId3);
private final VirtualNetwork vnet4 = new DefaultVirtualNetwork(networkId4, tenantId3);
private final DeviceId devId1 = DeviceId.deviceId("devid1");
private final DeviceId devId2 = DeviceId.deviceId("devid2");
private final DeviceId devId22 = DeviceId.deviceId("dev22");
private final VirtualDevice vdev1 = new DefaultVirtualDevice(networkId3, devId1);
private final VirtualDevice vdev2 = new DefaultVirtualDevice(networkId3, devId2);
private final Device dev1 = NetTestTools.device("dev1");
private final Device dev2 = NetTestTools.device("dev2");
private final Device dev22 = NetTestTools.device("dev22");
private final ConnectPoint cp1 = new ConnectPoint(dev1.id(), portNumber(1));
private final ConnectPoint cp2 = new ConnectPoint(dev2.id(), portNumber(2));
private final VirtualPort vport22 = new DefaultVirtualPort(networkId3,
dev22, portNumber(22), cp1);
private final VirtualPort vport23 = new DefaultVirtualPort(networkId3,
dev22, portNumber(23), cp2);
private final ConnectPoint cp11 = NetTestTools.connectPoint(devId1.toString(), 21);
private final ConnectPoint cp21 = NetTestTools.connectPoint(devId2.toString(), 22);
private final ConnectPoint cp12 = NetTestTools.connectPoint(devId1.toString(), 2);
private final ConnectPoint cp22 = NetTestTools.connectPoint(devId2.toString(), 22);
private final VirtualLink vlink1 = DefaultVirtualLink.builder()
.networkId(networkId3)
.src(cp22)
.dst(cp11)
.build();
private final VirtualLink vlink2 = DefaultVirtualLink.builder()
.networkId(networkId3)
.src(cp12)
.dst(cp21)
.build();
private final MacAddress mac1 = MacAddress.valueOf("00:11:00:00:00:01");
private final MacAddress mac2 = MacAddress.valueOf("00:22:00:00:00:02");
private final VlanId vlan1 = VlanId.vlanId((short) 11);
private final VlanId vlan2 = VlanId.vlanId((short) 22);
private final IpAddress ip1 = IpAddress.valueOf("10.0.0.1");
private final IpAddress ip2 = IpAddress.valueOf("10.0.0.2");
private final IpAddress ip3 = IpAddress.valueOf("10.0.0.3");
private final HostId hId1 = HostId.hostId(mac1, vlan1);
private final HostId hId2 = HostId.hostId(mac2, vlan2);
private final HostLocation loc1 = new HostLocation(devId1, portNumber(100), 123L);
private final HostLocation loc2 = new HostLocation(devId2, portNumber(200), 123L);
private final Set<IpAddress> ipSet1 = Sets.newHashSet(ip1, ip2);
private final Set<IpAddress> ipSet2 = Sets.newHashSet(ip1, ip3);
private final VirtualHost vhost1 = new DefaultVirtualHost(networkId1, hId1,
mac1, vlan1, loc1, ipSet1);
private final VirtualHost vhost2 = new DefaultVirtualHost(networkId2, hId2,
mac2, vlan2, loc2, ipSet2);
/**
* Sets up the global values for all the tests.
*/
@Before
public void setUpTest() {
// Register the services needed for the test
codecService = new CodecManager();
codecService.activate();
ServiceDirectory testDirectory =
new TestServiceDirectory()
.add(VirtualNetworkAdminService.class, mockVnetAdminService)
.add(VirtualNetworkService.class, mockVnetService)
.add(CodecService.class, codecService);
BaseResource.setServiceDirectory(testDirectory);
}
/**
* Hamcrest matcher to check that a virtual network entity representation in JSON matches
* the actual virtual network entity.
*/
private static final class JsonObjectMatcher<T> extends TypeSafeMatcher<JsonObject> {
private final T vnetEntity;
private List<String> jsonFieldNames;
private String reason = "";
private BiFunction<T, String, String> getValue; // get vnetEntity's value
private JsonObjectMatcher(T vnetEntityValue,
List<String> jsonFieldNames1,
BiFunction<T, String, String> getValue1) {
vnetEntity = vnetEntityValue;
jsonFieldNames = jsonFieldNames1;
getValue = getValue1;
}
@Override
public boolean matchesSafely(JsonObject jsonHost) {
return jsonFieldNames
.stream()
.allMatch(s -> checkField(jsonHost, s, getValue.apply(vnetEntity, s)));
}
private boolean checkField(JsonObject jsonHost, String jsonFieldName,
String objectValue) {
final String jsonValue = jsonHost.get(jsonFieldName).asString();
if (!jsonValue.equals(objectValue)) {
reason = jsonFieldName + " " + objectValue;
return false;
}
return true;
}
@Override
public void describeTo(Description description) {
description.appendText(reason);
}
}
/**
* Factory to allocate a virtual network id array matcher.
*
* @param obj virtual network id object we are looking for
* @return matcher
*/
/**
* Factory to allocate a virtual network entity matcher.
*
* @param obj virtual network object we are looking for
* @param jsonFieldNames JSON field names to check against
* @param getValue function to retrieve value from virtual network object
* @param <T> the type of virtual network object
* @return matcher
*/
private static <T> JsonObjectMatcher matchesVnetEntity(T obj, List<String> jsonFieldNames,
BiFunction<T, String, String> getValue) {
return new JsonObjectMatcher<T>(obj, jsonFieldNames, getValue);
}
/**
* Hamcrest matcher to check that a virtual network entity is represented properly in a JSON
* array of virtual network entities.
*/
protected static class JsonArrayMatcher<T> extends TypeSafeMatcher<JsonArray> {
private final T vnetEntity;
private String reason = "";
private Function<T, String> getKey; // gets vnetEntity's key
private BiPredicate<T, JsonObject> checkKey; // check vnetEntity's key with JSON rep'n
private List<String> jsonFieldNames; // field/property names
private BiFunction<T, String, String> getValue; // get vnetEntity's value
protected JsonArrayMatcher(T vnetEntityValue, Function<T, String> getKey1,
BiPredicate<T, JsonObject> checkKey1,
List<String> jsonFieldNames1,
BiFunction<T, String, String> getValue1) {
vnetEntity = vnetEntityValue;
getKey = getKey1;
checkKey = checkKey1;
jsonFieldNames = jsonFieldNames1;
getValue = getValue1;
}
@Override
public boolean matchesSafely(JsonArray json) {
boolean itemFound = false;
final int expectedAttributes = jsonFieldNames.size();
for (int jsonArrayIndex = 0; jsonArrayIndex < json.size();
jsonArrayIndex++) {
final JsonObject jsonHost = json.get(jsonArrayIndex).asObject();
if (jsonHost.names().size() < expectedAttributes) {
reason = "Found a virtual network with the wrong number of attributes";
return false;
}
if (checkKey != null && checkKey.test(vnetEntity, jsonHost)) {
itemFound = true;
assertThat(jsonHost, matchesVnetEntity(vnetEntity, jsonFieldNames, getValue));
}
}
if (!itemFound) {
reason = getKey.apply(vnetEntity) + " was not found";
return false;
}
return true;
}
@Override
public void describeTo(Description description) {
description.appendText(reason);
}
}
/**
* Array matcher for VirtualNetwork.
*/
private static final class VnetJsonArrayMatcher extends JsonArrayMatcher<VirtualNetwork> {
private VnetJsonArrayMatcher(VirtualNetwork vnetIn) {
super(vnetIn,
vnet -> "Virtual network " + vnet.id().toString(),
(vnet, jsonObject) -> jsonObject.get(ID).asString().equals(vnet.id().toString()),
ImmutableList.of(ID, TENANT_ID),
(vnet, s) -> s.equals(ID) ? vnet.id().toString()
: s.equals(TENANT_ID) ? vnet.tenantId().toString()
: null
);
}
}
/**
* Factory to allocate a virtual network array matcher.
*
* @param vnet virtual network object we are looking for
* @return matcher
*/
private VnetJsonArrayMatcher hasVnet(VirtualNetwork vnet) {
return new VnetJsonArrayMatcher(vnet);
}
// Tests for Virtual Networks
/**
* Tests the result of the REST API GET when there are no virtual networks.
*/
@Test
public void testGetVirtualNetworksEmptyArray() {
expect(mockVnetAdminService.getTenantIds()).andReturn(ImmutableSet.of()).anyTimes();
replay(mockVnetAdminService);
expect(mockVnetService.getVirtualNetworks(tenantId4)).andReturn(ImmutableSet.of()).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String response = wt.path("vnets").request().get(String.class);
assertThat(response, is("{\"vnets\":[]}"));
verify(mockVnetService);
verify(mockVnetAdminService);
}
/**
* Tests the result of the REST API GET when virtual networks are defined.
*/
@Test
public void testGetVirtualNetworksArray() {
final Set<VirtualNetwork> vnetSet = ImmutableSet.of(vnet1, vnet2, vnet3, vnet4);
expect(mockVnetAdminService.getTenantIds()).andReturn(ImmutableSet.of(tenantId3)).anyTimes();
replay(mockVnetAdminService);
expect(mockVnetService.getVirtualNetworks(tenantId3)).andReturn(vnetSet).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String response = wt.path("vnets").request().get(String.class);
assertThat(response, containsString("{\"vnets\":["));
final JsonObject result = Json.parse(response).asObject();
assertThat(result, notNullValue());
assertThat(result.names(), hasSize(1));
assertThat(result.names().get(0), is("vnets"));
final JsonArray vnetJsonArray = result.get("vnets").asArray();
assertThat(vnetJsonArray, notNullValue());
assertEquals("Virtual networks array is not the correct size.",
vnetSet.size(), vnetJsonArray.size());
vnetSet.forEach(vnet -> assertThat(vnetJsonArray, hasVnet(vnet)));
verify(mockVnetService);
verify(mockVnetAdminService);
}
/**
* Tests the result of the REST API GET for virtual networks with tenant id.
*/
@Test
public void testGetVirtualNetworksByTenantId() {
final Set<VirtualNetwork> vnetSet = ImmutableSet.of(vnet1, vnet2, vnet3, vnet4);
expect(mockVnetAdminService.getTenantIds()).andReturn(ImmutableSet.of(tenantId3)).anyTimes();
replay(mockVnetAdminService);
expect(mockVnetService.getVirtualNetworks(tenantId3)).andReturn(vnetSet).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String response = wt.path("vnets/" + tenantId3.id()).request().get(String.class);
assertThat(response, containsString("{\"vnets\":["));
final JsonObject result = Json.parse(response).asObject();
assertThat(result, notNullValue());
assertThat(result.names(), hasSize(1));
assertThat(result.names().get(0), is("vnets"));
final JsonArray vnetJsonArray = result.get("vnets").asArray();
assertThat(vnetJsonArray, notNullValue());
assertEquals("Virtual networks array is not the correct size.",
vnetSet.size(), vnetJsonArray.size());
vnetSet.forEach(vnet -> assertThat(vnetJsonArray, hasVnet(vnet)));
verify(mockVnetService);
verify(mockVnetAdminService);
}
/**
* Tests the result of the REST API GET for virtual networks with tenant id.
*/
@Test
public void testGetVirtualNetworksByNonExistentTenantId() {
String tenantIdName = "NON_EXISTENT_TENANT_ID";
expect(mockVnetAdminService.getTenantIds()).andReturn(ImmutableSet.of(tenantId3)).anyTimes();
replay(mockVnetAdminService);
expect(mockVnetService.getVirtualNetworks(anyObject())).andReturn(ImmutableSet.of()).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
try {
wt.path("vnets/" + tenantIdName)
.request()
.get(String.class);
fail("Get of a non-existent virtual network did not throw an exception");
} catch (NotFoundException ex) {
assertThat(ex.getMessage(), containsString("HTTP 404 Not Found"));
}
verify(mockVnetService);
verify(mockVnetAdminService);
}
/**
* Tests adding of new virtual network using POST via JSON stream.
*/
@Test
public void testPostVirtualNetwork() {
expect(mockVnetAdminService.createVirtualNetwork(tenantId2)).andReturn(vnet1);
expectLastCall();
replay(mockVnetAdminService);
WebTarget wt = target();
InputStream jsonStream = TenantWebResourceTest.class
.getResourceAsStream("post-tenant.json");
Response response = wt.path("vnets").request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(jsonStream));
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_CREATED));
String location = response.getLocation().getPath();
assertThat(location, Matchers.startsWith("/vnets/" + vnet1.id().toString()));
verify(mockVnetAdminService);
}
/**
* Tests adding of a null virtual network using POST via JSON stream.
*/
@Test
public void testPostVirtualNetworkNullTenantId() {
replay(mockVnetAdminService);
WebTarget wt = target();
try {
wt.path("vnets")
.request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(null), String.class);
fail("POST of null virtual network did not throw an exception");
} catch (BadRequestException ex) {
assertThat(ex.getMessage(), containsString("HTTP 400 Bad Request"));
}
verify(mockVnetAdminService);
}
/**
* Tests removing a virtual network with DELETE request.
*/
@Test
public void testDeleteVirtualNetwork() {
mockVnetAdminService.removeVirtualNetwork(anyObject());
expectLastCall();
replay(mockVnetAdminService);
WebTarget wt = target()
.property(ClientProperties.SUPPRESS_HTTP_COMPLIANCE_VALIDATION, true);
Response response = wt.path("vnets/" + "2")
.request(MediaType.APPLICATION_JSON_TYPE)
.delete();
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_NO_CONTENT));
verify(mockVnetAdminService);
}
/**
* Tests that a DELETE of a non-existent virtual network throws an exception.
*/
@Test
public void testDeleteNetworkNonExistentNetworkId() {
expect(mockVnetAdminService.getTenantIds())
.andReturn(ImmutableSet.of())
.anyTimes();
expectLastCall();
replay(mockVnetAdminService);
WebTarget wt = target();
try {
wt.path("vnets/" + "NON_EXISTENT_NETWORK_ID")
.request()
.delete(String.class);
fail("Delete of a non-existent virtual network did not throw an exception");
} catch (NotFoundException ex) {
assertThat(ex.getMessage(), containsString("HTTP 404 Not Found"));
}
verify(mockVnetAdminService);
}
// Tests for Virtual Device
/**
* Tests the result of the REST API GET when there are no virtual devices.
*/
@Test
public void testGetVirtualDevicesEmptyArray() {
NetworkId networkId = networkId4;
expect(mockVnetService.getVirtualDevices(networkId)).andReturn(ImmutableSet.of()).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String location = "vnets/" + networkId.toString() + "/devices";
String response = wt.path(location).request().get(String.class);
assertThat(response, is("{\"devices\":[]}"));
verify(mockVnetService);
}
/**
* Tests the result of the REST API GET when virtual devices are defined.
*/
@Test
public void testGetVirtualDevicesArray() {
NetworkId networkId = networkId3;
vdevSet.add(vdev1);
vdevSet.add(vdev2);
expect(mockVnetService.getVirtualDevices(networkId)).andReturn(vdevSet).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String location = "vnets/" + networkId.toString() + "/devices";
String response = wt.path(location).request().get(String.class);
assertThat(response, containsString("{\"devices\":["));
final JsonObject result = Json.parse(response).asObject();
assertThat(result, notNullValue());
assertThat(result.names(), hasSize(1));
assertThat(result.names().get(0), is("devices"));
final JsonArray vnetJsonArray = result.get("devices").asArray();
assertThat(vnetJsonArray, notNullValue());
assertEquals("Virtual devices array is not the correct size.",
vdevSet.size(), vnetJsonArray.size());
vdevSet.forEach(vdev -> assertThat(vnetJsonArray, hasVdev(vdev)));
verify(mockVnetService);
}
/**
* Array matcher for VirtualDevice.
*/
private static final class VdevJsonArrayMatcher extends JsonArrayMatcher<VirtualDevice> {
private VdevJsonArrayMatcher(VirtualDevice vdevIn) {
super(vdevIn,
vdev -> "Virtual device " + vdev.networkId().toString()
+ " " + vdev.id().toString(),
(vdev, jsonObject) -> jsonObject.get(ID).asString().equals(vdev.networkId().toString())
&& jsonObject.get(DEVICE_ID).asString().equals(vdev.id().toString()),
ImmutableList.of(ID, DEVICE_ID),
(vdev, s) -> s.equals(ID) ? vdev.networkId().toString()
: s.equals(DEVICE_ID) ? vdev.id().toString()
: null
);
}
}
/**
* Factory to allocate a virtual device array matcher.
*
* @param vdev virtual device object we are looking for
* @return matcher
*/
private VdevJsonArrayMatcher hasVdev(VirtualDevice vdev) {
return new VdevJsonArrayMatcher(vdev);
}
/**
* Tests adding of new virtual device using POST via JSON stream.
*/
@Test
public void testPostVirtualDevice() {
NetworkId networkId = networkId3;
DeviceId deviceId = devId2;
expect(mockVnetAdminService.createVirtualDevice(networkId, deviceId)).andReturn(vdev2);
expectLastCall();
replay(mockVnetAdminService);
WebTarget wt = target();
InputStream jsonStream = VirtualNetworkWebResourceTest.class
.getResourceAsStream("post-virtual-device.json");
String reqLocation = "vnets/" + networkId.toString() + "/devices";
Response response = wt.path(reqLocation).request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(jsonStream));
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_CREATED));
String location = response.getLocation().getPath();
assertThat(location, Matchers.startsWith("/" + reqLocation + "/" + vdev2.id().toString()));
verify(mockVnetAdminService);
}
/**
* Tests adding of a null virtual device using POST via JSON stream.
*/
@Test
public void testPostVirtualDeviceNullJsonStream() {
NetworkId networkId = networkId3;
replay(mockVnetAdminService);
WebTarget wt = target();
try {
String reqLocation = "vnets/" + networkId.toString() + "/devices";
wt.path(reqLocation)
.request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(null), String.class);
fail("POST of null virtual device did not throw an exception");
} catch (BadRequestException ex) {
assertThat(ex.getMessage(), containsString("HTTP 400 Bad Request"));
}
verify(mockVnetAdminService);
}
/**
* Tests removing a virtual device with DELETE request.
*/
@Test
public void testDeleteVirtualDevice() {
NetworkId networkId = networkId3;
DeviceId deviceId = devId2;
mockVnetAdminService.removeVirtualDevice(networkId, deviceId);
expectLastCall();
replay(mockVnetAdminService);
WebTarget wt = target()
.property(ClientProperties.SUPPRESS_HTTP_COMPLIANCE_VALIDATION, true);
String reqLocation = "vnets/" + networkId.toString() + "/devices/" + deviceId.toString();
Response response = wt.path(reqLocation)
.request(MediaType.APPLICATION_JSON_TYPE)
.delete();
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_NO_CONTENT));
verify(mockVnetAdminService);
}
// Tests for Virtual Ports
/**
* Tests the result of the REST API GET when there are no virtual ports.
*/
@Test
public void testGetVirtualPortsEmptyArray() {
NetworkId networkId = networkId4;
DeviceId deviceId = devId2;
expect(mockVnetService.getVirtualPorts(networkId, deviceId))
.andReturn(ImmutableSet.of()).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String location = "vnets/" + networkId.toString()
+ "/devices/" + deviceId.toString() + "/ports";
String response = wt.path(location).request().get(String.class);
assertThat(response, is("{\"ports\":[]}"));
verify(mockVnetService);
}
/**
* Tests the result of the REST API GET when virtual ports are defined.
*/
@Test
public void testGetVirtualPortsArray() {
NetworkId networkId = networkId3;
DeviceId deviceId = dev22.id();
vportSet.add(vport23);
vportSet.add(vport22);
expect(mockVnetService.getVirtualPorts(networkId, deviceId)).andReturn(vportSet).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String location = "vnets/" + networkId.toString()
+ "/devices/" + deviceId.toString() + "/ports";
String response = wt.path(location).request().get(String.class);
assertThat(response, containsString("{\"ports\":["));
final JsonObject result = Json.parse(response).asObject();
assertThat(result, notNullValue());
assertThat(result.names(), hasSize(1));
assertThat(result.names().get(0), is("ports"));
final JsonArray vnetJsonArray = result.get("ports").asArray();
assertThat(vnetJsonArray, notNullValue());
assertEquals("Virtual ports array is not the correct size.",
vportSet.size(), vnetJsonArray.size());
vportSet.forEach(vport -> assertThat(vnetJsonArray, hasVport(vport)));
verify(mockVnetService);
}
/**
* Array matcher for VirtualPort.
*/
private static final class VportJsonArrayMatcher extends JsonArrayMatcher<VirtualPort> {
private VportJsonArrayMatcher(VirtualPort vportIn) {
super(vportIn,
vport -> "Virtual port " + vport.networkId().toString() + " "
+ vport.element().id().toString() + " " + vport.number().toString(),
(vport, jsonObject) -> jsonObject.get(ID).asString().equals(vport.networkId().toString())
&& jsonObject.get(PORT_NUM).asString().equals(vport.number().toString())
&& jsonObject.get(DEVICE_ID).asString().equals(vport.element().id().toString()),
ImmutableList.of(ID, DEVICE_ID, PORT_NUM, PHYS_DEVICE_ID, PHYS_PORT_NUM),
(vport, s) -> s.equals(ID) ? vport.networkId().toString()
: s.equals(DEVICE_ID) ? vport.element().id().toString()
: s.equals(PORT_NUM) ? vport.number().toString()
: s.equals(PHYS_DEVICE_ID) ? vport.realizedBy().deviceId().toString()
: s.equals(PHYS_PORT_NUM) ? vport.realizedBy().port().toString()
: null
);
}
}
/**
* Factory to allocate a virtual port array matcher.
*
* @param vport virtual port object we are looking for
* @return matcher
*/
private VportJsonArrayMatcher hasVport(VirtualPort vport) {
return new VportJsonArrayMatcher(vport);
}
/**
* Tests adding of new virtual port using POST via JSON stream.
*/
@Test
public void testPostVirtualPort() {
NetworkId networkId = networkId3;
DeviceId deviceId = devId22;
DefaultAnnotations annotations = DefaultAnnotations.builder().build();
Device physDevice = new DefaultDevice(null, DeviceId.deviceId("dev1"),
null, null, null, null, null, null, annotations);
ConnectPoint cp1 = new ConnectPoint(physDevice.id(), portNumber(1));
expect(mockVnetAdminService.createVirtualPort(networkId, deviceId, portNumber(22), cp1))
.andReturn(vport22);
replay(mockVnetAdminService);
WebTarget wt = target();
InputStream jsonStream = VirtualNetworkWebResourceTest.class
.getResourceAsStream("post-virtual-port.json");
String reqLocation = "vnets/" + networkId.toString()
+ "/devices/" + deviceId.toString() + "/ports";
Response response = wt.path(reqLocation).request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(jsonStream));
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_CREATED));
verify(mockVnetAdminService);
}
/**
* Tests adding of a null virtual port using POST via JSON stream.
*/
@Test
public void testPostVirtualPortNullJsonStream() {
NetworkId networkId = networkId3;
DeviceId deviceId = devId2;
replay(mockVnetAdminService);
WebTarget wt = target();
try {
String reqLocation = "vnets/" + networkId.toString()
+ "/devices/" + deviceId.toString() + "/ports";
wt.path(reqLocation)
.request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(null), String.class);
fail("POST of null virtual port did not throw an exception");
} catch (BadRequestException ex) {
assertThat(ex.getMessage(), containsString("HTTP 400 Bad Request"));
}
verify(mockVnetAdminService);
}
/**
* Tests removing a virtual port with DELETE request.
*/
@Test
public void testDeleteVirtualPort() {
NetworkId networkId = networkId3;
DeviceId deviceId = devId2;
PortNumber portNum = portNumber(2);
mockVnetAdminService.removeVirtualPort(networkId, deviceId, portNum);
expectLastCall();
replay(mockVnetAdminService);
WebTarget wt = target()
.property(ClientProperties.SUPPRESS_HTTP_COMPLIANCE_VALIDATION, true);
String reqLocation = "vnets/" + networkId.toString()
+ "/devices/" + deviceId.toString() + "/ports/" + portNum.toLong();
Response response = wt.path(reqLocation)
.request(MediaType.APPLICATION_JSON_TYPE)
.delete();
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_NO_CONTENT));
verify(mockVnetAdminService);
}
// Tests for Virtual Links
/**
* Tests the result of the REST API GET when there are no virtual links.
*/
@Test
public void testGetVirtualLinksEmptyArray() {
NetworkId networkId = networkId4;
expect(mockVnetService.getVirtualLinks(networkId)).andReturn(ImmutableSet.of()).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String location = "vnets/" + networkId.toString() + "/links";
String response = wt.path(location).request().get(String.class);
assertThat(response, is("{\"links\":[]}"));
verify(mockVnetService);
}
/**
* Tests the result of the REST API GET when virtual links are defined.
*/
@Test
public void testGetVirtualLinksArray() {
NetworkId networkId = networkId3;
final Set<VirtualLink> vlinkSet = ImmutableSet.of(vlink1, vlink2);
expect(mockVnetService.getVirtualLinks(networkId)).andReturn(vlinkSet).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String location = "vnets/" + networkId.toString() + "/links";
String response = wt.path(location).request().get(String.class);
assertThat(response, containsString("{\"links\":["));
final JsonObject result = Json.parse(response).asObject();
assertThat(result, notNullValue());
assertThat(result.names(), hasSize(1));
assertThat(result.names().get(0), is("links"));
final JsonArray vnetJsonArray = result.get("links").asArray();
assertThat(vnetJsonArray, notNullValue());
assertEquals("Virtual links array is not the correct size.",
vlinkSet.size(), vnetJsonArray.size());
vlinkSet.forEach(vlink -> assertThat(vnetJsonArray, hasVlink(vlink)));
verify(mockVnetService);
}
/**
* Hamcrest matcher to check that a virtual link representation in JSON matches
* the actual virtual link.
*/
private static final class VirtualLinkJsonMatcher extends LinksResourceTest.LinkJsonMatcher {
private final VirtualLink vlink;
private String reason = "";
private VirtualLinkJsonMatcher(VirtualLink vlinkValue) {
super(vlinkValue);
vlink = vlinkValue;
}
@Override
public boolean matchesSafely(JsonObject jsonLink) {
if (!super.matchesSafely(jsonLink)) {
return false;
}
// check NetworkId
String jsonNetworkId = jsonLink.get(ID).asString();
String networkId = vlink.networkId().toString();
if (!jsonNetworkId.equals(networkId)) {
reason = ID + " was " + jsonNetworkId;
return false;
}
return true;
}
@Override
public void describeTo(Description description) {
description.appendText(reason);
}
}
/**
* Factory to allocate a virtual link matcher.
*
* @param vlink virtual link object we are looking for
* @return matcher
*/
private static VirtualLinkJsonMatcher matchesVirtualLink(VirtualLink vlink) {
return new VirtualLinkJsonMatcher(vlink);
}
/**
* Hamcrest matcher to check that a virtual link is represented properly in a JSON
* array of links.
*/
private static final class VirtualLinkJsonArrayMatcher extends TypeSafeMatcher<JsonArray> {
private final VirtualLink vlink;
private String reason = "";
private VirtualLinkJsonArrayMatcher(VirtualLink vlinkValue) {
vlink = vlinkValue;
}
@Override
public boolean matchesSafely(JsonArray json) {
for (int jsonLinkIndex = 0; jsonLinkIndex < json.size();
jsonLinkIndex++) {
JsonObject jsonLink = json.get(jsonLinkIndex).asObject();
if (matchesVirtualLink(vlink).matchesSafely(jsonLink)) {
return true;
}
}
return false;
}
@Override
public void describeTo(Description description) {
description.appendText(reason);
}
}
/**
* Factory to allocate a virtual link array matcher.
*
* @param vlink virtual link object we are looking for
* @return matcher
*/
private VirtualLinkJsonArrayMatcher hasVlink(VirtualLink vlink) {
return new VirtualLinkJsonArrayMatcher(vlink);
}
/**
* Tests adding of new virtual link using POST via JSON stream.
*/
@Test
public void testPostVirtualLink() {
NetworkId networkId = networkId3;
expect(mockVnetAdminService.createVirtualLink(networkId, cp22, cp11))
.andReturn(vlink1);
replay(mockVnetAdminService);
WebTarget wt = target();
InputStream jsonStream = VirtualNetworkWebResourceTest.class
.getResourceAsStream("post-virtual-link.json");
String reqLocation = "vnets/" + networkId.toString() + "/links";
Response response = wt.path(reqLocation).request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(jsonStream));
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_CREATED));
String location = response.getLocation().getPath();
assertThat(location, Matchers.startsWith("/" + reqLocation));
verify(mockVnetAdminService);
}
/**
* Tests adding of a null virtual link using POST via JSON stream.
*/
@Test
public void testPostVirtualLinkNullJsonStream() {
NetworkId networkId = networkId3;
replay(mockVnetAdminService);
WebTarget wt = target();
try {
String reqLocation = "vnets/" + networkId.toString() + "/links";
wt.path(reqLocation)
.request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(null), String.class);
fail("POST of null virtual link did not throw an exception");
} catch (BadRequestException ex) {
assertThat(ex.getMessage(), containsString("HTTP 400 Bad Request"));
}
verify(mockVnetAdminService);
}
/**
* Tests removing a virtual link with DELETE request.
*/
@Test
public void testDeleteVirtualLink() {
NetworkId networkId = networkId3;
mockVnetAdminService.removeVirtualLink(networkId, cp22, cp11);
expectLastCall();
replay(mockVnetAdminService);
WebTarget wt = target()
.property(ClientProperties.SUPPRESS_HTTP_COMPLIANCE_VALIDATION, true);
InputStream jsonStream = VirtualNetworkWebResourceTest.class
.getResourceAsStream("post-virtual-link.json");
String reqLocation = "vnets/" + networkId.toString() + "/links";
Response response = wt.path(reqLocation).request().method("DELETE", Entity.json(jsonStream));
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_NO_CONTENT));
verify(mockVnetAdminService);
}
// Tests for Virtual Hosts
/**
* Tests the result of the REST API GET when there are no virtual hosts.
*/
@Test
public void testGetVirtualHostsEmptyArray() {
NetworkId networkId = networkId4;
expect(mockVnetService.getVirtualHosts(networkId)).andReturn(ImmutableSet.of()).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String location = "vnets/" + networkId.toString() + "/hosts";
String response = wt.path(location).request().get(String.class);
assertThat(response, is("{\"hosts\":[]}"));
verify(mockVnetService);
}
/**
* Tests the result of the REST API GET when virtual hosts are defined.
*/
@Test
public void testGetVirtualHostsArray() {
NetworkId networkId = networkId3;
final Set<VirtualHost> vhostSet = ImmutableSet.of(vhost1, vhost2);
expect(mockVnetService.getVirtualHosts(networkId)).andReturn(vhostSet).anyTimes();
replay(mockVnetService);
WebTarget wt = target();
String location = "vnets/" + networkId.toString() + "/hosts";
String response = wt.path(location).request().get(String.class);
assertThat(response, containsString("{\"hosts\":["));
final JsonObject result = Json.parse(response).asObject();
assertThat(result, notNullValue());
assertThat(result.names(), hasSize(1));
assertThat(result.names().get(0), is("hosts"));
final JsonArray vnetJsonArray = result.get("hosts").asArray();
assertThat(vnetJsonArray, notNullValue());
assertEquals("Virtual hosts array is not the correct size.",
vhostSet.size(), vnetJsonArray.size());
vhostSet.forEach(vhost -> assertThat(vnetJsonArray, hasVhost(vhost)));
verify(mockVnetService);
}
/**
* Hamcrest matcher to check that a virtual host representation in JSON matches
* the actual virtual host.
*/
private static final class VirtualHostJsonMatcher extends HostResourceTest.HostJsonMatcher {
private final VirtualHost vhost;
private String reason = "";
private VirtualHostJsonMatcher(VirtualHost vhostValue) {
super(vhostValue);
vhost = vhostValue;
}
@Override
public boolean matchesSafely(JsonObject jsonHost) {
if (!super.matchesSafely(jsonHost)) {
return false;
}
// check NetworkId
String jsonNetworkId = jsonHost.get(ID).asString();
String networkId = vhost.networkId().toString();
if (!jsonNetworkId.equals(networkId)) {
reason = ID + " was " + jsonNetworkId;
return false;
}
return true;
}
@Override
public void describeTo(Description description) {
description.appendText(reason);
}
}
/**
* Factory to allocate a virtual host matcher.
*
* @param vhost virtual host object we are looking for
* @return matcher
*/
private static VirtualHostJsonMatcher matchesVirtualHost(VirtualHost vhost) {
return new VirtualHostJsonMatcher(vhost);
}
/**
* Hamcrest matcher to check that a virtual host is represented properly in a JSON
* array of hosts.
*/
private static final class VirtualHostJsonArrayMatcher extends TypeSafeMatcher<JsonArray> {
private final VirtualHost vhost;
private String reason = "";
private VirtualHostJsonArrayMatcher(VirtualHost vhostValue) {
vhost = vhostValue;
}
@Override
public boolean matchesSafely(JsonArray json) {
for (int jsonHostIndex = 0; jsonHostIndex < json.size();
jsonHostIndex++) {
JsonObject jsonHost = json.get(jsonHostIndex).asObject();
if (matchesVirtualHost(vhost).matchesSafely(jsonHost)) {
return true;
}
}
return false;
}
@Override
public void describeTo(Description description) {
description.appendText(reason);
}
}
/**
* Factory to allocate a virtual host array matcher.
*
* @param vhost virtual host object we are looking for
* @return matcher
*/
private VirtualHostJsonArrayMatcher hasVhost(VirtualHost vhost) {
return new VirtualHostJsonArrayMatcher(vhost);
}
/**
* Tests adding of new virtual host using POST via JSON stream.
*/
@Test
public void testPostVirtualHost() {
NetworkId networkId = networkId3;
expect(mockVnetAdminService.createVirtualHost(networkId, hId1, mac1, vlan1, loc1, ipSet1))
.andReturn(vhost1);
replay(mockVnetAdminService);
WebTarget wt = target();
InputStream jsonStream = VirtualNetworkWebResourceTest.class
.getResourceAsStream("post-virtual-host.json");
String reqLocation = "vnets/" + networkId.toString() + "/hosts";
Response response = wt.path(reqLocation).request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(jsonStream));
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_CREATED));
String location = response.getLocation().getPath();
assertThat(location, Matchers.startsWith("/" + reqLocation));
verify(mockVnetAdminService);
}
/**
* Tests adding of a null virtual host using POST via JSON stream.
*/
@Test
public void testPostVirtualHostNullJsonStream() {
NetworkId networkId = networkId3;
replay(mockVnetAdminService);
WebTarget wt = target();
try {
String reqLocation = "vnets/" + networkId.toString() + "/hosts";
wt.path(reqLocation)
.request(MediaType.APPLICATION_JSON_TYPE)
.post(Entity.json(null), String.class);
fail("POST of null virtual host did not throw an exception");
} catch (BadRequestException ex) {
assertThat(ex.getMessage(), containsString("HTTP 400 Bad Request"));
}
verify(mockVnetAdminService);
}
/**
* Tests removing a virtual host with DELETE request.
*/
@Test
public void testDeleteVirtualHost() {
NetworkId networkId = networkId3;
mockVnetAdminService.removeVirtualHost(networkId, hId1);
expectLastCall();
replay(mockVnetAdminService);
WebTarget wt = target()
.property(ClientProperties.SUPPRESS_HTTP_COMPLIANCE_VALIDATION, true);
InputStream jsonStream = VirtualNetworkWebResourceTest.class
.getResourceAsStream("post-virtual-host.json");
String reqLocation = "vnets/" + networkId.toString() + "/hosts";
Response response = wt.path(reqLocation).request().method("DELETE", Entity.json(jsonStream));
assertThat(response.getStatus(), is(HttpURLConnection.HTTP_NO_CONTENT));
verify(mockVnetAdminService);
}
}