/**
* Copyright (C) 2008 Abiquo Holdings S.L.
*
* 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 com.abiquo.apiclient;
import static com.abiquo.apiclient.domain.ApiPath.VIRTUALDATACENTERS_URL;
import static com.abiquo.apiclient.domain.Links.create;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.testng.annotations.Test;
import com.abiquo.apiclient.domain.ApiPath;
import com.abiquo.apiclient.domain.options.AllowedDatacenterListOptions;
import com.abiquo.apiclient.domain.options.AllowedPublicCloudRegionListOptions;
import com.abiquo.apiclient.domain.options.ExternalIpListOptions;
import com.abiquo.apiclient.domain.options.VirtualApplianceListOptions;
import com.abiquo.apiclient.domain.options.VirtualDatacenterListOptions;
import com.abiquo.apiclient.domain.options.VirtualMachineListOptions;
import com.abiquo.model.enumerator.NetworkType;
import com.abiquo.model.rest.RESTLink;
import com.abiquo.model.transport.AcceptedRequestDto;
import com.abiquo.model.transport.SingleResourceTransportDto;
import com.abiquo.server.core.appslibrary.VirtualMachineTemplateDto;
import com.abiquo.server.core.cloud.DeviceDto;
import com.abiquo.server.core.cloud.DeviceTypeDto;
import com.abiquo.server.core.cloud.DevicesDto;
import com.abiquo.server.core.cloud.FirewallPoliciesDto;
import com.abiquo.server.core.cloud.FirewallPolicyDto;
import com.abiquo.server.core.cloud.FirewallRulesDto;
import com.abiquo.server.core.cloud.HardwareProfileDto;
import com.abiquo.server.core.cloud.HealthCheckDto;
import com.abiquo.server.core.cloud.HealthChecksDto;
import com.abiquo.server.core.cloud.LoadBalancerAddressesDto;
import com.abiquo.server.core.cloud.LoadBalancerDto;
import com.abiquo.server.core.cloud.LoadBalancersDto;
import com.abiquo.server.core.cloud.RoutingRuleDto;
import com.abiquo.server.core.cloud.RoutingRulesDto;
import com.abiquo.server.core.cloud.VirtualApplianceDto;
import com.abiquo.server.core.cloud.VirtualApplianceState;
import com.abiquo.server.core.cloud.VirtualAppliancesDto;
import com.abiquo.server.core.cloud.VirtualDatacenterDto;
import com.abiquo.server.core.cloud.VirtualDatacentersDto;
import com.abiquo.server.core.cloud.VirtualMachineDto;
import com.abiquo.server.core.cloud.VirtualMachineState;
import com.abiquo.server.core.cloud.VirtualMachineStateDto;
import com.abiquo.server.core.cloud.VirtualMachineTaskDto;
import com.abiquo.server.core.cloud.VirtualMachinesDto;
import com.abiquo.server.core.enterprise.EnterpriseDto;
import com.abiquo.server.core.infrastructure.DatacenterDto;
import com.abiquo.server.core.infrastructure.DatacentersDto;
import com.abiquo.server.core.infrastructure.PublicCloudRegionDto;
import com.abiquo.server.core.infrastructure.PublicCloudRegionsDto;
import com.abiquo.server.core.infrastructure.network.ExternalIpsDto;
import com.abiquo.server.core.infrastructure.network.NicsDto;
import com.abiquo.server.core.infrastructure.network.PublicIpDto;
import com.abiquo.server.core.infrastructure.network.PublicIpsDto;
import com.abiquo.server.core.infrastructure.network.VLANNetworkDto;
import com.abiquo.server.core.infrastructure.network.VMNetworkConfigurationsDto;
import com.abiquo.server.core.infrastructure.storage.TierDto;
import com.abiquo.server.core.infrastructure.storage.TiersDto;
import com.abiquo.server.core.infrastructure.storage.VolumeManagementDto;
import com.abiquo.server.core.infrastructure.storage.VolumesManagementDto;
import com.abiquo.server.core.task.TaskDto;
import com.google.common.base.Optional;
import com.squareup.okhttp.mockwebserver.MockResponse;
import com.squareup.okhttp.mockwebserver.RecordedRequest;
@Test
public class CloudApiTest extends BaseMockTest
{
public void testCreateVirtualAppliance() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vapp.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto dto = new VirtualDatacenterDto();
RESTLink link =
new RESTLink("virtualappliances", "/cloud/virtualdatacenters/1/virtualappliances");
link.setType(VirtualAppliancesDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
newApiClient().getCloudApi().createVirtualAppliance(dto, "VAPP");
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST", VIRTUALDATACENTERS_URL + "/1/virtualappliances");
assertAccept(request, VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualApplianceDto requestBody = readBody(request, VirtualApplianceDto.class);
assertEquals(requestBody.getName(), "VAPP");
}
public void testCreateHealthCheck() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", HealthCheckDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("healthCheck.json"));
server.enqueue(response);
server.start();
LoadBalancerDto lbd = new LoadBalancerDto();
RESTLink link =
new RESTLink("healthchecks",
"/cloud/locations/1/devices/1/loadbalancers/1/healthchecks/1");
link.setType(HealthChecksDto.SHORT_MEDIA_TYPE_JSON);
lbd.addLink(link);
newApiClient().getCloudApi().createHealthCheck(lbd, "Health Check test", "TCP", 30, 5, 2,
22, "/");
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST", "/cloud/locations/1/devices/1/loadbalancers/1/healthchecks/1");
assertAccept(request, HealthCheckDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, HealthCheckDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
HealthCheckDto requestBody = readBody(request, HealthCheckDto.class);
assertEquals(requestBody.getName(), "Health Check test");
}
public void testDeleteHealthCheck() throws Exception
{
MockResponse response = new MockResponse() //
.setBody(payloadFromResource("healthCheck.json"));
server.enqueue(response);
server.start();
HealthCheckDto healthCheck = new HealthCheckDto();
RESTLink link =
new RESTLink("edit", "/cloud/locations/1/devices/1/loadbalancers/1/healthchecks/1");
link.setType(HealthCheckDto.SHORT_MEDIA_TYPE_JSON);
healthCheck.addEditLink(link);
newApiClient().getCloudApi().deleteHealthCheck(healthCheck);
RecordedRequest request = server.takeRequest();
assertRequest(request, "DELETE",
"/cloud/locations/1/devices/1/loadbalancers/1/healthchecks/1");
}
public void testDeleteLoadBalancer() throws Exception
{
MockResponse response = new MockResponse() //
.setBody(payloadFromResource("loadBalancer.json"));
server.enqueue(response);
server.start();
LoadBalancerDto lbd = new LoadBalancerDto();
RESTLink link = new RESTLink("edit", "/cloud/locations/1/devices/1/loadbalancers/1");
link.setType(LoadBalancerDto.SHORT_MEDIA_TYPE_JSON);
lbd.addEditLink(link);
newApiClient().getCloudApi().deleteLoadBalancer(lbd);
RecordedRequest request = server.takeRequest();
assertRequest(request, "DELETE", "/cloud/locations/1/devices/1/loadbalancers/1");
}
public void testDeleteRoutingRule() throws Exception
{
MockResponse response = new MockResponse() //
.setBody(payloadFromResource("routingRule.json"));
server.enqueue(response);
server.start();
RoutingRuleDto routingRule = new RoutingRuleDto();
RESTLink link =
new RESTLink("edit",
"/cloud/locations/1/devices/1/loadbalancers/1/routingrules/1");
link.setType(RoutingRuleDto.SHORT_MEDIA_TYPE_JSON);
routingRule.addEditLink(link);
newApiClient().getCloudApi().deleteRoutingRule(routingRule);
RecordedRequest request = server.takeRequest();
assertRequest(request, "DELETE",
"/cloud/locations/1/devices/1/loadbalancers/1/routingrules/1");
}
public void testCreateRoutingRule() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", RoutingRuleDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("routingRule.json"));
server.enqueue(response);
server.start();
LoadBalancerDto lbd = new LoadBalancerDto();
RESTLink link =
new RESTLink("routingrules",
"/cloud/locations/1/devices/1/loadbalancers/1/routingrules/1");
link.setType(RoutingRulesDto.SHORT_MEDIA_TYPE_JSON);
lbd.addLink(link);
newApiClient().getCloudApi().createRoutingRule(lbd, "TCP", "TCP", 22, 22, null);
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/locations/1/devices/1/loadbalancers/1/routingrules/1");
assertAccept(request, RoutingRuleDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, RoutingRuleDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
RoutingRuleDto requestBody = readBody(request, RoutingRuleDto.class);
assertEquals(requestBody.getProtocolIn(), "TCP");
}
public void testCreateLoadBalancer() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VolumeManagementDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("loadBalancer.json"));
server.enqueue(response);
server.start();
DeviceDto device = new DeviceDto();
RESTLink linkDevice =
new RESTLink("loadbalancers", "/cloud/locations/1/devices/1/loadbalancers/1");
linkDevice.setType(LoadBalancersDto.SHORT_MEDIA_TYPE_JSON);
device.addLink(linkDevice);
RoutingRulesDto rr = new RoutingRulesDto();
RESTLink linkRR =
new RESTLink("routingrules", "/cloud/locations/1/devices/1/loadbalancer/1/routingrules");
linkRR.setType(RoutingRulesDto.SHORT_MEDIA_TYPE_JSON);
device.addLink(linkRR);
HealthChecksDto healthChecks = new HealthChecksDto();
RESTLink linkHC =
new RESTLink("healthChecks", "/cloud/locations/1/devices/1/loadbalancer/1/healthChecks");
linkHC.setType(HealthChecksDto.SHORT_MEDIA_TYPE_JSON);
device.addLink(linkHC);
LoadBalancerAddressesDto lBA = new LoadBalancerAddressesDto();
RESTLink linkA =
new RESTLink("loadbalanceraddresses",
"/cloud/locations/1/devices/1/loadbalancer/1/addresses");
linkA.setType(LoadBalancerAddressesDto.SHORT_MEDIA_TYPE_JSON);
device.addLink(linkA);
List<FirewallPolicyDto> listFwp = new ArrayList<>();
FirewallPolicyDto fwp = new FirewallPolicyDto();
RESTLink lFWP =
new RESTLink("firewall", "/cloud/locations/1/devices/1/loadbalancer/1/firewalls");
RESTLink eFWP =
new RESTLink("edit", "/cloud/locations/1/devices/1/loadbalancer/1/firewalls");
fwp.addEditLink(eFWP);
listFwp.add(fwp);
lFWP.setType(FirewallPoliciesDto.SHORT_MEDIA_TYPE_JSON);
device.addLink(lFWP);
newApiClient().getCloudApi().createLoadBalancer(device, "TEST", "ROUND_ROBIN", rr,
healthChecks, lBA, listFwp,
Optional.<VLANNetworkDto> absent());
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST", "/cloud/locations/1/devices/1/loadbalancers/1");
assertAccept(request, LoadBalancerDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, LoadBalancerDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
LoadBalancerDto requestBody = readBody(request, LoadBalancerDto.class);
assertEquals(requestBody.getName(), "TEST");
}
public void testEditHealthCheck() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", HealthCheckDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("healthCheck.json"));
server.enqueue(response);
server.start();
RESTLink link =
new RESTLink("edit",
"/cloud/locations/1/devices/1/loadbalancers/1/healthchecks/1");
link.setType(HealthCheckDto.SHORT_MEDIA_TYPE_JSON);
HealthCheckDto healthCheck = new HealthCheckDto();
healthCheck.setName("Test");
healthCheck.addEditLink(link);
newApiClient().getCloudApi().editHealthCheck(healthCheck);
assertEquals(healthCheck.getName(), "Test");
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT", "/cloud/locations/1/devices/1/loadbalancers/1/healthchecks/1");
assertContentType(request, HealthCheckDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
HealthCheckDto requestBody = readBody(request, HealthCheckDto.class);
assertEquals(requestBody.searchLink("edit").getHref(), healthCheck.getEditLink().getHref());
}
public void testEditRoutingRule() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", RoutingRuleDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("routingRule.json"));
server.enqueue(response);
server.start();
RESTLink link =
new RESTLink("edit",
"/cloud/locations/1/devices/1/loadbalancers/1/routingrules/1");
link.setType(HealthCheckDto.SHORT_MEDIA_TYPE_JSON);
RoutingRuleDto routingRule = new RoutingRuleDto();
routingRule.addEditLink(link);
newApiClient().getCloudApi().editRoutingRule(routingRule);
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT", "/cloud/locations/1/devices/1/loadbalancers/1/routingrules/1");
assertContentType(request, HealthCheckDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
RoutingRuleDto requestBody = readBody(request, RoutingRuleDto.class);
assertEquals(requestBody.searchLink("edit").getHref(), routingRule.getEditLink().getHref());
}
public void testEditLoadBalancer() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", LoadBalancerDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("loadBalancer.json"));
server.enqueue(response);
server.start();
RESTLink link = new RESTLink("edit", "/cloud/locations/1/devices/1/loadbalancers/1");
link.setType(LoadBalancerDto.SHORT_MEDIA_TYPE_JSON);
LoadBalancerDto lbd = new LoadBalancerDto();
lbd.setName("Test");
lbd.addEditLink(link);
newApiClient().getCloudApi().editLoadBalancer(lbd);
assertEquals(lbd.getName(), "Test");
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT", "/cloud/locations/1/devices/1/loadbalancers/1");
assertContentType(request, LoadBalancerDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
LoadBalancerDto requestBody = readBody(request, LoadBalancerDto.class);
assertEquals(requestBody.searchLink("edit").getHref(), lbd.getEditLink().getHref());
}
public void testCreateVirtualDatacenter() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualDatacenterDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vdc.json"));
server.enqueue(response);
server.start();
DatacenterDto location = new DatacenterDto();
RESTLink link = new RESTLink("self", "/cloud/locations/1");
link.setType(DatacenterDto.SHORT_MEDIA_TYPE_JSON);
location.addLink(link);
EnterpriseDto enterprise = new EnterpriseDto();
link = new RESTLink("edit", "/admin/enterprises/1");
link.setType(EnterpriseDto.SHORT_MEDIA_TYPE_JSON);
enterprise.addLink(link);
newApiClient().getCloudApi().createVirtualDatacenter(location, enterprise, "VDC", "KVM",
"192.168.0.0", "192.168.0.1", "default_private_network");
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST", VIRTUALDATACENTERS_URL);
assertAccept(request, VirtualDatacenterDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualDatacenterDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualDatacenterDto requestBody = readBody(request, VirtualDatacenterDto.class);
assertEquals(requestBody.getName(), "VDC");
assertEquals(requestBody.getHypervisorType(), "KVM");
VLANNetworkDto vlanDto = requestBody.getVlan();
assertNotNull(vlanDto);
assertEquals(vlanDto.getName(), "default_private_network");
assertEquals(vlanDto.getAddress(), "192.168.0.0");
assertEquals(vlanDto.getGateway(), "192.168.0.1");
assertEquals(vlanDto.getMask(), new Integer(24));
assertEquals(vlanDto.getType(), NetworkType.INTERNAL);
assertLinkExist(requestBody, enterprise.getEditLink().getHref(), "enterprise",
EnterpriseDto.SHORT_MEDIA_TYPE_JSON);
assertLinkExist(requestBody, location.searchLink("self").getHref(), "location",
DatacenterDto.SHORT_MEDIA_TYPE_JSON);
}
public void testCreateVirtualMachine() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualMachineDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vm.json"));
server.enqueue(response);
server.start();
VirtualMachineTemplateDto template = new VirtualMachineTemplateDto();
RESTLink link =
new RESTLink("edit",
"/admin/enterprises/1/datacenterrepositories/1/virtualmachinetemplates/109");
link.setType(VirtualMachineTemplateDto.SHORT_MEDIA_TYPE_JSON);
template.addLink(link);
VirtualApplianceDto vapp = new VirtualApplianceDto();
link =
new RESTLink("virtualmachines",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines");
link.setType(VirtualMachinesDto.SHORT_MEDIA_TYPE_JSON);
vapp.addLink(link);
VirtualMachineDto vmDto = newApiClient().getCloudApi().createVirtualMachine(template, vapp);
assertEquals(vmDto.getId().intValue(), 1);
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines");
assertAccept(request, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualMachineDto requestBody = readBody(request, VirtualMachineDto.class);
assertEquals(requestBody.getVdrpEnabled(), Boolean.TRUE);
assertLinkExist(requestBody, template.getEditLink().getHref(), "virtualmachinetemplate",
VirtualMachineTemplateDto.SHORT_MEDIA_TYPE_JSON);
}
public void testCreateVirtualMachineWithHardwareProfile() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualMachineDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vm.json"));
server.enqueue(response);
server.start();
VirtualMachineTemplateDto template = new VirtualMachineTemplateDto();
template.addLink(create("edit",
"/admin/enterprises/1/datacenterrepositories/1/virtualmachinetemplates/109",
VirtualMachineTemplateDto.SHORT_MEDIA_TYPE_JSON));
VirtualApplianceDto vapp = new VirtualApplianceDto();
vapp.addLink(create("virtualmachines",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines",
VirtualMachinesDto.SHORT_MEDIA_TYPE_JSON));
HardwareProfileDto hp = new HardwareProfileDto();
hp.addLink(create("self", "/cloud/locations/1/hardwareprofiles/1",
HardwareProfileDto.SHORT_MEDIA_TYPE_JSON));
VirtualMachineDto vmDto =
newApiClient().getCloudApi().createVirtualMachine(template, vapp, hp);
assertEquals(vmDto.getId().intValue(), 1);
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines");
assertAccept(request, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualMachineDto requestBody = readBody(request, VirtualMachineDto.class);
assertEquals(requestBody.getVdrpEnabled(), Boolean.TRUE);
assertLinkExist(requestBody, template.getEditLink().getHref(), "virtualmachinetemplate",
VirtualMachineTemplateDto.SHORT_MEDIA_TYPE_JSON);
assertLinkExist(requestBody, hp.searchLink("self").getHref(), "hardwareprofile",
HardwareProfileDto.SHORT_MEDIA_TYPE_JSON);
}
public void testCreatePublicIp() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", PublicIpDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("publicip.json"));
server.enqueue(response);
server.start();
PublicCloudRegionDto location = new PublicCloudRegionDto();
RESTLink link = new RESTLink("ips", "/cloud/locations/1/ips");
link.setType(PublicIpsDto.SHORT_MEDIA_TYPE_JSON);
location.addLink(link);
PublicIpDto ipDto = newApiClient().getCloudApi().createPublicIp(location);
int id = ipDto.getId();
assertEquals(id, 1);
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST", "/cloud/locations/1/ips");
assertAccept(request, PublicIpDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testAddPublicIpToVirtualDatacenter() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", PublicIpDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("publicip.json"));
server.enqueue(response);
server.start();
PublicIpDto ip = new PublicIpDto();
ip.setId(1);
VirtualDatacenterDto dto = new VirtualDatacenterDto();
dto.addLink(create("purchased", "/cloud/virtualdatacenters/1/publicips/purchased",
PublicIpsDto.SHORT_MEDIA_TYPE_JSON));
PublicIpDto ipDto = newApiClient().getCloudApi().addPublicIpToVirtualDatacenter(ip, dto);
assertEquals(ipDto.getId().intValue(), 1);
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT", "/cloud/virtualdatacenters/1/publicips/purchased/1");
assertAccept(request, PublicIpDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testReleasePublicIpFromVirtualDatacenter() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", PublicIpDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("publicip.json"));
server.enqueue(response);
server.start();
PublicIpDto ip = new PublicIpDto();
ip.setId(1);
VirtualDatacenterDto dto = new VirtualDatacenterDto();
dto.addLink(create("topurchase", "/cloud/virtualdatacenters/1/publicips/topurchase",
PublicIpsDto.SHORT_MEDIA_TYPE_JSON));
PublicIpDto ipDto =
newApiClient().getCloudApi().releasePublicIpFromVirtualDatacenter(ip, dto);
assertEquals(ipDto.getId().intValue(), 1);
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT", "/cloud/virtualdatacenters/1/publicips/topurchase/1");
assertAccept(request, PublicIpDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testAssignPublicIpToVirtualMachine() throws Exception
{
server.enqueue(new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json")));
VirtualMachineDto notAllocated = new VirtualMachineDto();
notAllocated.setState(VirtualMachineState.NOT_ALLOCATED);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(notAllocated)));
server.start();
PublicIpDto ip = new PublicIpDto();
ip.setIp("52.18.52.31");
ip.setId(1);
ip.addLink(create("self", "/cloud/locations/1/ips/1", PublicIpDto.SHORT_MEDIA_TYPE_JSON));
PublicCloudRegionDto location = new PublicCloudRegionDto();
location.setName("publicCloudRegion");
location.addLink(create("self", "/cloud/locations/1",
PublicCloudRegionDto.SHORT_MEDIA_TYPE_JSON));
VirtualDatacenterDto vdc = new VirtualDatacenterDto();
vdc.addLink(create("purchased", "/cloud/virtualdatacenters/1/publicips/purchased",
PublicIpsDto.SHORT_MEDIA_TYPE_JSON));
VirtualMachineDto dto = new VirtualMachineDto();
dto.setState(VirtualMachineState.NOT_ALLOCATED);
dto.addLink(create("nic0", "/cloud/virtualdatacenters/1/publicips/purchased/3",
PublicIpDto.SHORT_MEDIA_TYPE_JSON));
dto.addLink(create("edit",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON));
VirtualMachineDto vm =
newApiClient().getCloudApi().assignPublicIpToVirtualMachine(ip, location, vdc, dto);
// Verify the returned status is the right one
assertEquals(vm.getState(), VirtualMachineState.NOT_ALLOCATED);
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualMachineDto requestBody = readBody(request, VirtualMachineDto.class);
assertEquals(requestBody.searchLink("nic1").getHref(),
"/cloud/virtualdatacenters/1/publicips/purchased/1");
assertEquals(requestBody.searchLink("nic1").getType(), PublicIpDto.SHORT_MEDIA_TYPE_JSON);
}
public void testCreateFirewallDeviceInVirtualDatacenter() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", DeviceTypeDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("firewalldevice.json"));
server.enqueue(response);
server.start();
DeviceTypeDto firewallDeviceType = new DeviceTypeDto();
firewallDeviceType.addLink(create("self", "/config/devicetypes",
DeviceTypeDto.SHORT_MEDIA_TYPE_JSON));
PublicCloudRegionDto pcr = new PublicCloudRegionDto();
pcr.addLink(create("devices", "/cloud/locations/1/devices",
DeviceDto.SHORT_MEDIA_TYPE_JSON, "devices"));
pcr.addLink(create("location", "/cloud/locations/1", PublicCloudRegionDto.MEDIA_TYPE));
VirtualDatacenterDto vdc = new VirtualDatacenterDto();
vdc.setName("VDCTest");
vdc.addEditLink(create("edit", "/cloud/virtualdatacenters/1/",
VirtualDatacenterDto.SHORT_MEDIA_TYPE_JSON));
newApiClient().getCloudApi().createDevice(pcr, firewallDeviceType, "deviceTest", null,
null, null, vdc, false);
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST", "/cloud/locations/1/devices");
assertAccept(request, DeviceDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
DeviceTypeDto requestBody = readBody(request, DeviceTypeDto.class);
assertEquals(requestBody.searchLink("virtualdatacenter").getHref(), vdc.getEditLink()
.getHref());
assertEquals(requestBody.searchLink("virtualdatacenter").getType(),
VirtualDatacenterDto.SHORT_MEDIA_TYPE_JSON);
}
public void testCreateFirewallPolicy() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", FirewallPolicyDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("firewallpolicy.json"));
server.enqueue(response);
server.start();
DeviceDto fwdevice = new DeviceDto();
fwdevice.addLink(create("firewalls",
"/cloud/locations/1/firewalldevices/1/firewallpolicies",
FirewallPoliciesDto.SHORT_MEDIA_TYPE_JSON));
String firewallName = "firewallTest";
String firewallDescription = "firewallTestDescription";
FirewallPolicyDto firewallDto =
newApiClient().getCloudApi().createFirewallPolicy(firewallName, firewallDescription,
fwdevice, Optional.<VirtualDatacenterDto> absent());
assertEquals(firewallDto.getId().intValue(), 1);
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST", "/cloud/locations/1/firewalldevices/1/firewallpolicies");
assertAccept(request, FirewallPolicyDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
FirewallPolicyDto requestBody = readBody(request, FirewallPolicyDto.class);
assertEquals(requestBody.getName(), firewallName);
assertEquals(requestBody.getDescription(), firewallDescription);
}
public void testAddFirewallRules() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", FirewallRulesDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("firewallrules.json"));
server.enqueue(response);
server.start();
FirewallPolicyDto firewall = new FirewallPolicyDto();
firewall.addLink(create("rules", "/cloud/locations/1/firewalls/1/rules",
FirewallRulesDto.SHORT_MEDIA_TYPE_JSON));
FirewallRulesDto rules = new FirewallRulesDto();
FirewallRulesDto rulesDto = newApiClient().getCloudApi().addFirewallRules(firewall, rules);
assertNotNull(rulesDto.getCollection());
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT", "/cloud/locations/1/firewalls/1/rules");
assertAccept(request, FirewallRulesDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testAddFirewallToVirtualMachine() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("vm.json"));
server.enqueue(response);
server.start();
FirewallPolicyDto firewall = new FirewallPolicyDto();
firewall.setName("firewallTest");
firewall.addEditLink(create("edit", "/cloud/locations/1/firewalls/1",
FirewallPolicyDto.SHORT_MEDIA_TYPE_JSON));
VirtualMachineDto vm = new VirtualMachineDto();
vm.addEditLink(create("edit",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON));
newApiClient().getCloudApi().addFirewallToVirtualMachine(firewall, vm);
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT", vm.getEditLink().getHref());
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testGetNics() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", NicsDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("nics.json"));
server.enqueue(response);
server.start();
VirtualMachineDto vm = new VirtualMachineDto();
vm.addLink(create("nics",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/network/nics",
NicsDto.SHORT_MEDIA_TYPE_JSON));
NicsDto nicsDto = newApiClient().getCloudApi().getNics(vm);
assertNotNull(nicsDto.getCollection());
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/network/nics");
assertAccept(request, NicsDto.SHORT_MEDIA_TYPE_JSON, SingleResourceTransportDto.API_VERSION);
}
public void testGetHealthCheck() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", HealthCheckDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("healthCheck.json"));
server.enqueue(response);
server.start();
LoadBalancerDto lb = new LoadBalancerDto();
lb.addLink(create("healthchecks",
"/cloud/locations/1/devices/1/loadbalancers/1/healthchecks",
HealthChecksDto.SHORT_MEDIA_TYPE_JSON));
newApiClient().getCloudApi().getHealthCheck(lb, "1");
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/locations/1/devices/1/loadbalancers/1/healthchecks/1");
assertAccept(request, HealthCheckDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testGetLoadBalancer() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", LoadBalancerDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("loadBalancer.json"));
server.enqueue(response);
server.start();
DeviceDto device = new DeviceDto();
device.addLink(create("loadbalancers", "/cloud/locations/1/devices/1/loadbalancers",
LoadBalancersDto.SHORT_MEDIA_TYPE_JSON));
newApiClient().getCloudApi().getLoadBalacer(device, "1");
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/locations/1/devices/1/loadbalancers/1");
assertAccept(request, LoadBalancerDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testGetRoutingRule() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", RoutingRuleDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("routingRule.json"));
server.enqueue(response);
server.start();
LoadBalancerDto lb = new LoadBalancerDto();
lb.addLink(create("routingrules",
"/cloud/locations/1/devices/1/loadbalancers/1/routingrules",
RoutingRulesDto.SHORT_MEDIA_TYPE_JSON));
newApiClient().getCloudApi().getRoutingRule(lb, "1");
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/locations/1/devices/1/loadbalancers/1/routingrules/1");
assertAccept(request, RoutingRuleDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testCreateVolume() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VolumeManagementDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("volume.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto vdc = new VirtualDatacenterDto();
RESTLink link = new RESTLink("volumes", "/cloud/virtualdatacenters/1/volumes");
link.setType(VolumesManagementDto.SHORT_MEDIA_TYPE_JSON);
vdc.addLink(link);
TierDto tier = new TierDto();
link = new RESTLink("self", "/cloud/virtualdatacenters/1/tiers/1");
link.setType(TierDto.SHORT_MEDIA_TYPE_JSON);
tier.addLink(link);
newApiClient().getCloudApi().createVolume(vdc, "volumeTest", 1024, tier);
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST", "/cloud/virtualdatacenters/1/volumes");
assertAccept(request, VolumeManagementDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VolumeManagementDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VolumeManagementDto requestBody = readBody(request, VolumeManagementDto.class);
assertEquals(requestBody.getName(), "volumeTest");
assertEquals(requestBody.getSizeInMB(), 1024);
assertLinkExist(requestBody, tier.searchLink("self").getHref(), "tier",
TierDto.SHORT_MEDIA_TYPE_JSON);
}
public void testDeployVirtualAppliance() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualApplianceDto deployed = new VirtualApplianceDto();
deployed.setState(VirtualApplianceState.DEPLOYED);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(deployed)));
server.start();
VirtualApplianceDto dto = new VirtualApplianceDto();
RESTLink link =
new RESTLink("deploy", "/cloud/virtualdatacenters/1/virtualappliances/1/action/deploy");
link.setType(AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link = new RESTLink("edit", "/cloud/virtualdatacenters/1/virtualappliances/1");
link.setType(VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
VirtualApplianceDto vapp =
newApiClient().getCloudApi().deploy(dto, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vapp.getState(), VirtualApplianceState.DEPLOYED);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/action/deploy?force=false");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testDeployVirtualApplianceWithForce() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualApplianceDto deployed = new VirtualApplianceDto();
deployed.setState(VirtualApplianceState.DEPLOYED);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(deployed)));
server.start();
VirtualApplianceDto dto = new VirtualApplianceDto();
RESTLink link =
new RESTLink("deploy", "/cloud/virtualdatacenters/1/virtualappliances/1/action/deploy");
link.setType(AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link = new RESTLink("edit", "/cloud/virtualdatacenters/1/virtualappliances/1");
link.setType(VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
VirtualApplianceDto vapp =
newApiClient().getCloudApi().deploy(dto, true, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vapp.getState(), VirtualApplianceState.DEPLOYED);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/action/deploy?force=true");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testUndeployVirtualAppliance() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualApplianceDto notDeployed = new VirtualApplianceDto();
notDeployed.setState(VirtualApplianceState.NOT_DEPLOYED);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(notDeployed)));
server.start();
VirtualApplianceDto dto = new VirtualApplianceDto();
RESTLink link =
new RESTLink("undeploy",
"/cloud/virtualdatacenters/1/virtualappliances/1/action/undeploy");
link.setType(AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link = new RESTLink("edit", "/cloud/virtualdatacenters/1/virtualappliances/1");
link.setType(VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
VirtualApplianceDto vm =
newApiClient().getCloudApi().undeploy(dto, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vm.getState(), VirtualApplianceState.NOT_DEPLOYED);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/action/undeploy");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineTaskDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualMachineTaskDto requestBody = readBody(request, VirtualMachineTaskDto.class);
assertEquals(requestBody.getForceUndeploy(), false);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testUndeployVirtualApplianceWithForce() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualApplianceDto notDeployed = new VirtualApplianceDto();
notDeployed.setState(VirtualApplianceState.NOT_DEPLOYED);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(notDeployed)));
server.start();
VirtualApplianceDto dto = new VirtualApplianceDto();
RESTLink link =
new RESTLink("undeploy",
"/cloud/virtualdatacenters/1/virtualappliances/1/action/undeploy");
link.setType(AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link = new RESTLink("edit", "/cloud/virtualdatacenters/1/virtualappliances/1");
link.setType(VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
VirtualApplianceDto vm =
newApiClient().getCloudApi().undeploy(dto, true, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vm.getState(), VirtualApplianceState.NOT_DEPLOYED);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/action/undeploy");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineTaskDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualMachineTaskDto requestBody = readBody(request, VirtualMachineTaskDto.class);
assertEquals(requestBody.getForceUndeploy(), true);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testDeployVirtualMachine() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualMachineDto powerOn = new VirtualMachineDto();
powerOn.setState(VirtualMachineState.ON);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(powerOn)));
server.start();
VirtualMachineDto dto = new VirtualMachineDto();
RESTLink link =
new RESTLink("deploy",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/action/deploy");
link.setType(AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link =
new RESTLink("edit",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
link.setType(VirtualMachineDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
VirtualMachineDto vm = newApiClient().getCloudApi().deploy(dto, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vm.getState(), VirtualMachineState.ON);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/action/deploy?force=false");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testDeployVirtualMachineWithForce() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualMachineDto powerOn = new VirtualMachineDto();
powerOn.setState(VirtualMachineState.ON);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(powerOn)));
server.start();
VirtualMachineDto dto = new VirtualMachineDto();
RESTLink link =
new RESTLink("deploy",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/action/deploy");
link.setType(AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link =
new RESTLink("edit",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
link.setType(VirtualMachineDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
VirtualMachineDto vm =
newApiClient().getCloudApi().deploy(dto, true, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vm.getState(), VirtualMachineState.ON);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/action/deploy?force=true");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testUndeployVirtualMachine() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualMachineDto notAllocated = new VirtualMachineDto();
notAllocated.setState(VirtualMachineState.NOT_ALLOCATED);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(notAllocated)));
server.start();
VirtualMachineDto dto = new VirtualMachineDto();
RESTLink link =
new RESTLink("undeploy",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/action/undeploy");
link.setType(AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link =
new RESTLink("edit",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
link.setType(VirtualMachineDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
VirtualMachineDto vm = newApiClient().getCloudApi().undeploy(dto, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vm.getState(), VirtualMachineState.NOT_ALLOCATED);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/action/undeploy");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineTaskDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualMachineTaskDto requestBody = readBody(request, VirtualMachineTaskDto.class);
assertEquals(requestBody.getForceUndeploy(), false);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testUndeployVirtualMachineWithForce() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualMachineDto notAllocated = new VirtualMachineDto();
notAllocated.setState(VirtualMachineState.NOT_ALLOCATED);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(notAllocated)));
server.start();
VirtualMachineDto dto = new VirtualMachineDto();
RESTLink link =
new RESTLink("undeploy",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/action/undeploy");
link.setType(AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link =
new RESTLink("edit",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
link.setType(VirtualMachineDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
VirtualMachineDto vm =
newApiClient().getCloudApi().undeploy(dto, true, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vm.getState(), VirtualMachineState.NOT_ALLOCATED);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "POST",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/action/undeploy");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineTaskDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualMachineTaskDto requestBody = readBody(request, VirtualMachineTaskDto.class);
assertEquals(requestBody.getForceUndeploy(), true);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testEditVirtualMachine() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualMachineDto notAllocated = new VirtualMachineDto();
notAllocated.setState(VirtualMachineState.NOT_ALLOCATED);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(notAllocated)));
server.start();
VirtualMachineDto dto = new VirtualMachineDto();
RESTLink link =
new RESTLink("edit",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
link.setType(VirtualMachineDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
dto.setState(VirtualMachineState.NOT_ALLOCATED);
VirtualMachineDto vm =
newApiClient().getCloudApi().editVirtualMachine(dto, 1, 300, TimeUnit.SECONDS);
// Verify the returned status is the right one
assertEquals(vm.getState(), VirtualMachineState.NOT_ALLOCATED);
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testPowerState() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("acceptedRequest.json"));
server.enqueue(response);
VirtualMachineDto powerOff = new VirtualMachineDto();
powerOff.setState(VirtualMachineState.OFF);
server.enqueue(new MockResponse().addHeader("Content-type",
VirtualMachineDto.SHORT_MEDIA_TYPE_JSON).setBody(json.write(powerOff)));
server.start();
VirtualMachineDto dto = new VirtualMachineDto();
RESTLink link =
new RESTLink("state",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/state");
link.setType(VirtualMachineStateDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
link =
new RESTLink("edit",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
link.setType(VirtualMachineDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
newApiClient().getCloudApi().powerState(dto, VirtualMachineState.OFF, 1, 300,
TimeUnit.SECONDS);
// Make sure the polling has retried once
assertEquals(server.getRequestCount(), 2);
// Verify the first request
RecordedRequest request = server.takeRequest();
assertRequest(request, "PUT",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/state");
assertAccept(request, AcceptedRequestDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
assertContentType(request, VirtualMachineStateDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
VirtualMachineStateDto requestBody = readBody(request, VirtualMachineStateDto.class);
assertEquals(requestBody.getState(), VirtualMachineState.OFF);
// Verify the second request
RecordedRequest second = server.takeRequest();
assertRequest(second, "GET", dto.getEditLink().getHref());
assertAccept(second, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testGetPrivateNetwork() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VLANNetworkDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("privatenetwork.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto vdc = new VirtualDatacenterDto();
vdc.addLink(new RESTLink("privatenetworks", "/cloud/virtualdatacenters/1/privatenetworks"));
newApiClient().getCloudApi().getPrivateNetwork(vdc, "1");
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/virtualdatacenters/1/privatenetworks/1");
assertAccept(request, VLANNetworkDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testGetTask() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", TaskDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("task.json"));
server.enqueue(response);
server.start();
VirtualMachineDto vm = new VirtualMachineDto();
vm.addLink(new RESTLink("tasks",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/tasks"));
newApiClient().getCloudApi().getTask(vm, "f9df77b3-2068-4a07-8336-38d4c8235e4d");
RecordedRequest request = server.takeRequest();
assertRequest(
request,
"GET",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/tasks/f9df77b3-2068-4a07-8336-38d4c8235e4d");
assertAccept(request, TaskDto.SHORT_MEDIA_TYPE_JSON, SingleResourceTransportDto.API_VERSION);
}
public void testGetVirtualAppliance() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("vapp.json"));
server.enqueue(response);
server.start();
newApiClient().getCloudApi().getVirtualAppliance("1", "1");
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/virtualdatacenters/1/virtualappliances/1");
assertAccept(request, VirtualApplianceDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testGetVirtualDatacenter() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualDatacenterDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("vdc.json"));
server.enqueue(response);
server.start();
newApiClient().getCloudApi().getVirtualDatacenter("1");
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/virtualdatacenters/1");
assertAccept(request, VirtualDatacenterDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testGetVirtualMachine() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualMachineDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("vm.json"));
server.enqueue(response);
server.start();
VirtualApplianceDto vapp = new VirtualApplianceDto();
vapp.addLink(new RESTLink("virtualmachines",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines"));
newApiClient().getCloudApi().getVirtualMachine(vapp, "1");
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1");
assertAccept(request, VirtualMachineDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testGetVolume() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VolumeManagementDto.SHORT_MEDIA_TYPE_JSON)//
.setBody(payloadFromResource("volume.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto vdc = new VirtualDatacenterDto();
vdc.addLink(new RESTLink("volumes", "/cloud/virtualdatacenters/1/volumes"));
newApiClient().getCloudApi().getVolume(vdc, "1");
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/virtualdatacenters/1/volumes/1");
assertAccept(request, VolumeManagementDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListExternalIps() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", ExternalIpsDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("externalips.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto dto = new VirtualDatacenterDto();
RESTLink link =
new RESTLink("externalips", "/cloud/virtualdatacenters/1/action/externalips");
link.setType(ExternalIpsDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
newApiClient().getCloudApi().listExternalIps(dto);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/virtualdatacenters/1/action/externalips");
assertAccept(request, ExternalIpsDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListExternalIpsWithOptions() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", ExternalIpsDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("externalips.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto dto = new VirtualDatacenterDto();
RESTLink link =
new RESTLink("externalips", "/cloud/virtualdatacenters/1/action/externalips");
link.setType(ExternalIpsDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
newApiClient().getCloudApi().listExternalIps(dto,
ExternalIpListOptions.builder().limit(0).all(true).build());
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET",
"/cloud/virtualdatacenters/1/action/externalips?all=true&limit=0");
assertAccept(request, ExternalIpsDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListNetworkConfigurations() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VMNetworkConfigurationsDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("networkconfiguration.json"));
server.enqueue(response);
server.start();
VirtualMachineDto dto = new VirtualMachineDto();
RESTLink link =
new RESTLink("configurations",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/network/configurations");
link.setType(VMNetworkConfigurationsDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
newApiClient().getCloudApi().listNetworkConfigurations(dto);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines/1/network/configurations");
assertAccept(request, VMNetworkConfigurationsDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListVirtualAppliances() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualAppliancesDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vapps.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto dto = new VirtualDatacenterDto();
RESTLink link =
new RESTLink("virtualappliances", "/cloud/virtualdatacenters/1/virtualappliances");
link.setType(VirtualAppliancesDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
newApiClient().getCloudApi().listVirtualAppliances(dto);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/virtualdatacenters/1/virtualappliances");
assertAccept(request, VirtualAppliancesDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListVirtualAppliancesWithOptions() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualAppliancesDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vapps.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto dto = new VirtualDatacenterDto();
RESTLink link =
new RESTLink("virtualappliances", "/cloud/virtualdatacenters/1/virtualappliances");
link.setType(VirtualAppliancesDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
newApiClient().getCloudApi().listVirtualAppliances(dto,
VirtualApplianceListOptions.builder().limit(0).expand("foo").build());
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET",
"/cloud/virtualdatacenters/1/virtualappliances?expand=foo&limit=0");
assertAccept(request, VirtualAppliancesDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListDevice() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", DevicesDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("devices.json"));
server.enqueue(response);
server.start();
PublicCloudRegionDto pcr = new PublicCloudRegionDto();
RESTLink link = new RESTLink("devices", "/cloud/locations/1/devices");
link.setType(DevicesDto.SHORT_MEDIA_TYPE_JSON);
pcr.addLink(link);
newApiClient().getCloudApi().listDevices(pcr);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/locations/1/devices");
assertAccept(request, DevicesDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListLoadBalancer() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", LoadBalancersDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("loadBalancers.json"));
server.enqueue(response);
server.start();
DeviceDto device = new DeviceDto();
RESTLink link = new RESTLink("loadbalancers", "/cloud/locations/1/devices/1/loadbalancers");
link.setType(LoadBalancersDto.SHORT_MEDIA_TYPE_JSON);
device.addLink(link);
newApiClient().getCloudApi().listLoadBalancers(device);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/locations/1/devices/1/loadbalancers");
assertAccept(request, LoadBalancersDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListHealthCheck() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", HealthChecksDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("healthChecks.json"));
server.enqueue(response);
server.start();
LoadBalancerDto loadBalancer = new LoadBalancerDto();
RESTLink link =
new RESTLink("healthchecks",
"/cloud/locations/1/devices/1/loadbalancers/1/healthchecks");
link.setType(HealthChecksDto.SHORT_MEDIA_TYPE_JSON);
loadBalancer.addLink(link);
newApiClient().getCloudApi().listHealthChecks(loadBalancer);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/locations/1/devices/1/loadbalancers/1/healthchecks");
assertAccept(request, HealthChecksDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListRoutingRules() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", HealthChecksDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("routingRules.json"));
server.enqueue(response);
server.start();
LoadBalancerDto loadBalancer = new LoadBalancerDto();
RESTLink link =
new RESTLink("routingrules",
"/cloud/locations/1/devices/1/loadbalancers/1/routingrules");
link.setType(RoutingRulesDto.SHORT_MEDIA_TYPE_JSON);
loadBalancer.addLink(link);
newApiClient().getCloudApi().listRoutingRules(loadBalancer);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/locations/1/devices/1/loadbalancers/1/routingrules");
assertAccept(request, RoutingRulesDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListAllowedDatacenters() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", DatacentersDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("dcs.json"));
server.enqueue(response);
server.start();
newApiClient().getCloudApi().listAllowedDatacenters();
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", ApiPath.LOCATIONS_URL);
assertAccept(request, DatacentersDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListAllowedDatacentersWithOptions() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", DatacentersDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("dcs.json"));
server.enqueue(response);
server.start();
AllowedDatacenterListOptions opts =
AllowedDatacenterListOptions.builder().limit(0).has("foo").idEnterprise(1)
.inScope(true).allEnterprises(true).build();
newApiClient().getCloudApi().listAllowedDatacenters(opts);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", ApiPath.LOCATIONS_URL
+ "?allEnterprises=true&has=foo&idEnterprise=1&inscope=true&limit=0");
assertAccept(request, DatacentersDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListAllowedPublicCloudRegions() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", PublicCloudRegionsDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("pcrs.json"));
server.enqueue(response);
server.start();
newApiClient().getCloudApi().listAllowedPublicCloudRegions();
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", ApiPath.LOCATIONS_URL);
assertAccept(request, PublicCloudRegionsDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListAllowedPublicCloudRegionsWithOptions() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", PublicCloudRegionsDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("pcrs.json"));
server.enqueue(response);
server.start();
AllowedPublicCloudRegionListOptions opts =
AllowedPublicCloudRegionListOptions.builder().has("foo").limit(0).inScope(true)
.idEnterprise(1).provider("AMAZON").allEnterprises(true).build();
newApiClient().getCloudApi().listAllowedPublicCloudRegions(opts);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", ApiPath.LOCATIONS_URL
+ "?allEnterprises=true&has=foo&idEnterprise=1&inscope=true&limit=0&provider=AMAZON");
assertAccept(request, PublicCloudRegionsDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListVirtualDatacenters() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualDatacentersDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vdcs.json"));
server.enqueue(response);
server.start();
newApiClient().getCloudApi().listVirtualDatacenters();
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/virtualdatacenters");
assertAccept(request, VirtualDatacentersDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListVirtualDatacentersWithOptions() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualDatacentersDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vdcs.json"));
server.enqueue(response);
server.start();
newApiClient().getCloudApi().listVirtualDatacenters(
VirtualDatacenterListOptions.builder().has("foo bar*").limit(0).datacenterId(2)
.enterpriseId(4).build());
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET",
"/cloud/virtualdatacenters?datacenter=2&enterprise=4&has=foo%20bar%2A&limit=0");
assertAccept(request, VirtualDatacentersDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListVirtualMachines() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualMachinesDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vms.json"));
server.enqueue(response);
server.start();
VirtualApplianceDto vapp = new VirtualApplianceDto();
RESTLink link =
new RESTLink("virtualmachines",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines");
link.setType(VirtualMachinesDto.SHORT_MEDIA_TYPE_JSON);
vapp.addLink(link);
newApiClient().getCloudApi().listVirtualMachines(vapp);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines");
assertAccept(request, VirtualMachinesDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListVirtualMachinesWithOptions() throws Exception
{
MockResponse response = new MockResponse() //
.setHeader("Content-Type", VirtualMachinesDto.SHORT_MEDIA_TYPE_JSON) //
.setBody(payloadFromResource("vms.json"));
server.enqueue(response);
server.start();
VirtualApplianceDto vapp = new VirtualApplianceDto();
RESTLink link =
new RESTLink("virtualmachines",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines");
link.setType(VirtualMachinesDto.SHORT_MEDIA_TYPE_JSON);
vapp.addLink(link);
newApiClient().getCloudApi().listVirtualMachines(vapp,
VirtualMachineListOptions.builder().limit(0).key("foo").build());
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET",
"/cloud/virtualdatacenters/1/virtualappliances/1/virtualmachines?key=foo&limit=0");
assertAccept(request, VirtualMachinesDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
public void testListTiersfromVDC() throws Exception
{
MockResponse response =
new MockResponse().setHeader("Content-Type", TiersDto.SHORT_MEDIA_TYPE_JSON).setBody(
payloadFromResource("tiersVDC.json"));
server.enqueue(response);
server.start();
VirtualDatacenterDto dto = new VirtualDatacenterDto();
RESTLink link = new RESTLink("tiers", "/cloud/virtualdatacenters/1/tiers");
link.setType(TiersDto.SHORT_MEDIA_TYPE_JSON);
dto.addLink(link);
newApiClient().getCloudApi().listTiers(dto);
RecordedRequest request = server.takeRequest();
assertRequest(request, "GET", "/cloud/virtualdatacenters/1/tiers");
assertAccept(request, TiersDto.SHORT_MEDIA_TYPE_JSON,
SingleResourceTransportDto.API_VERSION);
}
}