http://git-wip-us.apache.org/repos/asf/stratos/blob/b45ae00e/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/FloatingIPApiMockTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/FloatingIPApiMockTest.java b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/FloatingIPApiMockTest.java new file mode 100644 index 0000000..c28b1c8 --- /dev/null +++ b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/FloatingIPApiMockTest.java @@ -0,0 +1,436 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.jclouds.openstack.neutron.v2.extensions; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertNull; +import static org.testng.Assert.assertTrue; + +import java.io.IOException; +import java.net.URISyntaxException; +import java.util.List; + +import org.jclouds.openstack.neutron.v2.NeutronApi; +import org.jclouds.openstack.neutron.v2.domain.FloatingIP; +import org.jclouds.openstack.neutron.v2.domain.FloatingIPs; +import org.jclouds.openstack.neutron.v2.internal.BaseNeutronApiMockTest; +import org.jclouds.openstack.v2_0.options.PaginationOptions; +import org.jclouds.rest.ResourceNotFoundException; +import org.testng.annotations.Test; + +import com.squareup.okhttp.mockwebserver.MockResponse; +import com.squareup.okhttp.mockwebserver.MockWebServer; + +/** + * Tests Floating Api Guice wiring and parsing + * + */ +@Test +public class FloatingIPApiMockTest extends BaseNeutronApiMockTest { + + public void testCreateFloatingIP() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/floatingip_create_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIP.CreateFloatingIP createFip = FloatingIP.createBuilder("376da547-b977-4cfe-9cba-275c80debf57") + .portId("ce705c24-c1ef-408a-bda3-7bbd946164ab") + .build(); + + FloatingIP floatingIP = api.create(createFip); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "POST", "/v2.0/floatingips", "/floatingip_create_request.json"); + + /* + * Check response + */ + assertNotNull(floatingIP); + assertEquals(floatingIP.getRouterId(), "d23abc8d-2991-4a55-ba98-2aaea84cc72f"); + assertEquals(floatingIP.getTenantId(), "4969c491a3c74ee4af974e6d800c62de"); + assertEquals(floatingIP.getFloatingNetworkId(), "376da547-b977-4cfe-9cba-275c80debf57"); + assertEquals(floatingIP.getFixedIpAddress(), "10.0.0.3"); + assertEquals(floatingIP.getFloatingIpAddress(), "172.24.4.228"); + assertEquals(floatingIP.getPortId(), "ce705c24-c1ef-408a-bda3-7bbd946164ab"); + assertEquals(floatingIP.getId(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7"); + + } finally { + server.shutdown(); + } + } + + @Test(expectedExceptions = ResourceNotFoundException.class) + public void testCreateFloatingIPFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIP.CreateFloatingIP createFip = FloatingIP.createBuilder("376da547-b977-4cfe-9cba-275c80debf57") + .portId("ce705c24-c1ef-408a-bda3-7bbd946164ab") + .build(); + + FloatingIP floatingIP = api.create(createFip); + } finally { + server.shutdown(); + } + } + + public void testListSpecificPageFloatingIP() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/floatingip_list_response_paged1.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIPs floatingIPs = api.list(PaginationOptions.Builder.limit(2).marker("abcdefg")); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/floatingips?limit=2&marker=abcdefg"); + + /* + * Check response + */ + assertNotNull(floatingIPs); + assertEquals(floatingIPs.size(), 2); + assertEquals(floatingIPs.first().get().getId(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7"); + assertEquals(floatingIPs.get(1).getId(), "61cea855-49cb-4846-997d-801b70c71bdd"); + } finally { + server.shutdown(); + } + } + + public void testListSpecificPageFloatingIPFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIPs floatingIPs = api.list(PaginationOptions.Builder.limit(2).marker("abcdefg")); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/floatingips?limit=2&marker=abcdefg"); + + /* + * Check response + */ + assertNotNull(floatingIPs); + assertTrue(floatingIPs.isEmpty()); + } finally { + server.shutdown(); + } + } + + public void testListPagedFloatingIP() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/floatingip_list_response_paged1.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/floatingip_list_response_paged2.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + // Note: Lazy! Have to actually look at the collection. + List<FloatingIP> floatingIPs = api.list().concat().toList(); + + /* + * Check request + */ + assertEquals(server.getRequestCount(), 3); + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/floatingips"); + assertRequest(server.takeRequest(), "GET", "/v2.0/floatingips?marker=71c1e68c-171a-4aa2-aca5-50ea153a3718"); + + /* + * Check response + */ + assertNotNull(floatingIPs); + assertEquals(floatingIPs.size(), 4); + assertEquals(floatingIPs.get(0).getId(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7"); + assertEquals(floatingIPs.get(3).getId(), "61cea855-49cb-4846-997d-801b70c71bdd2"); + } finally { + server.shutdown(); + } + } + + public void testListPagedFloatingIPFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + // Note: Lazy! Have to actually look at the collection. + List<FloatingIP> floatingIPs = api.list().concat().toList(); + + /* + * Check request + */ + assertEquals(server.getRequestCount(), 2); + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/floatingips"); + + /* + * Check response + */ + assertNotNull(floatingIPs); + assertTrue(floatingIPs.isEmpty()); + } finally { + server.shutdown(); + } + } + + public void testGetFloatingIP() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/floatingip_get_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIP floatingIP = api.get("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/floatingips/12345"); + + /* + * Check response + */ + assertNotNull(floatingIP); + assertEquals(floatingIP.getId(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7"); + assertEquals(floatingIP.getPortId(), "ce705c24-c1ef-408a-bda3-7bbd946164ab"); + assertEquals(floatingIP.getFloatingIpAddress(), "172.24.4.228"); + assertEquals(floatingIP.getFixedIpAddress(), "10.0.0.3"); + assertEquals(floatingIP.getFloatingNetworkId(), "376da547-b977-4cfe-9cba-275c80debf57"); + assertEquals(floatingIP.getRouterId(), "d23abc8d-2991-4a55-ba98-2aaea84cc72f"); + assertEquals(floatingIP.getTenantId(), "4969c491a3c74ee4af974e6d800c62de"); + + } finally { + server.shutdown(); + } + } + + public void testGetFloatingIPFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIP floatingIP = api.get("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/floatingips/12345"); + + /* + * Check response + */ + assertNull(floatingIP); + + } finally { + server.shutdown(); + } + } + + public void testUpdateFloatingIP() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/floatingip_update_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIP.UpdateFloatingIP updateFloatingIP = FloatingIP.updateBuilder() + .portId("fc861431-0e6c-4842-a0ed-e2363f9bc3a8") + .build(); + + FloatingIP floatingIP = api.update("12345", updateFloatingIP); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/floatingips/12345", "/floatingip_update_request.json"); + + /* + * Check response + */ + assertNotNull(floatingIP); + assertEquals(floatingIP.getPortId(), "fc861431-0e6c-4842-a0ed-e2363f9bc3a8"); + + } finally { + server.shutdown(); + } + } + + public void testUpdateFloatingIPDissociate() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/floatingip_update_dissociate_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIP.UpdateFloatingIP updateFloatingIP = FloatingIP.updateBuilder().build(); + + FloatingIP floatingIP = api.update("12345", updateFloatingIP); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/floatingips/12345", "/floatingip_update_dissociate_request.json"); + + /* + * Check response + */ + assertNotNull(floatingIP); + assertNull(floatingIP.getPortId()); + + } finally { + server.shutdown(); + } + } + + public void testUpdateFloatingIPFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + FloatingIP.UpdateFloatingIP updateFloatingIP = FloatingIP.updateBuilder() + .portId("fc861431-0e6c-4842-a0ed-e2363f9bc3a8") + .build(); + + FloatingIP floatingIP = api.update("12345", updateFloatingIP); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/floatingips/12345", "/floatingip_update_request.json"); + + /* + * Check response + */ + assertNull(floatingIP); + } finally { + server.shutdown(); + } + } + + public void testDeleteFloatingIP() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + boolean result = api.delete("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "DELETE", "/v2.0/floatingips/12345"); + + /* + * Check response + */ + assertTrue(result); + } finally { + server.shutdown(); + } + } + + public void testDeleteFloatingIPFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + FloatingIPApi api = neutronApi.getFloatingIPApi("RegionOne").get(); + + boolean result = api.delete("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "DELETE", "/v2.0/floatingips/12345"); + + /* + * Check response + */ + assertFalse(result); + } finally { + server.shutdown(); + } + } +}
http://git-wip-us.apache.org/repos/asf/stratos/blob/b45ae00e/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/RouterApiLiveTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/RouterApiLiveTest.java b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/RouterApiLiveTest.java new file mode 100644 index 0000000..2a006e8 --- /dev/null +++ b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/RouterApiLiveTest.java @@ -0,0 +1,173 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.jclouds.openstack.neutron.v2.extensions; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertTrue; + +import java.util.Set; + +import org.jclouds.openstack.neutron.v2.domain.ExternalGatewayInfo; +import org.jclouds.openstack.neutron.v2.domain.Network; +import org.jclouds.openstack.neutron.v2.domain.NetworkType; +import org.jclouds.openstack.neutron.v2.domain.Port; +import org.jclouds.openstack.neutron.v2.domain.Router; +import org.jclouds.openstack.neutron.v2.domain.RouterInterface; +import org.jclouds.openstack.neutron.v2.domain.Subnet; +import org.jclouds.openstack.neutron.v2.features.NetworkApi; +import org.jclouds.openstack.neutron.v2.features.PortApi; +import org.jclouds.openstack.neutron.v2.features.SubnetApi; +import org.jclouds.openstack.neutron.v2.internal.BaseNeutronApiLiveTest; +import org.testng.annotations.Test; + +/** + * Tests parsing and Guice wiring of RouterApi + */ +@Test(groups = "live", testName = "RouterApiLiveTest") +public class RouterApiLiveTest extends BaseNeutronApiLiveTest { + + public void testCreateUpdateAndDeleteRouter() { + for (String region : api.getConfiguredRegions()) { + RouterApi routerApi = api.getRouterApi(region).get(); + NetworkApi networkApi = api.getNetworkApi(region); + SubnetApi subnetApi = api.getSubnetApi(region); + + Network network = networkApi.create( + Network.createBuilder("jclouds-network-test").external(true).networkType(NetworkType.LOCAL).build()); + assertNotNull(network); + + Subnet subnet = subnetApi.create(Subnet.createBuilder(network.getId(), "192.168.0.0/16").ipVersion(4).build()); + assertNotNull(subnet); + + Router router = routerApi.create(Router.createBuilder().name("jclouds-router-test") + .externalGatewayInfo(ExternalGatewayInfo.builder().networkId(network.getId()).build()).build()); + assertNotNull(router); + + /* List and Get test */ + Set<Router> routers = api.getRouterApi(region).get().list().concat().toSet(); + Router routerList = routers.iterator().next(); + Router routerGet = api.getRouterApi(region).get().get(routerList.getId()); + + assertNotNull(routerGet); + assertEquals(routerGet, routerList); + /***/ + + routerGet = routerApi.get(router.getId()); + + assertEquals(routerGet.getName(), router.getName()); + assertEquals(routerGet.getId(), router.getId()); + assertEquals(routerGet.getExternalGatewayInfo(), router.getExternalGatewayInfo()); + + Router routerUpdate = routerApi.update(router.getId(), Router.updateBuilder().name("jclouds-router-test-rename").build()); + assertNotNull(routerUpdate); + assertEquals(routerUpdate.getName(), "jclouds-router-test-rename"); + + routerGet = routerApi.get(router.getId()); + + assertEquals(routerGet.getId(), router.getId()); + assertEquals(routerGet.getName(), "jclouds-router-test-rename"); + + assertTrue(routerApi.delete(router.getId())); + assertTrue(subnetApi.delete(subnet.getId())); + assertTrue(networkApi.delete(network.getId())); + } + } + + public void testCreateAndDeleteRouterInterfaceForSubnet() { + for (String region : api.getConfiguredRegions()) { + RouterApi routerApi = api.getRouterApi(region).get(); + NetworkApi networkApi = api.getNetworkApi(region); + SubnetApi subnetApi = api.getSubnetApi(region); + + Network network = networkApi.create(Network.createBuilder("jclouds-network-test").external(true).networkType(NetworkType.LOCAL).build()); + assertNotNull(network); + + Subnet subnet = subnetApi.create(Subnet.createBuilder(network.getId(), "192.168.0.0/16").ipVersion(4).build()); + assertNotNull(subnet); + + Network network2 = networkApi.create(Network.createBuilder("jclouds-network-test2").external(true).networkType(NetworkType.LOCAL).build()); + assertNotNull(network2); + + Subnet subnet2 = subnetApi.create(Subnet.createBuilder(network2.getId(), "192.169.0.0/16").ipVersion(4).build()); + assertNotNull(subnet2); + + Router router = routerApi.create(Router.createBuilder().name("jclouds-router-test").build()); + assertNotNull(router); + + RouterInterface routerInterface = routerApi.addInterfaceForSubnet(router.getId(), subnet.getId()); + assertNotNull(routerInterface); + + RouterInterface routerInterface2 = routerApi.addInterfaceForSubnet(router.getId(), subnet2.getId()); + assertNotNull(routerInterface2); + + assertTrue(routerApi.removeInterfaceForSubnet(router.getId(), subnet.getId())); + assertTrue(routerApi.removeInterfaceForSubnet(router.getId(), subnet2.getId())); + assertTrue(routerApi.delete(router.getId())); + assertTrue(subnetApi.delete(subnet.getId())); + assertTrue(networkApi.delete(network.getId())); + assertTrue(subnetApi.delete(subnet2.getId())); + assertTrue(networkApi.delete(network2.getId())); + } + } + + public void testCreateAndDeleteRouterInterfaceForPort() { + for (String region : api.getConfiguredRegions()) { + RouterApi routerApi = api.getRouterApi(region).get(); + NetworkApi networkApi = api.getNetworkApi(region); + SubnetApi subnetApi = api.getSubnetApi(region); + PortApi portApi = api.getPortApi(region); + + Network network = networkApi.create(Network.createBuilder("jclouds-network-test").external(true).networkType(NetworkType.LOCAL).build()); + assertNotNull(network); + + Subnet subnet = subnetApi.create(Subnet.createBuilder(network.getId(), "192.168.0.0/16").ipVersion(4).build()); + assertNotNull(subnet); + + Network network2 = networkApi.create(Network.createBuilder("jclouds-network-test2").external(true).networkType(NetworkType.LOCAL).build()); + assertNotNull(network2); + + Subnet subnet2 = subnetApi.create(Subnet.createBuilder(network2.getId(), "192.169.0.0/16").ipVersion(4).build()); + assertNotNull(subnet2); + + Port port = portApi.create(Port.createBuilder(network.getId()).build()); + assertNotNull(port); + + Port port2 = portApi.create(Port.createBuilder(network2.getId()).build()); + assertNotNull(port2); + + Router router = routerApi.create(Router.createBuilder().name("jclouds-router-test").build()); + assertNotNull(router); + + RouterInterface routerInterface = routerApi.addInterfaceForPort(router.getId(), port.getId()); + assertNotNull(routerInterface); + + RouterInterface routerInterface2 = routerApi.addInterfaceForPort(router.getId(), port2.getId()); + assertNotNull(routerInterface2); + + assertTrue(routerApi.removeInterfaceForPort(router.getId(), port.getId())); + assertTrue(routerApi.removeInterfaceForPort(router.getId(), port2.getId())); + assertTrue(routerApi.delete(router.getId())); + assertTrue(subnetApi.delete(subnet.getId())); + assertTrue(networkApi.delete(network.getId())); + assertTrue(subnetApi.delete(subnet2.getId())); + assertTrue(networkApi.delete(network2.getId())); + } + } + +} http://git-wip-us.apache.org/repos/asf/stratos/blob/b45ae00e/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/RouterApiMockTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/RouterApiMockTest.java b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/RouterApiMockTest.java new file mode 100644 index 0000000..00232f8 --- /dev/null +++ b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/RouterApiMockTest.java @@ -0,0 +1,631 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.jclouds.openstack.neutron.v2.extensions; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertNull; +import static org.testng.Assert.assertTrue; +import static org.testng.Assert.fail; + +import java.io.IOException; +import java.net.URISyntaxException; +import java.util.List; + +import org.jclouds.openstack.neutron.v2.NeutronApi; +import org.jclouds.openstack.neutron.v2.domain.ExternalGatewayInfo; +import org.jclouds.openstack.neutron.v2.domain.NetworkStatus; +import org.jclouds.openstack.neutron.v2.domain.Router; +import org.jclouds.openstack.neutron.v2.domain.RouterInterface; +import org.jclouds.openstack.neutron.v2.domain.Routers; +import org.jclouds.openstack.neutron.v2.internal.BaseNeutronApiMockTest; +import org.jclouds.openstack.v2_0.options.PaginationOptions; +import org.jclouds.rest.ResourceNotFoundException; +import org.testng.annotations.Test; + +import com.squareup.okhttp.mockwebserver.MockResponse; +import com.squareup.okhttp.mockwebserver.MockWebServer; + +/** + * Tests NetworkApi Guice wiring and parsing + * + */ +@Test +public class RouterApiMockTest extends BaseNeutronApiMockTest { + + public void testCreateRouter() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/router_create_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + Router.CreateRouter createRouter = Router.createBuilder().name("another_router").adminStateUp(Boolean.TRUE) + .externalGatewayInfo(ExternalGatewayInfo.builder().networkId("8ca37218-28ff-41cb-9b10-039601ea7e6b").build()) + .build(); + + Router router = api.create(createRouter); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "POST", "/v2.0/routers", "/router_create_request.json"); + + /* + * Check response + */ + assertNotNull(router); + assertEquals(router.getName(), "another_router"); + assertEquals(router.getExternalGatewayInfo().getNetworkId(), "8ca37218-28ff-41cb-9b10-039601ea7e6b"); + assertEquals(router.getStatus(), NetworkStatus.ACTIVE); + assertEquals(router.getAdminStateUp(), Boolean.TRUE); + assertEquals(router.getId(), "8604a0de-7f6b-409a-a47c-a1cc7bc77b2e"); + assertEquals(router.getTenantId(), "6b96ff0cb17a4b859e1e575d221683d3"); + } finally { + server.shutdown(); + } + } + + @Test(expectedExceptions = ResourceNotFoundException.class) + public void testCreateRouterFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + Router.CreateRouter createRouter = Router.createBuilder().name("another_router").adminStateUp(Boolean.TRUE) + .externalGatewayInfo(ExternalGatewayInfo.builder().networkId("8ca37218-28ff-41cb-9b10-039601ea7e6b").build()) + .build(); + + api.create(createRouter); + fail("Should have failed with not found exception"); + + } finally { + server.shutdown(); + } + } + + public void testListSpecificPageRouter() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/router_list_response_paged1.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + Routers routers = api.list(PaginationOptions.Builder.limit(2).marker("abcdefg")); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/routers?limit=2&marker=abcdefg"); + + /* + * Check response + */ + assertNotNull(routers); + assertEquals(routers.size(), 2); + assertEquals(routers.first().get().getId(), "a9254bdb-2613-4a13-ac4c-adc581fba50d"); + } finally { + server.shutdown(); + } + } + + public void testListSpecificPageRouterFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + Routers routers = api.list(PaginationOptions.Builder.limit(2).marker("abcdefg")); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/routers?limit=2&marker=abcdefg"); + + /* + * Check response + */ + assertNotNull(routers); + assertTrue(routers.isEmpty()); + } finally { + server.shutdown(); + } + } + + public void testListPagedRouter() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/router_list_response_paged1.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/router_list_response_paged2.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + // Note: Lazy! Have to actually look at the collection. + List<Router> routers = api.list().concat().toList(); + + /* + * Check request + */ + assertEquals(server.getRequestCount(), 3); + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/routers"); + assertRequest(server.takeRequest(), "GET", "/v2.0/routers?marker=71c1e68c-171a-4aa2-aca5-50ea153a3718"); + + /* + * Check response + */ + assertNotNull(routers); + assertEquals(routers.size(), 4); + assertEquals(routers.get(0).getId(), "a9254bdb-2613-4a13-ac4c-adc581fba50d"); + assertEquals(routers.get(3).getId(), "a9254bdb-2613-4a13-ac4c-adc581fba50d_4"); + } finally { + server.shutdown(); + } + } + + public void testListPagedRouterFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + // Note: Lazy! Have to actually look at the collection. + List<Router> routers = api.list().concat().toList(); + + /* + * Check request + */ + assertEquals(server.getRequestCount(), 2); + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/routers"); + + /* + * Check response + */ + assertNotNull(routers); + assertTrue(routers.isEmpty()); + } finally { + server.shutdown(); + } + } + + public void testGetRouter() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/router_get_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + Router router = api.get("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/routers/12345"); + + /* + * Check response + */ + assertNotNull(router); + assertEquals(router.getName(), "router1"); + assertEquals(router.getExternalGatewayInfo().getNetworkId(), "3c5bcddd-6af9-4e6b-9c3e-c153e521cab8"); + assertEquals(router.getStatus(), NetworkStatus.ACTIVE); + assertEquals(router.getAdminStateUp(), Boolean.TRUE); + assertEquals(router.getId(), "a9254bdb-2613-4a13-ac4c-adc581fba50d"); + assertEquals(router.getTenantId(), "33a40233088643acb66ff6eb0ebea679"); + } finally { + server.shutdown(); + } + } + + public void testGetRouterFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + Router router = api.get("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/routers/12345"); + + /* + * Check response + */ + assertNull(router); + } finally { + server.shutdown(); + } + } + + public void testUpdateRouter() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/router_update_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + Router.UpdateRouter updateRouter = Router.updateBuilder() + .externalGatewayInfo( + ExternalGatewayInfo.builder().networkId("8ca37218-28ff-41cb-9b10-039601ea7e6b").build()) + .build(); + + Router router = api.update("12345", updateRouter); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345", "/router_update_request.json"); + + /* + * Check response + */ + assertNotNull(router); + assertEquals(router.getName(), "another_router"); + assertEquals(router.getExternalGatewayInfo().getNetworkId(), "8ca37218-28ff-41cb-9b10-039601ea7e6b"); + assertEquals(router.getStatus(), NetworkStatus.ACTIVE); + assertEquals(router.getAdminStateUp(), Boolean.TRUE); + assertEquals(router.getId(), "8604a0de-7f6b-409a-a47c-a1cc7bc77b2e"); + assertEquals(router.getTenantId(), "6b96ff0cb17a4b859e1e575d221683d3"); + } finally { + server.shutdown(); + } + } + + public void testUpdateRouterFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + Router.UpdateRouter updateRouter = Router.updateBuilder() + .externalGatewayInfo( + ExternalGatewayInfo.builder().networkId("8ca37218-28ff-41cb-9b10-039601ea7e6b").build()) + .build(); + + Router router = api.update("12345", updateRouter); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345", "/router_update_request.json"); + + /* + * Check response + */ + assertNull(router); + } finally { + server.shutdown(); + } + } + + public void testDeleteRouter() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + boolean result = api.delete("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "DELETE", "/v2.0/routers/12345"); + + /* + * Check response + */ + assertTrue(result); + } finally { + server.shutdown(); + } + } + + public void testDeleteRouterFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + boolean result = api.delete("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "DELETE", "/v2.0/routers/12345"); + + /* + * Check response + */ + assertFalse(result); + } finally { + server.shutdown(); + } + } + + public void testAddRouterInterfaceForSubnet() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/router_add_interface_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + RouterInterface routerInterface = api.addInterfaceForSubnet("12345", "a2f1f29d-571b-4533-907f-5803ab96ead1"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345/add_router_interface", "/router_add_interface_request.json"); + + /* + * Check response + */ + assertNotNull(routerInterface); + assertEquals(routerInterface.getSubnetId(), "a2f1f29d-571b-4533-907f-5803ab96ead1"); + assertEquals(routerInterface.getPortId(), "3a44f4e5-1694-493a-a1fb-393881c673a4"); + } finally { + server.shutdown(); + } + } + + public void testAddRouterInterfaceForSubnetFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + RouterInterface routerInterface = api.addInterfaceForSubnet("12345", "a2f1f29d-571b-4533-907f-5803ab96ead1"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345/add_router_interface", "/router_add_interface_request.json"); + + /* + * Check response + */ + assertNull(routerInterface); + } finally { + server.shutdown(); + } + } + + public void testAddRouterInterfaceForPort() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/router_add_interface_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + RouterInterface routerInterface = api.addInterfaceForPort("12345", "portid"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345/add_router_interface", "/router_add_interface_port_request.json"); + + /* + * Check response + */ + assertNotNull(routerInterface); + assertEquals(routerInterface.getSubnetId(), "a2f1f29d-571b-4533-907f-5803ab96ead1"); + assertEquals(routerInterface.getPortId(), "3a44f4e5-1694-493a-a1fb-393881c673a4"); + } finally { + server.shutdown(); + } + } + + public void testAddRouterInterfaceForPortFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + RouterInterface routerInterface = api.addInterfaceForPort("12345", "portid"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345/add_router_interface", "/router_add_interface_port_request.json"); + + /* + * Check response + */ + assertNull(routerInterface); + } finally { + server.shutdown(); + } + } + + public void testRemoveRouterInterfaceForSubnet() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + boolean result = api.removeInterfaceForSubnet("12345", "a2f1f29d-571b-4533-907f-5803ab96ead1"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345/remove_router_interface", "/router_remove_interface_subnet_request.json"); + + /* + * Check response + */ + assertTrue(result); + } finally { + server.shutdown(); + } + } + + public void testRemoveRouterInterfaceForSubnetFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + boolean result = api.removeInterfaceForSubnet("12345", "a2f1f29d-571b-4533-907f-5803ab96ead1"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345/remove_router_interface", "/router_remove_interface_subnet_request.json"); + + /* + * Check response + */ + assertFalse(result); + } finally { + server.shutdown(); + } + } + + public void testRemoveRouterInterfaceForPort() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + boolean result = api.removeInterfaceForPort("12345", "portid"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345/remove_router_interface", "/router_remove_interface_port_request.json"); + + /* + * Check response + */ + assertTrue(result); + } finally { + server.shutdown(); + } + } + + public void testRemoveRouterInterfaceForPortFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + RouterApi api = neutronApi.getRouterApi("RegionOne").get(); + + boolean result = api.removeInterfaceForPort("12345", "portid"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "PUT", "/v2.0/routers/12345/remove_router_interface", "/router_remove_interface_port_request.json"); + + /* + * Check response + */ + assertFalse(result); + } finally { + server.shutdown(); + } + } +} http://git-wip-us.apache.org/repos/asf/stratos/blob/b45ae00e/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/SecurityGroupApiLiveTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/SecurityGroupApiLiveTest.java b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/SecurityGroupApiLiveTest.java new file mode 100644 index 0000000..a7ef1a6 --- /dev/null +++ b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/SecurityGroupApiLiveTest.java @@ -0,0 +1,99 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.jclouds.openstack.neutron.v2.extensions; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertTrue; + +import org.jclouds.openstack.neutron.v2.domain.Rule; +import org.jclouds.openstack.neutron.v2.domain.RuleDirection; +import org.jclouds.openstack.neutron.v2.domain.RuleEthertype; +import org.jclouds.openstack.neutron.v2.domain.RuleProtocol; +import org.jclouds.openstack.neutron.v2.domain.SecurityGroup; +import org.jclouds.openstack.neutron.v2.internal.BaseNeutronApiLiveTest; +import org.testng.annotations.Test; + +/** + * Tests parsing and Guice wiring of RouterApi + */ +@Test(groups = "live", testName = "SecurityGroupApiLiveTest") +public class SecurityGroupApiLiveTest extends BaseNeutronApiLiveTest { + + /** + * Smoke test for the Security Group extension for Neutron + */ + public void testCreateUpdateAndDeleteSecurityGroup() { + for (String region : api.getConfiguredRegions()) { + SecurityGroupApi sgApi = null; + Rule rule = null; + SecurityGroup securityGroup = null; + + try { + sgApi = api.getSecurityGroupApi(region).get(); + + securityGroup = sgApi.create( + SecurityGroup.createBuilder().name("jclouds-test").description("jclouds test security group") + .build()); + assertNotNull(securityGroup); + + rule = sgApi.create( + Rule.createBuilder(RuleDirection.EGRESS, securityGroup.getId()) + .ethertype(RuleEthertype.IPV6) + .portRangeMax(90) + .portRangeMin(80) + .protocol(RuleProtocol.TCP) + .build()); + + assertNotNull(rule); + + // Refresh + securityGroup = sgApi.getSecurityGroup(securityGroup.getId()); + + assertEquals(securityGroup.getName(), "jclouds-test"); + assertEquals(securityGroup.getDescription(), "jclouds test security group"); + + assertEquals(securityGroup.getRules().size(), 3); + + Rule newSecGroupRule = null; + + for (Rule sgr : securityGroup.getRules()) { + if (sgr.getId().equals(rule.getId())) { + newSecGroupRule = sgr; + break; + } + } + assertNotNull(newSecGroupRule, "Did not find the new rule in the group."); + + assertEquals(rule, newSecGroupRule); + + assertEquals(rule.getEthertype(), RuleEthertype.IPV6); + assertEquals(rule.getProtocol(), RuleProtocol.TCP); + assertEquals(rule.getPortRangeMax().intValue(), 90); + assertEquals(rule.getPortRangeMin().intValue(), 80); + assertEquals(rule.getDirection(), RuleDirection.EGRESS); + } finally { + try { + assertTrue(sgApi.deleteRule(rule.getId())); + } finally { + assertTrue(sgApi.deleteSecurityGroup(securityGroup.getId())); + } + } + } + } +} http://git-wip-us.apache.org/repos/asf/stratos/blob/b45ae00e/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/SecurityGroupApiMockTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/SecurityGroupApiMockTest.java b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/SecurityGroupApiMockTest.java new file mode 100644 index 0000000..dfe6a80 --- /dev/null +++ b/dependencies/jclouds/apis/openstack-neutron/1.8.1-stratos/src/test/java/org/jclouds/openstack/neutron/v2/extensions/SecurityGroupApiMockTest.java @@ -0,0 +1,659 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.jclouds.openstack.neutron.v2.extensions; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertNull; +import static org.testng.Assert.assertTrue; + +import java.io.IOException; +import java.net.URISyntaxException; +import java.util.List; + +import org.jclouds.openstack.neutron.v2.NeutronApi; +import org.jclouds.openstack.neutron.v2.domain.Rule; +import org.jclouds.openstack.neutron.v2.domain.RuleDirection; +import org.jclouds.openstack.neutron.v2.domain.RuleEthertype; +import org.jclouds.openstack.neutron.v2.domain.RuleProtocol; +import org.jclouds.openstack.neutron.v2.domain.Rules; +import org.jclouds.openstack.neutron.v2.domain.SecurityGroup; +import org.jclouds.openstack.neutron.v2.domain.SecurityGroups; +import org.jclouds.openstack.neutron.v2.internal.BaseNeutronApiMockTest; +import org.jclouds.openstack.v2_0.options.PaginationOptions; +import org.jclouds.rest.ResourceNotFoundException; +import org.testng.annotations.Test; + +import com.squareup.okhttp.mockwebserver.MockResponse; +import com.squareup.okhttp.mockwebserver.MockWebServer; + +/** + * Tests NetworkApi Guice wiring and parsing + * + */ +@Test +public class SecurityGroupApiMockTest extends BaseNeutronApiMockTest { + + public void testCreateSecurityGroup() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/security_group_create_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + SecurityGroup.CreateSecurityGroup createSecurityGroup = SecurityGroup.createBuilder().name("new-webservers") + .description("security group for webservers") + .build(); + + SecurityGroup securityGroup = api.create(createSecurityGroup); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "POST", "/v2.0/security-groups", "/security_group_create_request.json"); + + /* + * Check response + */ + assertNotNull(securityGroup); + assertEquals(securityGroup.getId(), "2076db17-a522-4506-91de-c6dd8e837028"); + assertEquals(securityGroup.getTenantId(), "e4f50856753b4dc6afee5fa6b9b6c550"); + assertEquals(securityGroup.getName(), "new-webservers"); + assertEquals(securityGroup.getDescription(), "security group for webservers"); + + Rule sgr0 = securityGroup.getRules().get(0); + Rule sgr1 = securityGroup.getRules().get(1); + + assertEquals(sgr0.getId(), "38ce2d8e-e8f1-48bd-83c2-d33cb9f50c3d"); + assertEquals(sgr1.getId(), "565b9502-12de-4ffd-91e9-68885cff6ae1"); + } finally { + server.shutdown(); + } + } + + @Test(expectedExceptions = ResourceNotFoundException.class) + public void testCreateSecurityGroupFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + SecurityGroup.CreateSecurityGroup createSecurityGroup = SecurityGroup.createBuilder().name("new-webservers") + .description("security group for webservers") + .build(); + + SecurityGroup securityGroup = api.create(createSecurityGroup); + } finally { + server.shutdown(); + } + } + + public void testCreateSecurityGroupRule() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/security_group_rule_create_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + Rule.CreateRule createSecurityGroupRule = Rule.createBuilder( + RuleDirection.INGRESS, "a7734e61-b545-452d-a3cd-0189cbd9747a") + .portRangeMin(80) + .portRangeMax(80) + .ethertype(RuleEthertype.IPV4) + .protocol(RuleProtocol.TCP) + .remoteGroupId("85cc3048-abc3-43cc-89b3-377341426ac5") + .build(); + + Rule rule = api.create(createSecurityGroupRule); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "POST", "/v2.0/security-group-rules", "/security_group_rule_create_request.json"); + + /* + * Check response + */ + assertNotNull(rule); + assertEquals(rule.getId(), "2bc0accf-312e-429a-956e-e4407625eb62"); + assertEquals(rule.getTenantId(), "e4f50856753b4dc6afee5fa6b9b6c550"); + assertEquals(rule.getDirection(), RuleDirection.INGRESS); + assertEquals(rule.getPortRangeMax().intValue(), 80); + assertEquals(rule.getPortRangeMin().intValue(), 80); + assertEquals(rule.getEthertype(), RuleEthertype.IPV4); + assertEquals(rule.getProtocol(), RuleProtocol.TCP); + assertEquals(rule.getRemoteGroupId(), "85cc3048-abc3-43cc-89b3-377341426ac5"); + assertEquals(rule.getSecurityGroupId(), "a7734e61-b545-452d-a3cd-0189cbd9747a"); + + } finally { + server.shutdown(); + } + } + + @Test(expectedExceptions = ResourceNotFoundException.class) + public void testCreateSecurityGroupRuleFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + Rule.CreateRule createSecurityGroupRule = Rule.createBuilder( + RuleDirection.INGRESS, "a7734e61-b545-452d-a3cd-0189cbd9747a") + .portRangeMin(80) + .portRangeMax(80) + .ethertype(RuleEthertype.IPV4) + .protocol(RuleProtocol.TCP) + .remoteGroupId("85cc3048-abc3-43cc-89b3-377341426ac5") + .build(); + + Rule rule = api.create(createSecurityGroupRule); + } finally { + server.shutdown(); + } + } + + public void testListSpecificPageSecurityGroup() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/security_group_list_response_paged1.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + SecurityGroups securityGroups = api.listSecurityGroups(PaginationOptions.Builder.limit(2).marker("abcdefg")); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-groups?limit=2&marker=abcdefg"); + + /* + * Check response + */ + assertNotNull(securityGroups); + assertEquals(securityGroups.size(), 2); + // Ensures the full collection is parsed and ordering is preserved. + assertEquals(securityGroups.first().get().getId(), "85cc3048-abc3-43cc-89b3-377341426ac5"); + assertEquals(securityGroups.get(1).getId(), "85cc3048-abc3-43cc-89b3-377341426ac52"); + } finally { + server.shutdown(); + } + } + + public void testListSpecificPageSecurityGroupFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + SecurityGroups securityGroups = api.listSecurityGroups(PaginationOptions.Builder.limit(2).marker("abcdefg")); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-groups?limit=2&marker=abcdefg"); + + /* + * Check response + */ + assertNotNull(securityGroups); + assertTrue(securityGroups.isEmpty()); + } finally { + server.shutdown(); + } + } + + public void testListSpecificPageSecurityGroupRule() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/security_group_rule_list_response_paged1.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + Rules rules = api.listRules(PaginationOptions.Builder.limit(2).marker("abcdefg")); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-group-rules?limit=2&marker=abcdefg"); + + /* + * Check response + */ + assertNotNull(rules); + assertEquals(rules.size(), 4); + // Ensures the full collection is parsed and ordering is preserved. + assertEquals(rules.first().get().getId(), "3c0e45ff-adaf-4124-b083-bf390e5482ff"); + assertEquals(rules.get(3).getId(), "f7d45c89-008e-4bab-88ad-d6811724c51c"); + } finally { + server.shutdown(); + } + } + + public void testListSpecificPageSecurityGroupRuleFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + Rules rules = api.listRules(PaginationOptions.Builder.limit(2).marker("abcdefg")); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-group-rules?limit=2&marker=abcdefg"); + + /* + * Check response + */ + assertNotNull(rules); + assertTrue(rules.isEmpty()); + } finally { + server.shutdown(); + } + } + + public void testListPagedSecurityGroups() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/security_group_list_response_paged1.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/security_group_list_response_paged2.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + // Note: Lazy! Have to actually look at the collection. + List<SecurityGroup> securityGroups = api.listSecurityGroups().concat().toList(); + + /* + * Check request + */ + assertEquals(server.getRequestCount(), 3); + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-groups"); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-groups?marker=71c1e68c-171a-4aa2-aca5-50ea153a3718"); + + /* + * Check response + */ + assertNotNull(securityGroups); + assertEquals(securityGroups.size(), 4); + // Ensures ordering is preserved and both pages are parsed. + assertEquals(securityGroups.get(0).getId(), "85cc3048-abc3-43cc-89b3-377341426ac5"); + assertEquals(securityGroups.get(3).getId(), "85cc3048-abc3-43cc-89b3-377341426ac524"); + + } finally { + server.shutdown(); + } + } + + public void testListPagedSecurityGroupsFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + // Note: Lazy! Have to actually look at the collection. + List<SecurityGroup> securityGroups = api.listSecurityGroups().concat().toList(); + + /* + * Check request + */ + assertEquals(server.getRequestCount(), 2); + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-groups"); + + /* + * Check response + */ + assertNotNull(securityGroups); + assertTrue(securityGroups.isEmpty()); + + } finally { + server.shutdown(); + } + } + + public void testListPagedSecurityGroupRules() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/security_group_rule_list_response_paged1.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(200).setBody(stringFromResource("/security_group_rule_list_response_paged2.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + // Note: Lazy! Have to actually look at the collection. + List<Rule> rules = api.listRules().concat().toList(); + + /* + * Check request + */ + assertEquals(server.getRequestCount(), 3); + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-group-rules"); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-group-rules?marker=71c1e68c-171a-4aa2-aca5-50ea153a3718"); + + /* + * Check response + */ + assertNotNull(rules); + assertEquals(rules.size(), 8); + // Ensures both pages are tested and ordering is preserved. + assertEquals(rules.get(0).getId(), "3c0e45ff-adaf-4124-b083-bf390e5482ff"); + assertEquals(rules.get(7).getId(), "f7d45c89-008e-4bab-88ad-d6811724c51c2"); + + } finally { + server.shutdown(); + } + } + + public void testListPagedSecurityGroupRulesFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders(new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + // Note: Lazy! Have to actually look at the collection. + List<Rule> rules = api.listRules().concat().toList(); + + /* + * Check request + */ + assertEquals(server.getRequestCount(), 2); + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-group-rules"); + + /* + * Check response + */ + assertNotNull(rules); + assertTrue(rules.isEmpty()); + + } finally { + server.shutdown(); + } + } + + public void testGetSecurityGroup() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/security_group_get_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + SecurityGroup securityGroup = api.getSecurityGroup("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-groups/12345"); + + /* + * Check response + */ + assertNotNull(securityGroup); + assertEquals(securityGroup.getName(), "default"); + assertEquals(securityGroup.getDescription(), "default"); + assertEquals(securityGroup.getId(), "85cc3048-abc3-43cc-89b3-377341426ac5"); + assertEquals(securityGroup.getTenantId(), "e4f50856753b4dc6afee5fa6b9b6c550"); + Rule sgr = securityGroup.getRules().get(0); + assertEquals(sgr.getId(), "3c0e45ff-adaf-4124-b083-bf390e5482ff"); + } finally { + server.shutdown(); + } + } + + public void testGetSecurityGroupFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + SecurityGroup securityGroup = api.getSecurityGroup("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-groups/12345"); + + /* + * Check response + */ + assertNull(securityGroup); + + } finally { + server.shutdown(); + } + } + + public void testGetSecurityGroupRule() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201).setBody(stringFromResource("/security_group_rule_get_response.json")))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + Rule rule = api.get("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-group-rules/12345"); + + /* + * Check response + */ + assertNotNull(rule); + assertEquals(rule.getDirection(), RuleDirection.EGRESS); + assertEquals(rule.getEthertype(), RuleEthertype.IPV6); + assertEquals(rule.getId(), "3c0e45ff-adaf-4124-b083-bf390e5482ff"); + assertEquals(rule.getTenantId(), "e4f50856753b4dc6afee5fa6b9b6c550"); + assertEquals(rule.getSecurityGroupId(), "85cc3048-abc3-43cc-89b3-377341426ac5"); + + } finally { + server.shutdown(); + } + } + + public void testGetSecurityGroupRuleFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + Rule rule = api.get("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "GET", "/v2.0/security-group-rules/12345"); + + /* + * Check response + */ + assertNull(rule); + + } finally { + server.shutdown(); + } + } + + public void testDeleteSecurityGroup() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + boolean result = api.deleteSecurityGroup("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "DELETE", "/v2.0/security-groups/12345"); + + /* + * Check response + */ + assertTrue(result); + } finally { + server.shutdown(); + } + } + + public void testDeleteSecurityGroupFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + boolean result = api.deleteSecurityGroup("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "DELETE", "/v2.0/security-groups/12345"); + + /* + * Check response + */ + assertFalse(result); + } finally { + server.shutdown(); + } + } + + public void testDeleteSecurityGroupRule() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(201))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + boolean result = api.deleteRule("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "DELETE", "/v2.0/security-group-rules/12345"); + + /* + * Check response + */ + assertTrue(result); + } finally { + server.shutdown(); + } + } + + public void testDeleteSecurityGroupRuleFail() throws IOException, InterruptedException, URISyntaxException { + MockWebServer server = mockOpenStackServer(); + server.enqueue(addCommonHeaders(new MockResponse().setBody(stringFromResource("/access.json")))); + server.enqueue(addCommonHeaders( + new MockResponse().setResponseCode(404))); + + try { + NeutronApi neutronApi = api(server.getUrl("/").toString(), "openstack-neutron", overrides); + SecurityGroupApi api = neutronApi.getSecurityGroupApi("RegionOne").get(); + + boolean result = api.deleteRule("12345"); + + /* + * Check request + */ + assertAuthentication(server); + assertRequest(server.takeRequest(), "DELETE", "/v2.0/security-group-rules/12345"); + + /* + * Check response + */ + assertFalse(result); + } finally { + server.shutdown(); + } + } +}
