http://git-wip-us.apache.org/repos/asf/stratos/blob/397d9926/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/functions/WindowsLoginCredentialsFromEncryptedDataTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/functions/WindowsLoginCredentialsFromEncryptedDataTest.java b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/functions/WindowsLoginCredentialsFromEncryptedDataTest.java new file mode 100644 index 0000000..3859f53 --- /dev/null +++ b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/functions/WindowsLoginCredentialsFromEncryptedDataTest.java @@ -0,0 +1,74 @@ +/* + * 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.ec2.compute.functions; + +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertFalse; + +import org.jclouds.date.DateService; +import org.jclouds.date.internal.SimpleDateFormatDateService; +import org.jclouds.domain.LoginCredentials; +import org.jclouds.ec2.compute.domain.PasswordDataAndPrivateKey; +import org.jclouds.ec2.domain.PasswordData; +import org.jclouds.encryption.internal.JCECrypto; +import org.testng.annotations.Test; + +public class WindowsLoginCredentialsFromEncryptedDataTest { + + private static final String PRIVATE_KEY = "-----BEGIN RSA PRIVATE KEY-----\n" + + "MIIEowIBAAKCAQEAmN6GOSMnyGNWN19ETBh11tJB5OGs3Dps8kPWqAhF9RyL/mKwkW26vH+h/5Z5\n" + + "cA5T80pK72kNnXObFaMHNoX3lavrc6yXF+8F3f1tlFX2Z+iB1pYXz1oBPqT6oOmc2XzcsJuJRakd\n" + + "zwRwHDaqljpaW7+TZlxhMa1DmUkD/HHMxDCK8jbUIZDc6BZSrnj2uPwHwW737NRE4aC3fcu4LMwf\n" + + "b2VotbNGNiAnNmrb/vtIIGkFE8NYEMpiz0WYTWX4eVKpJImv1PR6G1fMLSvudJs0ARObuLDvuonn\n" + + "SCFFdkibrwMKYbHVGGh6FoY1Vy0sqI55dgQU1kSNouiDgOGxgx+TIwIDAQABAoIBAHCS/nk5QGS7\n" + + "cpRYXa1EHhNSxx/MaUXM6MoH1x3q6cm1egqdlrWh/vAtdZkIsOkqQ/xX65Me493dcomegwNN6KOZ\n" + + "9Uw7/xCq/sEZjga8vzaJ7IOgCGy0NVJyn/a70rv+zW5pO8/G2KLI+95rC3iSBFSoYd3xjcnNdIh/\n" + + "UqYnD8oxYpKmf7418pMPsBrkglkFlbVBPiDXdpoSziqSN6uWQG4Yh0WR87aElhM9JJW50Hh6h7g5\n" + + "OvgCBzS8G+KXCjqimk108+/ed5Nl6VhPAf79yCVZUueKBhaf2r0Kkyxg7M/Y+LJwcoUusIP7Cv7G\n" + + "xyzG2vi21prWRCm2sVCUDyQy5qECgYEA92jGVAaB3OGEUIXn7eVE3U3FQH37XcJMGsHqBIzDG13p\n" + + "C97HdN21rwRkz+G2eAsIxA+p9BsO7dSmtKC60kl6iMRgltS3W7xoC37N9BtjhpciHcLg8c70oyDx\n" + + "qHiLKuDi90mZ1FPmWupO4FJnGEB3evHUKZSpTrVVMzt+tyEn/psCgYEAni1hrYoMkQgN3sEC3CKB\n" + + "0jQkrOMvY219B8Tdf9LXSuP6z9POagDBDhkeT3xn8rAOmOfVGHYdO0CvPqmAkmXhf+g+OREdecQa\n" + + "uY0FmvcTt+Dx0c6pRZmm5AhvUVXFXqONsSg79iviXbUy5Hik0k5HTs5E6B4obrh5W+xfMTUXghkC\n" + + "gYBn92uAW8uumkYT4HF6EuJBbTD6zPYYjFGW3O4OQ2ip02jfSBrhDVoP1fTXNq6K+3gPi9WLcuNv\n" + + "JfF37iMTwzTuzDcaqwDyV9YRHpRFhEzqfhAkGYSVmLZM5scmWKGCv0YhTJiMFUWz5sqGkZopIs4S\n" + + "qBTT9FjBbooDIXk6U4CPCQKBgFdVBxEhnz6UC9RpDIMuKi88yuMJrChhUx7u+ryQVH3s0ZXdg6HT\n" + + "OMPn6mxIa7v6qJSTq3wN+qW0WQ1n2Kz7wz0zpOctI/EO7RJ1YhrlP+XONLV6PMtIwnQ0lAF8MbTG\n" + + "6HxfknugTyMd4DN0yMu0nHpOOI1P2VMIVzkBkK1CevBBAoGBALROGR7a+eijHdp0/A0chfUoBmud\n" + + "/TsUt+0g/vf1p69rMt6DqEGMgMtp2jIRnwvLElS7gVqnCTEclxNU/0rCXR+V7ImJm8J4f0ff8m0Y\n" + + "Fir9nfCYStszo25NvLFfynS9d/aoBuvqGJaiQyNXiyBJ4MaxxFYagzAWTnDX+kzTlkZ2\n" + + "-----END RSA PRIVATE KEY-----"; + private static final String ENCRYPTED_PASSWORD = "gO1oMoIjjIifv2iqcfIKiQD7ziOTVXsuaBJFEQrZdb8uJH/LsAiJXZeGKEeXlHl/oMoR3HEIoYuHxl+p5iHdrpP889RmxWBDGOWC5iTUzK6CRa5mFmF1I5Lpt7v2YeVoQWihSM8B19BEdBdY1svQp9nyhPB4AqLDrY28x/OrmRh/qYq953i6Y4Z8c76OHqqGcUYM4ePysRlcizSgQjdkEDmKC10Ak3OFRRx3/LqYsFIMiOHeg47APg+UANNTyRiTIia5FDhSeHJzaeYCBRQ7UYH0z2rg4cX3YjOz/MoznjHiaaN4MO+5N3v84VawnqwKOvlwPyI2bmz0+9Tr6DKzqA=="; + + protected final DateService dateService = new SimpleDateFormatDateService(); + + @Test + public void testApply() throws Exception { + WindowsLoginCredentialsFromEncryptedData f = new WindowsLoginCredentialsFromEncryptedData(new JCECrypto()); + + PasswordData passwordData = PasswordData.builder() + .instanceId("i-2574e22a") + .timestamp(dateService.iso8601DateParse("2012-07-30T07:27:23.000+0000")) + .passwordData(ENCRYPTED_PASSWORD).build(); + + LoginCredentials credentials = f.apply(new PasswordDataAndPrivateKey(passwordData, PRIVATE_KEY)); + + assertEquals(credentials.getUser(), "Administrator"); + assertEquals(credentials.getOptionalPassword().get(), "u4.y9mb;nR."); + assertFalse(credentials.getOptionalPrivateKey().isPresent()); + } +}
http://git-wip-us.apache.org/repos/asf/stratos/blob/397d9926/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/BaseEC2ComputeServiceContextExpectTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/BaseEC2ComputeServiceContextExpectTest.java b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/BaseEC2ComputeServiceContextExpectTest.java new file mode 100644 index 0000000..cc9790b --- /dev/null +++ b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/BaseEC2ComputeServiceContextExpectTest.java @@ -0,0 +1,42 @@ +/* + * 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.ec2.compute.internal; + +import java.util.Properties; + +import org.jclouds.compute.ComputeServiceContext; +import org.jclouds.ec2.internal.BaseEC2ApiExpectTest; +import org.jclouds.http.HttpRequest; +import org.jclouds.http.HttpResponse; + +import com.google.common.base.Function; +import com.google.inject.Module; + +public abstract class BaseEC2ComputeServiceContextExpectTest<T> extends BaseEC2ApiExpectTest<T> implements + Function<ComputeServiceContext, T> { + + @Override + public T createClient(Function<HttpRequest, HttpResponse> fn, Module module, Properties props) { + return apply(createComputeServiceContext(fn, module, props)); + } + + private ComputeServiceContext createComputeServiceContext(Function<HttpRequest, HttpResponse> fn, Module module, + Properties props) { + return createInjector(fn, module, props).getInstance(ComputeServiceContext.class); + } + +} http://git-wip-us.apache.org/repos/asf/stratos/blob/397d9926/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/BaseEC2ComputeServiceExpectTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/BaseEC2ComputeServiceExpectTest.java b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/BaseEC2ComputeServiceExpectTest.java new file mode 100644 index 0000000..4178e74 --- /dev/null +++ b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/BaseEC2ComputeServiceExpectTest.java @@ -0,0 +1,296 @@ +/* + * 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.ec2.compute.internal; + +import static org.jclouds.location.reference.LocationConstants.PROPERTY_REGIONS; + +import javax.ws.rs.core.MediaType; +import java.util.Properties; + +import org.jclouds.compute.ComputeService; +import org.jclouds.compute.ComputeServiceContext; +import org.jclouds.http.HttpRequest; +import org.jclouds.http.HttpResponse; +import org.testng.annotations.BeforeClass; + +public abstract class BaseEC2ComputeServiceExpectTest extends BaseEC2ComputeServiceContextExpectTest<ComputeService> { + protected String region; + + @Override + protected Properties setupProperties() { + Properties properties = super.setupProperties(); + properties.setProperty(PROPERTY_REGIONS, region); + properties.setProperty(provider + ".template", "osDescriptionMatches=.*fedora.*"); + return properties; + } + + protected HttpRequest describeAvailabilityZonesRequest; + protected HttpResponse describeAvailabilityZonesResponse; + protected HttpRequest describeImagesRequest; + protected HttpResponse describeImagesResponse; + protected HttpRequest createKeyPairRequest; + protected HttpResponse createKeyPairResponse; + protected HttpRequest createSecurityGroupRequest; + protected HttpResponse createSecurityGroupResponse; + protected HttpRequest describeSecurityGroupRequest; + protected HttpResponse describeSecurityGroupResponse; + protected HttpRequest authorizeSecurityGroupIngressRequest22; + protected HttpResponse authorizeSecurityGroupIngressResponse; + protected HttpRequest authorizeSecurityGroupIngressRequestGroup; + protected HttpRequest runInstancesRequest; + protected HttpResponse runInstancesResponse; + protected HttpRequest runThreeInstancesRequest; + protected HttpRequest runThreeToFourInstancesRequest; + protected HttpResponse runThreeInstancesResponse; + protected HttpRequest describeInstanceRequest; + protected HttpResponse describeInstanceResponse; + protected HttpRequest describeInstanceMultiIdsRequest; + protected HttpResponse describeInstanceMultiIdsResponse; + protected HttpRequest describeInstanceThreeIdsRequest; + protected HttpResponse describeInstanceThreeIdsResponse; + protected HttpRequest describeImageRequest; + protected HttpRequest createTagsRequest; + protected HttpResponse createTagsResponse; + + public BaseEC2ComputeServiceExpectTest() { + region = "us-east-1"; + } + + @BeforeClass + @Override + protected void setupDefaultRequests() { + super.setupDefaultRequests(); + describeAvailabilityZonesRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "DescribeAvailabilityZones").build()); + + describeAvailabilityZonesResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/availabilityZones-" + region + ".xml", MediaType.APPLICATION_XML)).build(); + describeImagesRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "DescribeImages").build()); + + describeImagesResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/describe_images.xml", MediaType.APPLICATION_XML)).build(); + + createKeyPairRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "CreateKeyPair") + .addFormParam("KeyName", "jclouds#test#0").build()); + + createKeyPairResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/create_keypair.xml", MediaType.APPLICATION_XML)).build(); + + createSecurityGroupRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "CreateSecurityGroup") + .addFormParam("GroupDescription", "jclouds#test") + .addFormParam("GroupName", "jclouds#test").build()); + + createSecurityGroupResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/created_securitygroup.xml", MediaType.APPLICATION_XML)).build(); + + describeSecurityGroupRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "DescribeSecurityGroups") + .addFormParam("GroupName.1", "jclouds#test").build()); + + describeSecurityGroupResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/new_securitygroup.xml", MediaType.APPLICATION_XML)).build(); + + authorizeSecurityGroupIngressRequest22 = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "AuthorizeSecurityGroupIngress") + .addFormParam("CidrIp", "0.0.0.0/0") + .addFormParam("FromPort", "22") + .addFormParam("ToPort", "22") + .addFormParam("GroupName", "jclouds#test") + .addFormParam("IpProtocol", "tcp").build()); + + authorizeSecurityGroupIngressRequestGroup = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "AuthorizeSecurityGroupIngress") + .addFormParam("SourceSecurityGroupName", "jclouds#test") + .addFormParam("SourceSecurityGroupOwnerId", "993194456877") + .addFormParam("GroupName", "jclouds#test").build()); + + authorizeSecurityGroupIngressResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/authorize_securitygroup_ingress_response.xml", MediaType.APPLICATION_XML)).build(); + + runInstancesRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "RunInstances") + .addFormParam("ImageId", "ami-be3adfd7") + .addFormParam("InstanceType", "m1.small") + .addFormParam("KeyName", "jclouds#test#0") + .addFormParam("MaxCount", "1") + .addFormParam("MinCount", "1") + .addFormParam("SecurityGroup.1", "jclouds#test").build()); + + runInstancesResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/new_instance.xml", MediaType.APPLICATION_XML)).build(); + + runThreeInstancesRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "RunInstances") + .addFormParam("ImageId", "ami-be3adfd7") + .addFormParam("InstanceType", "m1.small") + .addFormParam("KeyName", "jclouds#test#0") + .addFormParam("MaxCount", "3") + .addFormParam("MinCount", "3") + .addFormParam("SecurityGroup.1", "jclouds#test").build()); + + runThreeToFourInstancesRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "RunInstances") + .addFormParam("ImageId", "ami-be3adfd7") + .addFormParam("InstanceType", "m1.small") + .addFormParam("KeyName", "jclouds#test#0") + .addFormParam("MaxCount", "4") + .addFormParam("MinCount", "3") + .addFormParam("SecurityGroup.1", "jclouds#test").build()); + + runThreeInstancesResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/run_instances_three.xml", MediaType.APPLICATION_XML)).build(); + + describeInstanceRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "DescribeInstances") + .addFormParam("InstanceId.1", "i-2baa5550").build()); + + describeInstanceResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/describe_instances_running-1.xml", MediaType.APPLICATION_XML)).build(); + + describeInstanceMultiIdsRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "DescribeInstances") + .addFormParam("InstanceId.1", "i-2baa5550") + .addFormParam("InstanceId.2", "i-abcd1234").build()); + + describeInstanceMultiIdsResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/describe_instances_multiple.xml", MediaType.APPLICATION_XML)).build(); + + describeInstanceThreeIdsRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("Action", "DescribeInstances") + .addFormParam("InstanceId.1", "i-2ba64342") + .addFormParam("InstanceId.2", "i-2bc64242") + .addFormParam("InstanceId.3", "i-2be64332").build()); + + describeInstanceThreeIdsResponse = + HttpResponse.builder().statusCode(200) + .payload(payloadFromResourceWithContentType( + "/describe_instances_multiple.xml", MediaType.APPLICATION_XML)).build(); + + //TODO: duplicate.. shouldn't need this + describeImageRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2."; + region + ".amazonaws.com/") + .addHeader("Host", "ec2." + region + ".amazonaws.com") + .addFormParam("ImageId.1", "ami-aecd60c7") + .addFormParam("Action", "DescribeImages").build()); + + createTagsRequest = + formSigner.filter(HttpRequest.builder() + .method("POST") + .endpoint("https://ec2.us-east-1.amazonaws.com/";) + .addHeader("Host", "ec2.us-east-1.amazonaws.com") + .payload( + payloadFromStringWithContentType( + "Action=CreateTags" + + "&ResourceId.1=i-2baa5550" + + "&Signature=Trp5e5%2BMqeBeBZbLYa9s9gxahQ9nkx6ETfsGl82IV8Y%3D" + + "&SignatureMethod=HmacSHA256" + + "&SignatureVersion=2" + + "&Tag.1.Key=Name" + + "&Tag.1.Value=test-2baa5550" + + "&Timestamp=2012-04-16T15%3A54%3A08.897Z" + + "&Version=2010-08-31" + + "&AWSAccessKeyId=identity", + "application/x-www-form-urlencoded")) + .build()); + + createTagsResponse = HttpResponse.builder().statusCode(200).build(); + + } + + @Override + public ComputeService apply(ComputeServiceContext input) { + return input.getComputeService(); + } + +} http://git-wip-us.apache.org/repos/asf/stratos/blob/397d9926/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/EC2TemplateBuilderImplTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/EC2TemplateBuilderImplTest.java b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/EC2TemplateBuilderImplTest.java new file mode 100644 index 0000000..9c7de8d --- /dev/null +++ b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/internal/EC2TemplateBuilderImplTest.java @@ -0,0 +1,230 @@ +/* + * 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.ec2.compute.internal; + +import static org.easymock.EasyMock.createMock; +import static org.easymock.EasyMock.expect; +import static org.easymock.EasyMock.replay; +import static org.easymock.EasyMock.verify; +import static org.jclouds.ec2.compute.domain.EC2HardwareBuilder.c1_medium; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.fail; + +import java.util.NoSuchElementException; +import java.util.Set; + +import javax.inject.Provider; + +import org.jclouds.collect.Memoized; +import org.jclouds.compute.domain.Hardware; +import org.jclouds.compute.domain.Image; +import org.jclouds.compute.domain.OperatingSystem; +import org.jclouds.compute.domain.TemplateBuilder; +import org.jclouds.compute.domain.internal.TemplateBuilderImpl; +import org.jclouds.compute.domain.internal.TemplateBuilderImplTest; +import org.jclouds.compute.options.TemplateOptions; +import org.jclouds.compute.strategy.GetImageStrategy; +import org.jclouds.compute.suppliers.ImageCacheSupplier; +import org.jclouds.domain.Location; +import org.jclouds.ec2.compute.domain.RegionAndName; +import org.jclouds.ec2.compute.functions.ImagesToRegionAndIdMap; +import org.jclouds.ec2.compute.options.EC2TemplateOptions; +import org.testng.annotations.Test; + +import com.google.common.base.Functions; +import com.google.common.base.Supplier; +import com.google.common.base.Suppliers; +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Sets; + +@Test(groups = "unit", singleThreaded = true) +public class EC2TemplateBuilderImplTest extends TemplateBuilderImplTest { + + @Override + protected TemplateOptions provideTemplateOptions() { + return new EC2TemplateOptions(); + } + + @Override + protected EC2TemplateBuilderImpl createTemplateBuilder(final Image knownImage, + @Memoized Supplier<Set<? extends Location>> locations, @Memoized final Supplier<Set<? extends Image>> images, + @Memoized Supplier<Set<? extends Hardware>> sizes, Location defaultLocation, + Provider<TemplateOptions> optionsProvider, Provider<TemplateBuilder> templateBuilderProvider, GetImageStrategy getImageStrategy) { + + LoadingCache<RegionAndName, ? extends Image> imageMap; + if (knownImage != null) { + final RegionAndName knownRegionAndName = new RegionAndName(knownImage.getLocation().getId(), knownImage.getProviderId()); + + imageMap = CacheBuilder.newBuilder().build(new CacheLoader<RegionAndName, Image>() { + @Override + public Image load(RegionAndName from) { + return from.equals(knownRegionAndName) ? knownImage : null; + } + + }); + + } else { + imageMap = CacheBuilder.newBuilder().build(CacheLoader.from(Functions.forMap( + ImagesToRegionAndIdMap.imagesToMap(images.get())))); + } + + return new EC2TemplateBuilderImpl(locations, new ImageCacheSupplier(images, 60), sizes, Suppliers.ofInstance(defaultLocation), + optionsProvider, templateBuilderProvider, getImageStrategy, Suppliers.<LoadingCache<RegionAndName, ? extends Image>>ofInstance(imageMap)); + } + + @Override + protected String getProviderFormatId(String uniqueLabel) { + return "us-east-1/" + uniqueLabel; + } + + @Override + @Test + public void testHardwareWithImageIdPredicateOnlyAcceptsImageWhenLocationNull() { + // not possible to have null region in ec2 + } + + @SuppressWarnings("unchecked") + @Test + public void testParseOnDemand() { + + Supplier<Set<? extends Location>> locations = Suppliers.<Set<? extends Location>> ofInstance(ImmutableSet + .<Location> of(region)); + Supplier<Set<? extends Image>> images = Suppliers.<Set<? extends Image>> ofInstance(Sets + .<Image> newLinkedHashSet()); + Supplier<Set<? extends Hardware>> sizes = Suppliers.<Set<? extends Hardware>> ofInstance(ImmutableSet + .<Hardware> of(c1_medium().build())); + + Provider<TemplateOptions> optionsProvider = createMock(Provider.class); + Provider<TemplateBuilder> templateBuilderProvider = createMock(Provider.class); + TemplateOptions defaultOptions = createMock(TemplateOptions.class); + Image knownImage = createMock(Image.class); + OperatingSystem os = createMock(OperatingSystem.class); + GetImageStrategy getImageStrategy = createMock(GetImageStrategy.class); + + expect(optionsProvider.get()).andReturn(defaultOptions); + + expect(knownImage.getId()).andReturn("us-east-1/ami").atLeastOnce(); + expect(knownImage.getLocation()).andReturn(region).atLeastOnce(); + expect(knownImage.getName()).andReturn(null).atLeastOnce(); + expect(knownImage.getDescription()).andReturn(null).atLeastOnce(); + expect(knownImage.getVersion()).andReturn(null).atLeastOnce(); + expect(knownImage.getProviderId()).andReturn("ami").atLeastOnce(); + + expect(knownImage.getOperatingSystem()).andReturn(os).atLeastOnce(); + + expect(os.getName()).andReturn(null).atLeastOnce(); + expect(os.getVersion()).andReturn(null).atLeastOnce(); + expect(os.getFamily()).andReturn(null).atLeastOnce(); + expect(os.getDescription()).andReturn(null).atLeastOnce(); + expect(os.getArch()).andReturn("paravirtual").atLeastOnce(); + expect(os.is64Bit()).andReturn(false).atLeastOnce(); + + replay(knownImage, os, defaultOptions, optionsProvider, templateBuilderProvider, getImageStrategy); + + TemplateBuilderImpl template = createTemplateBuilder(knownImage, locations, images, sizes, region, + optionsProvider, templateBuilderProvider, getImageStrategy); + + assertEquals(template.imageId("us-east-1/ami").build().getImage(), knownImage); + + verify(knownImage, os, defaultOptions, optionsProvider, templateBuilderProvider, getImageStrategy); + } + + @SuppressWarnings("unchecked") + @Test + public void testParseOnDemandWithoutRegionEncodedIntoId() { + + Supplier<Set<? extends Location>> locations = Suppliers.<Set<? extends Location>> ofInstance(ImmutableSet + .<Location> of(region)); + Supplier<Set<? extends Image>> images = Suppliers.<Set<? extends Image>> ofInstance(ImmutableSet.<Image> of()); + Supplier<Set<? extends Hardware>> sizes = Suppliers.<Set<? extends Hardware>> ofInstance(ImmutableSet + .<Hardware> of(c1_medium().build())); + + Provider<TemplateOptions> optionsProvider = createMock(Provider.class); + Provider<TemplateBuilder> templateBuilderProvider = createMock(Provider.class); + TemplateOptions defaultOptions = createMock(TemplateOptions.class); + Image knownImage = createMock(Image.class); + GetImageStrategy getImageStrategy = createMock(GetImageStrategy.class); + expect(knownImage.getId()).andReturn("region/ami").anyTimes(); + expect(knownImage.getProviderId()).andReturn("ami").anyTimes(); + expect(knownImage.getLocation()).andReturn(region).anyTimes(); + + expect(optionsProvider.get()).andReturn(defaultOptions); + + replay(knownImage, defaultOptions, optionsProvider, templateBuilderProvider, getImageStrategy); + + TemplateBuilderImpl template = createTemplateBuilder(knownImage, locations, images, sizes, region, + optionsProvider, templateBuilderProvider, getImageStrategy); + try { + template.imageId("ami").build(); + fail("Expected IllegalArgumentException"); + } catch (IllegalArgumentException e) { + + } + + verify(knownImage, defaultOptions, optionsProvider, templateBuilderProvider, getImageStrategy); + } + + @SuppressWarnings("unchecked") + @Test(expectedExceptions = NoSuchElementException.class) + public void testParseOnDemandNotFound() { + + Supplier<Set<? extends Location>> locations = Suppliers.<Set<? extends Location>> ofInstance(ImmutableSet + .<Location> of(region)); + Supplier<Set<? extends Image>> images = Suppliers.<Set<? extends Image>> ofInstance(ImmutableSet.<Image> of()); + Supplier<Set<? extends Hardware>> sizes = Suppliers.<Set<? extends Hardware>> ofInstance(ImmutableSet + .<Hardware> of(c1_medium().build())); + + Location defaultLocation = createMock(Location.class); + Provider<TemplateOptions> optionsProvider = createMock(Provider.class); + Provider<TemplateBuilder> templateBuilderProvider = createMock(Provider.class); + TemplateOptions defaultOptions = createMock(TemplateOptions.class); + GetImageStrategy getImageStrategy = createMock(GetImageStrategy.class); + Image knownImage = createMock(Image.class); + expect(knownImage.getId()).andReturn("region/ami").anyTimes(); + expect(knownImage.getProviderId()).andReturn("ami").anyTimes(); + expect(knownImage.getLocation()).andReturn(region).anyTimes(); + + expect(defaultLocation.getId()).andReturn("region"); + expect(optionsProvider.get()).andReturn(defaultOptions); + + replay(knownImage, defaultOptions, defaultLocation, optionsProvider, templateBuilderProvider, getImageStrategy); + + TemplateBuilderImpl template = createTemplateBuilder(knownImage, locations, images, sizes, defaultLocation, + optionsProvider, templateBuilderProvider, getImageStrategy); + + assertEquals(template.imageId("region/bad").build().getImage(), knownImage); + + verify(knownImage, defaultOptions, defaultLocation, optionsProvider, templateBuilderProvider, getImageStrategy); + } + + // The EC2 provider already overrides the getImage method so this test is not useful for EC2 + @Override + @Test(enabled = false) + public void testFindImageWithIdDefaultToGetImageStrategy() { + + } + + // The EC2 provider already overrides the getImage method so this test is not useful for EC2 + @Override + public void testFindImageWithIdDefaultToGetImageStrategyAndPopulatesTheCache() { + + } + +} http://git-wip-us.apache.org/repos/asf/stratos/blob/397d9926/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/CreateSecurityGroupIfNeededTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/CreateSecurityGroupIfNeededTest.java b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/CreateSecurityGroupIfNeededTest.java new file mode 100644 index 0000000..98ee834 --- /dev/null +++ b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/CreateSecurityGroupIfNeededTest.java @@ -0,0 +1,105 @@ +/* + * 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.ec2.compute.loaders; + +import static org.easymock.EasyMock.createMock; +import static org.easymock.EasyMock.createNiceMock; +import static org.easymock.EasyMock.expect; +import static org.easymock.EasyMock.expectLastCall; +import static org.easymock.EasyMock.replay; +import static org.easymock.EasyMock.verify; +import static org.testng.Assert.assertEquals; + +import java.util.Set; +import java.util.concurrent.ExecutionException; + +import org.jclouds.ec2.compute.domain.RegionAndName; +import org.jclouds.ec2.compute.domain.RegionNameAndIngressRules; +import org.jclouds.ec2.domain.SecurityGroup; +import org.jclouds.ec2.domain.UserIdGroupPair; +import org.jclouds.ec2.features.SecurityGroupApi; +import org.jclouds.net.domain.IpProtocol; +import org.testng.annotations.Test; + +import com.google.common.base.Predicate; +import com.google.common.base.Predicates; +import com.google.common.collect.ImmutableSet; + +@Test(groups = "unit", singleThreaded = true, testName = "CreateSecurityGroupIfNeeded") +public class CreateSecurityGroupIfNeededTest { + + @SuppressWarnings("unchecked") + @Test + public void testWhenPort22AndToItselfAuthorizesIngressTwice() throws ExecutionException { + + SecurityGroupApi client = createMock(SecurityGroupApi.class); + Predicate<RegionAndName> tester = Predicates.alwaysTrue(); + + SecurityGroup group = createNiceMock(SecurityGroup.class); + Set<SecurityGroup> groups = ImmutableSet.<SecurityGroup> of(group); + + client.createSecurityGroupInRegion("region", "group", "group"); + client.authorizeSecurityGroupIngressInRegion("region", "group", IpProtocol.TCP, 22, 22, "0.0.0.0/0"); + expect(client.describeSecurityGroupsInRegion("region", "group")).andReturn(Set.class.cast(groups)); + expect(group.getOwnerId()).andReturn("ownerId"); + client.authorizeSecurityGroupIngressInRegion("region", "group", new UserIdGroupPair("ownerId", "group")); + + replay(client); + replay(group); + + CreateSecurityGroupIfNeeded function = new CreateSecurityGroupIfNeeded(client, tester); + + assertEquals("group", function.load(new RegionNameAndIngressRules("region", "group", new int[] { 22 }, true))); + + verify(client); + verify(group); + + } + + @Test + public void testIllegalStateExceptionCreatingGroupJustReturns() throws ExecutionException { + + SecurityGroupApi client = createMock(SecurityGroupApi.class); + Predicate<RegionAndName> tester = Predicates.alwaysTrue(); + + client.createSecurityGroupInRegion("region", "group", "group"); + expectLastCall().andThrow(new IllegalStateException()); + + replay(client); + + CreateSecurityGroupIfNeeded function = new CreateSecurityGroupIfNeeded(client, tester); + + assertEquals("group", function.load(new RegionNameAndIngressRules("region", "group", new int[] { 22 }, true))); + + verify(client); + + } + + @Test(expectedExceptions = RuntimeException.class) + public void testWhenEventualConsistencyExpiresIllegalStateException() throws ExecutionException { + + SecurityGroupApi client = createMock(SecurityGroupApi.class); + Predicate<RegionAndName> tester = Predicates.alwaysFalse(); + + client.createSecurityGroupInRegion("region", "group", "group"); + + replay(client); + + CreateSecurityGroupIfNeeded function = new CreateSecurityGroupIfNeeded(client, tester); + function.load(new RegionNameAndIngressRules("region", "group", new int[] { 22 }, true)); + } +} http://git-wip-us.apache.org/repos/asf/stratos/blob/397d9926/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/LoadPublicIpForInstanceOrNullTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/LoadPublicIpForInstanceOrNullTest.java b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/LoadPublicIpForInstanceOrNullTest.java new file mode 100644 index 0000000..fde64ca --- /dev/null +++ b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/LoadPublicIpForInstanceOrNullTest.java @@ -0,0 +1,103 @@ +/* + * 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.ec2.compute.loaders; + +import static org.easymock.EasyMock.createMock; +import static org.easymock.EasyMock.expect; +import static org.easymock.EasyMock.replay; +import static org.easymock.EasyMock.verify; +import static org.testng.Assert.assertEquals; + +import org.jclouds.ec2.EC2Api; +import org.jclouds.ec2.compute.domain.RegionAndName; +import org.jclouds.ec2.domain.PublicIpInstanceIdPair; +import org.jclouds.ec2.features.ElasticIPAddressApi; +import org.testng.annotations.Test; + +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableSet; + +@Test(groups = "unit", singleThreaded = true, testName = "LoadPublicIpForInstanceOrNullTest") +public class LoadPublicIpForInstanceOrNullTest { + + @Test + public void testReturnsPublicIpOnMatch() throws Exception { + EC2Api client = createMock(EC2Api.class); + ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class); + + expect(client.getElasticIPAddressApi()).andReturn((Optional) Optional.of(ipClient)).atLeastOnce(); + expect(ipClient.describeAddressesInRegion("region")).andReturn( + ImmutableSet.<PublicIpInstanceIdPair> of(new PublicIpInstanceIdPair("region", "1.1.1.1", "i-blah"))) + .atLeastOnce(); + + replay(client); + replay(ipClient); + + LoadPublicIpForInstanceOrNull parser = new LoadPublicIpForInstanceOrNull(client); + + assertEquals(parser.load(new RegionAndName("region", "i-blah")), "1.1.1.1"); + + verify(client); + verify(ipClient); + } + + @Test + public void testReturnsNullWhenNotFound() throws Exception { + EC2Api client = createMock(EC2Api.class); + ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class); + + expect(client.getElasticIPAddressApi()).andReturn((Optional) Optional.of(ipClient)).atLeastOnce(); + + expect(ipClient.describeAddressesInRegion("region")).andReturn(ImmutableSet.<PublicIpInstanceIdPair> of()) + .atLeastOnce(); + + replay(client); + replay(ipClient); + + LoadPublicIpForInstanceOrNull parser = new LoadPublicIpForInstanceOrNull(client); + + assertEquals(parser.load(new RegionAndName("region", "i-blah")), null); + + verify(client); + verify(ipClient); + + } + + @Test + public void testReturnsNullWhenNotAssigned() throws Exception { + EC2Api client = createMock(EC2Api.class); + ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class); + + expect(client.getElasticIPAddressApi()).andReturn((Optional) Optional.of(ipClient)).atLeastOnce(); + + expect(ipClient.describeAddressesInRegion("region")).andReturn( + ImmutableSet.<PublicIpInstanceIdPair> of(new PublicIpInstanceIdPair("region", "1.1.1.1", null))) + .atLeastOnce(); + + replay(client); + replay(ipClient); + + LoadPublicIpForInstanceOrNull parser = new LoadPublicIpForInstanceOrNull(client); + + assertEquals(parser.load(new RegionAndName("region", "i-blah")), null); + + verify(client); + verify(ipClient); + + } + +} http://git-wip-us.apache.org/repos/asf/stratos/blob/397d9926/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/RegionAndIdToImageTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/RegionAndIdToImageTest.java b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/RegionAndIdToImageTest.java new file mode 100644 index 0000000..86ff871 --- /dev/null +++ b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/loaders/RegionAndIdToImageTest.java @@ -0,0 +1,140 @@ +/* + * 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.ec2.compute.loaders; + +import static org.easymock.EasyMock.createMock; +import static org.easymock.EasyMock.createNiceMock; +import static org.easymock.EasyMock.expect; +import static org.easymock.EasyMock.replay; +import static org.easymock.EasyMock.verify; +import static org.jclouds.ec2.options.DescribeImagesOptions.Builder.imageIds; +import static org.testng.Assert.assertEquals; + +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.concurrent.ExecutionException; + +import org.jclouds.compute.domain.Image; +import org.jclouds.ec2.EC2Api; +import org.jclouds.ec2.compute.domain.RegionAndName; +import org.jclouds.ec2.compute.functions.EC2ImageParser; +import org.jclouds.ec2.features.AMIApi; +import org.jclouds.rest.ResourceNotFoundException; +import org.testng.annotations.Test; + +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableSet; + +@Test(groups = "unit") +public class RegionAndIdToImageTest { + + @SuppressWarnings("unchecked") + @Test + public void testApply() throws ExecutionException { + + EC2ImageParser parser = createMock(EC2ImageParser.class); + EC2Api caller = createMock(EC2Api.class); + AMIApi client = createMock(AMIApi.class); + + org.jclouds.ec2.domain.Image ec2Image = createMock(org.jclouds.ec2.domain.Image.class); + Image image = createNiceMock(Image.class); + Set<? extends org.jclouds.ec2.domain.Image> images = ImmutableSet.<org.jclouds.ec2.domain.Image> of(ec2Image); + + expect(caller.getAMIApi()).andReturn((Optional) Optional.of(client)).atLeastOnce(); + expect(client.describeImagesInRegion("region", imageIds("ami"))).andReturn(Set.class.cast(images)); + expect(parser.apply(ec2Image)).andReturn(image); + + replay(caller); + replay(image); + replay(parser); + replay(client); + + RegionAndIdToImage function = new RegionAndIdToImage(parser, caller); + + assertEquals(function.load(new RegionAndName("region", "ami")), image); + + verify(caller); + verify(image); + verify(image); + verify(client); + + } + + @SuppressWarnings("unchecked") + @Test(expectedExceptions = ExecutionException.class) + public void testApplyNotFoundMakesExecutionException() throws ExecutionException { + + EC2ImageParser parser = createMock(EC2ImageParser.class); + EC2Api caller = createMock(EC2Api.class); + AMIApi client = createMock(AMIApi.class); + + org.jclouds.ec2.domain.Image ec2Image = createMock(org.jclouds.ec2.domain.Image.class); + Image image = createNiceMock(Image.class); + Set<? extends org.jclouds.ec2.domain.Image> images = ImmutableSet.<org.jclouds.ec2.domain.Image> of(ec2Image); + + expect(caller.getAMIApi()).andReturn((Optional) Optional.of(client)).atLeastOnce(); + expect(client.describeImagesInRegion("region", imageIds("ami"))).andReturn(Set.class.cast(images)); + expect(parser.apply(ec2Image)).andThrow(new ResourceNotFoundException()); + + replay(caller); + replay(image); + replay(parser); + replay(client); + + RegionAndIdToImage function = new RegionAndIdToImage(parser, caller); + + assertEquals(function.load(new RegionAndName("region", "ami")), null); + + verify(caller); + verify(image); + verify(parser); + verify(client); + + } + + @SuppressWarnings("unchecked") + @Test(expectedExceptions = ExecutionException.class) + public void testApplyNoSuchElementExceptionMakesExecutionException() throws ExecutionException { + + EC2ImageParser parser = createMock(EC2ImageParser.class); + EC2Api caller = createMock(EC2Api.class); + AMIApi client = createMock(AMIApi.class); + + org.jclouds.ec2.domain.Image ec2Image = createMock(org.jclouds.ec2.domain.Image.class); + Image image = createNiceMock(Image.class); + Set<? extends org.jclouds.ec2.domain.Image> images = ImmutableSet.<org.jclouds.ec2.domain.Image> of(ec2Image); + + expect(caller.getAMIApi()).andReturn((Optional) Optional.of(client)).atLeastOnce(); + expect(client.describeImagesInRegion("region", imageIds("ami"))).andReturn(Set.class.cast(images)); + expect(parser.apply(ec2Image)).andThrow(new NoSuchElementException()); + + replay(caller); + replay(image); + replay(parser); + replay(client); + + RegionAndIdToImage function = new RegionAndIdToImage(parser, caller); + + assertEquals(function.load(new RegionAndName("region", "ami")), null); + + verify(caller); + verify(image); + verify(parser); + verify(client); + + } +} http://git-wip-us.apache.org/repos/asf/stratos/blob/397d9926/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/options/EC2TemplateOptionsTest.java ---------------------------------------------------------------------- diff --git a/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/options/EC2TemplateOptionsTest.java b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/options/EC2TemplateOptionsTest.java new file mode 100644 index 0000000..a3f6cde --- /dev/null +++ b/dependencies/jclouds/apis/ec2/1.8.0-stratos/src/test/java/org/jclouds/ec2/compute/options/EC2TemplateOptionsTest.java @@ -0,0 +1,325 @@ +/* + * 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.ec2.compute.options; + +import static org.jclouds.ec2.compute.options.EC2TemplateOptions.Builder.authorizePublicKey; +import static org.jclouds.ec2.compute.options.EC2TemplateOptions.Builder.blockOnPort; +import static org.jclouds.ec2.compute.options.EC2TemplateOptions.Builder.inboundPorts; +import static org.jclouds.ec2.compute.options.EC2TemplateOptions.Builder.installPrivateKey; +import static org.jclouds.ec2.compute.options.EC2TemplateOptions.Builder.keyPair; +import static org.jclouds.ec2.compute.options.EC2TemplateOptions.Builder.noKeyPair; +import static org.jclouds.ec2.compute.options.EC2TemplateOptions.Builder.securityGroups; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertNull; + +import java.io.IOException; + +import com.google.common.collect.ImmutableSet; +import org.jclouds.compute.options.TemplateOptions; +import org.testng.annotations.Test; + +/** + * Tests possible uses of EC2TemplateOptions and EC2TemplateOptions.Builder.* + */ +public class EC2TemplateOptionsTest { + + public void testAs() { + TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.as(EC2TemplateOptions.class), options); + } + + @Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = "all security groups must be non-empty") + public void testsecurityGroupsIterableBadFormat() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.securityGroups(ImmutableSet.of("group1", "")); + } + + @Test(expectedExceptions = IllegalArgumentException.class) + public void testsecurityGroupsIterableEmptyNotOk() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.securityGroups(ImmutableSet.<String> of()); + } + + @Test + public void testsecurityGroupsIterable() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.securityGroups(ImmutableSet.of("group1", "group2")); + assertEquals(options.getGroups(), ImmutableSet.of("group1", "group2")); + + } + + @Test + public void testsecurityGroupsIterableStatic() { + EC2TemplateOptions options = securityGroups(ImmutableSet.of("group1", "group2")); + assertEquals(options.getGroups(), ImmutableSet.of("group1", "group2")); + } + + @Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = "all security groups must be non-empty") + public void testsecurityGroupsVarArgsBadFormat() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.securityGroups("mygroup", ""); + } + + @Test + public void testsecurityGroupsVarArgs() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.securityGroups("group1", "group2"); + assertEquals(options.getGroups(), ImmutableSet.of("group1", "group2")); + + } + + @Test(expectedExceptions = IllegalArgumentException.class) + public void testsecurityGroupsVarArgsEmptyNotOk() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.securityGroups(); + } + + @Test + public void testDefaultGroupsVarArgsEmpty() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.getGroups(), ImmutableSet.of()); + } + + @Test + public void testsecurityGroupsVarArgsStatic() { + EC2TemplateOptions options = securityGroups("group1", "group2"); + assertEquals(options.getGroups(), ImmutableSet.of("group1", "group2")); + } + + @Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = "use noKeyPair option to request boot without a keypair") + public void testkeyPairBadFormat() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.keyPair(""); + } + + @Test(expectedExceptions = IllegalStateException.class) + public void testkeyPairAndNoKeyPair() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.keyPair("mykeypair"); + options.noKeyPair(); + } + + @Test(expectedExceptions = IllegalStateException.class) + public void testNoKeyPairAndKeyPair() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.noKeyPair(); + options.keyPair("mykeypair"); + } + + @Test + public void testkeyPair() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.keyPair("mykeypair"); + assertEquals(options.getKeyPair(), "mykeypair"); + } + + @Test + public void testNullkeyPair() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.getKeyPair(), null); + } + + @Test + public void testkeyPairStatic() { + EC2TemplateOptions options = keyPair("mykeypair"); + assertEquals(options.getKeyPair(), "mykeypair"); + } + + @Test(expectedExceptions = NullPointerException.class) + public void testkeyPairNPE() { + keyPair(null); + } + + @Test + public void testnoKeyPair() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.noKeyPair(); + assertEquals(options.getKeyPair(), null); + assert !options.shouldAutomaticallyCreateKeyPair(); + } + + @Test + public void testFalsenoKeyPair() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.getKeyPair(), null); + assert options.shouldAutomaticallyCreateKeyPair(); + } + + @Test + public void testnoKeyPairStatic() { + EC2TemplateOptions options = noKeyPair(); + assertEquals(options.getKeyPair(), null); + assert !options.shouldAutomaticallyCreateKeyPair(); + } + + // superclass tests + @Test(expectedExceptions = IllegalArgumentException.class) + public void testinstallPrivateKeyBadFormat() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.installPrivateKey("whompy"); + } + + @Test + public void testinstallPrivateKey() throws IOException { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.installPrivateKey("-----BEGIN RSA PRIVATE KEY-----"); + assertEquals(options.getPrivateKey(), "-----BEGIN RSA PRIVATE KEY-----"); + } + + @Test + public void testNullinstallPrivateKey() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.getPrivateKey(), null); + } + + @Test + public void testinstallPrivateKeyStatic() throws IOException { + EC2TemplateOptions options = installPrivateKey("-----BEGIN RSA PRIVATE KEY-----"); + assertEquals(options.getPrivateKey(), "-----BEGIN RSA PRIVATE KEY-----"); + } + + @Test(expectedExceptions = NullPointerException.class) + public void testinstallPrivateKeyNPE() { + installPrivateKey(null); + } + + @Test(expectedExceptions = IllegalArgumentException.class) + public void testauthorizePublicKeyBadFormat() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.authorizePublicKey("whompy"); + } + + @Test + public void testauthorizePublicKey() throws IOException { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.authorizePublicKey("ssh-rsa"); + assertEquals(options.getPublicKey(), "ssh-rsa"); + } + + @Test + public void testNullauthorizePublicKey() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.getPublicKey(), null); + } + + @Test + public void testauthorizePublicKeyStatic() throws IOException { + EC2TemplateOptions options = authorizePublicKey("ssh-rsa"); + assertEquals(options.getPublicKey(), "ssh-rsa"); + } + + @Test(expectedExceptions = NullPointerException.class) + public void testauthorizePublicKeyNPE() { + authorizePublicKey(null); + } + + @Test(expectedExceptions = IllegalArgumentException.class) + public void testblockOnPortBadFormat() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.blockOnPort(-1, -1); + } + + @Test + public void testblockOnPort() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.blockOnPort(22, 30); + assertEquals(options.getPort(), 22); + assertEquals(options.getSeconds(), 30); + + } + + @Test + public void testNullblockOnPort() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.getPort(), -1); + assertEquals(options.getSeconds(), -1); + } + + @Test + public void testblockOnPortStatic() { + EC2TemplateOptions options = blockOnPort(22, 30); + assertEquals(options.getPort(), 22); + assertEquals(options.getSeconds(), 30); + } + + @Test(expectedExceptions = IllegalArgumentException.class) + public void testinboundPortsBadFormat() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.inboundPorts(-1, -1); + } + + @Test + public void testinboundPorts() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.inboundPorts(22, 30); + assertEquals(options.getInboundPorts()[0], 22); + assertEquals(options.getInboundPorts()[1], 30); + + } + + @Test + public void testDefaultOpen22() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.getInboundPorts()[0], 22); + } + + @Test + public void testinboundPortsStatic() { + EC2TemplateOptions options = inboundPorts(22, 30); + assertEquals(options.getInboundPorts()[0], 22); + assertEquals(options.getInboundPorts()[1], 30); + } + + @Test + public void testMaxCountDefault() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertEquals(options.getMaxCount(), 0); + } + + @Test + public void testMaxCount() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.maxCount(2); + assertEquals(options.getMaxCount(), 2); + } + + @Test + public void testMaxCountNull() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.maxCount(null); + assertEquals(options.getMaxCount(), 0); + } + + @Test + public void testClientTokenDefault() { + EC2TemplateOptions options = new EC2TemplateOptions(); + assertNull(options.getClientToken()); + } + + @Test + public void testClientToken() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.clientToken("some-token"); + assertEquals(options.getClientToken(), "some-token"); + } + + @Test(expectedExceptions = NullPointerException.class) + public void testClientTokenNPE() { + EC2TemplateOptions options = new EC2TemplateOptions(); + options.clientToken(null); + } +}
