You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stratos.apache.org by la...@apache.org on 2014/03/27 23:45:54 UTC
[06/13] Forking jclouds provider/aws-ec2 for STRATOS-559
http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/60b2f3fa/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/options/AWSEC2TemplateOptionsTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/options/AWSEC2TemplateOptionsTest.java b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/options/AWSEC2TemplateOptionsTest.java
new file mode 100644
index 0000000..11e1526
--- /dev/null
+++ b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/options/AWSEC2TemplateOptionsTest.java
@@ -0,0 +1,418 @@
+/*
+ * 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.aws.ec2.compute.options;
+
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.authorizePublicKey;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.blockOnPort;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.enableMonitoring;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.iamInstanceProfileArn;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.iamInstanceProfileName;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.inboundPorts;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.installPrivateKey;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.keyPair;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.noKeyPair;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.securityGroupIds;
+import static org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions.Builder.securityGroups;
+import static org.testng.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions;
+import org.jclouds.compute.options.TemplateOptions;
+import org.testng.annotations.Test;
+
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * Tests possible uses of AWSEC2TemplateOptions and
+ * AWSEC2TemplateOptions.Builder.*
+ *
+ * @author Adrian Cole
+ */
+public class AWSEC2TemplateOptionsTest {
+
+ public void testAs() {
+ TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.as(AWSEC2TemplateOptions.class), options);
+ }
+
+ @Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = "all security groups must be non-empty")
+ public void testsecurityGroupIdsIterableBadFormat() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroupIds(ImmutableSet.of("groupId1", ""));
+ }
+
+ @Test(expectedExceptions = IllegalArgumentException.class)
+ public void testsecurityGroupIdsIterableEmptyNotOk() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroupIds(ImmutableSet.<String> of());
+ }
+
+ @Test
+ public void testsecurityGroupIdsIterable() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroupIds(ImmutableSet.of("groupId1", "groupId2"));
+ assertEquals(options.getGroupIds(), ImmutableSet.of("groupId1", "groupId2"));
+
+ }
+
+ @Test
+ public void testsecurityGroupIdsIterableStatic() {
+ AWSEC2TemplateOptions options = securityGroupIds(ImmutableSet.of("groupId1", "groupId2"));
+ assertEquals(options.getGroupIds(), ImmutableSet.of("groupId1", "groupId2"));
+ }
+
+ @Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = "all security groups must be non-empty")
+ public void testsecurityGroupIdsVarArgsBadFormat() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroupIds("mygroupId", "");
+ }
+
+ @Test
+ public void testsecurityGroupIdsVarArgs() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroupIds("groupId1", "groupId2");
+ assertEquals(options.getGroupIds(), ImmutableSet.of("groupId1", "groupId2"));
+ }
+
+ @Test(expectedExceptions = IllegalArgumentException.class)
+ public void testsecurityGroupIdsVarArgsEmptyNotOk() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroupIds();
+ }
+
+ @Test
+ public void testDefaultGroupIdsVarArgsEmpty() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getGroupIds(), ImmutableSet.of());
+ }
+
+ @Test
+ public void testsecurityGroupIdsVarArgsStatic() {
+ AWSEC2TemplateOptions options = securityGroupIds("groupId1", "groupId2");
+ assertEquals(options.getGroupIds(), ImmutableSet.of("groupId1", "groupId2"));
+ }
+
+ @Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = "all security groups must be non-empty")
+ public void testsecurityGroupsIterableBadFormat() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroups(ImmutableSet.of("group1", ""));
+ }
+
+ @Test(expectedExceptions = IllegalArgumentException.class)
+ public void testsecurityGroupsIterableEmptyNotOk() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroups(ImmutableSet.<String> of());
+ }
+
+ @Test
+ public void testsecurityGroupsIterable() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroups(ImmutableSet.of("group1", "group2"));
+ assertEquals(options.getGroups(), ImmutableSet.of("group1", "group2"));
+
+ }
+
+ @Test
+ public void testsecurityGroupsIterableStatic() {
+ AWSEC2TemplateOptions 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() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroups("mygroup", "");
+ }
+
+ @Test
+ public void testsecurityGroupsVarArgs() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroups("group1", "group2");
+ assertEquals(options.getGroups(), ImmutableSet.of("group1", "group2"));
+ }
+
+ @Test(expectedExceptions = IllegalArgumentException.class)
+ public void testsecurityGroupsVarArgsEmptyNotOk() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.securityGroups();
+ }
+
+ @Test
+ public void testDefaultGroupsVarArgsEmpty() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getGroups(), ImmutableSet.of());
+ }
+
+ @Test
+ public void testsecurityGroupsVarArgsStatic() {
+ AWSEC2TemplateOptions 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() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.keyPair("");
+ }
+
+ @Test(expectedExceptions = IllegalStateException.class)
+ public void testkeyPairAndNoKeyPair() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.keyPair("mykeypair");
+ options.noKeyPair();
+ }
+
+ @Test(expectedExceptions = IllegalStateException.class)
+ public void testNoKeyPairAndKeyPair() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.noKeyPair();
+ options.keyPair("mykeypair");
+ }
+
+ @Test
+ public void testkeyPair() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.keyPair("mykeypair");
+ assertEquals(options.getKeyPair(), "mykeypair");
+ }
+
+ @Test
+ public void testNullkeyPair() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getKeyPair(), null);
+ }
+
+ @Test
+ public void testkeyPairStatic() {
+ AWSEC2TemplateOptions options = keyPair("mykeypair");
+ assertEquals(options.getKeyPair(), "mykeypair");
+ }
+
+ @Test(expectedExceptions = NullPointerException.class)
+ public void testkeyPairNPE() {
+ keyPair(null);
+ }
+
+ @Test
+ public void testnoKeyPair() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.noKeyPair();
+ assertEquals(options.getKeyPair(), null);
+ assert !options.shouldAutomaticallyCreateKeyPair();
+ }
+
+ @Test
+ public void testFalsenoKeyPair() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getKeyPair(), null);
+ assert options.shouldAutomaticallyCreateKeyPair();
+ }
+
+ @Test
+ public void testnoKeyPairStatic() {
+ AWSEC2TemplateOptions options = noKeyPair();
+ assertEquals(options.getKeyPair(), null);
+ assert !options.shouldAutomaticallyCreateKeyPair();
+ }
+
+ @Test
+ public void testMonitoringEnabledDefault() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assert !options.isMonitoringEnabled();
+ }
+
+ @Test
+ public void testMonitoringEnabled() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.enableMonitoring();
+ assert options.isMonitoringEnabled();
+ }
+
+ @Test
+ public void testEnableMonitoringStatic() {
+ AWSEC2TemplateOptions options = enableMonitoring();
+ assertEquals(options.getKeyPair(), null);
+ assert options.isMonitoringEnabled();
+ }
+
+ // superclass tests
+ @Test(expectedExceptions = IllegalArgumentException.class)
+ public void testinstallPrivateKeyBadFormat() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.installPrivateKey("whompy");
+ }
+
+ @Test
+ public void testinstallPrivateKey() throws IOException {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.installPrivateKey("-----BEGIN RSA PRIVATE KEY-----");
+ assertEquals(options.getPrivateKey(), "-----BEGIN RSA PRIVATE KEY-----");
+ }
+
+ @Test
+ public void testNullinstallPrivateKey() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getPrivateKey(), null);
+ }
+
+ @Test
+ public void testinstallPrivateKeyStatic() throws IOException {
+ AWSEC2TemplateOptions 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() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.authorizePublicKey("whompy");
+ }
+
+ @Test
+ public void testauthorizePublicKey() throws IOException {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.authorizePublicKey("ssh-rsa");
+ assertEquals(options.getPublicKey(), "ssh-rsa");
+ }
+
+ @Test
+ public void testNullauthorizePublicKey() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getPublicKey(), null);
+ }
+
+ @Test
+ public void testauthorizePublicKeyStatic() throws IOException {
+ AWSEC2TemplateOptions 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() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.blockOnPort(-1, -1);
+ }
+
+ @Test
+ public void testblockOnPort() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.blockOnPort(22, 30);
+ assertEquals(options.getPort(), 22);
+ assertEquals(options.getSeconds(), 30);
+
+ }
+
+ @Test
+ public void testNullblockOnPort() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getPort(), -1);
+ assertEquals(options.getSeconds(), -1);
+ }
+
+ @Test
+ public void testblockOnPortStatic() {
+ AWSEC2TemplateOptions options = blockOnPort(22, 30);
+ assertEquals(options.getPort(), 22);
+ assertEquals(options.getSeconds(), 30);
+ }
+
+ @Test(expectedExceptions = IllegalArgumentException.class)
+ public void testinboundPortsBadFormat() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.inboundPorts(-1, -1);
+ }
+
+ @Test
+ public void testinboundPorts() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.inboundPorts(22, 30);
+ assertEquals(options.getInboundPorts()[0], 22);
+ assertEquals(options.getInboundPorts()[1], 30);
+
+ }
+
+ @Test
+ public void testDefaultOpen22() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getInboundPorts()[0], 22);
+ }
+
+ @Test
+ public void testinboundPortsStatic() {
+ AWSEC2TemplateOptions options = inboundPorts(22, 30);
+ assertEquals(options.getInboundPorts()[0], 22);
+ assertEquals(options.getInboundPorts()[1], 30);
+ }
+
+ @Test
+ public void testIAMInstanceProfileArn() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.iamInstanceProfileArn("arn:aws:iam::123456789012:instance-profile/application_abc/component_xyz/Webserver");
+ assertEquals(options.getIAMInstanceProfileArn(), "arn:aws:iam::123456789012:instance-profile/application_abc/component_xyz/Webserver");
+ }
+
+ @Test
+ public void testNullIAMInstanceProfileArn() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getIAMInstanceProfileArn(), null);
+ }
+
+ @Test
+ public void testIAMInstanceProfileArnStatic() {
+ AWSEC2TemplateOptions options = iamInstanceProfileArn("arn:aws:iam::123456789012:instance-profile/application_abc/component_xyz/Webserver");
+ assertEquals(options.getIAMInstanceProfileArn(), "arn:aws:iam::123456789012:instance-profile/application_abc/component_xyz/Webserver");
+ }
+
+ @Test(expectedExceptions = NullPointerException.class)
+ public void testIAMInstanceProfileArnNPE() {
+ iamInstanceProfileArn(null);
+ }
+
+ @Test
+ public void testIAMInstanceProfileName() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ options.iamInstanceProfileName("Webserver");
+ assertEquals(options.getIAMInstanceProfileName(), "Webserver");
+ }
+
+ @Test
+ public void testNullIAMInstanceProfileName() {
+ AWSEC2TemplateOptions options = new AWSEC2TemplateOptions();
+ assertEquals(options.getIAMInstanceProfileName(), null);
+ }
+
+ @Test
+ public void testIAMInstanceProfileNameStatic() {
+ AWSEC2TemplateOptions options = iamInstanceProfileName("Webserver");
+ assertEquals(options.getIAMInstanceProfileName(), "Webserver");
+ }
+
+ @Test(expectedExceptions = NullPointerException.class)
+ public void testIAMInstanceProfileNameNPE() {
+ iamInstanceProfileName(null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/60b2f3fa/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/AWSEC2ImageParserTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/AWSEC2ImageParserTest.java b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/AWSEC2ImageParserTest.java
new file mode 100644
index 0000000..433fd7f
--- /dev/null
+++ b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/AWSEC2ImageParserTest.java
@@ -0,0 +1,242 @@
+/*
+ * 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.aws.ec2.compute.strategy;
+
+import static org.testng.Assert.assertEquals;
+
+import java.util.Map;
+import java.util.Set;
+
+import org.jclouds.compute.config.BaseComputeServiceContextModule;
+import org.jclouds.compute.domain.ImageBuilder;
+import org.jclouds.compute.domain.OperatingSystem;
+import org.jclouds.compute.domain.OsFamily;
+import org.jclouds.compute.reference.ComputeServiceConstants;
+import org.jclouds.domain.Location;
+import org.jclouds.domain.LocationBuilder;
+import org.jclouds.domain.LocationScope;
+import org.jclouds.domain.LoginCredentials;
+import org.jclouds.ec2.compute.config.EC2ComputeServiceDependenciesModule;
+import org.jclouds.ec2.compute.functions.EC2ImageParser;
+import org.jclouds.ec2.compute.strategy.EC2PopulateDefaultLoginCredentialsForImageStrategy;
+import org.jclouds.ec2.domain.Image;
+import org.jclouds.ec2.xml.DescribeImagesResponseHandlerTest;
+import org.jclouds.json.Json;
+import org.jclouds.json.config.GsonModule;
+import org.testng.annotations.Test;
+
+import com.google.common.base.Predicates;
+import com.google.common.base.Suppliers;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+import com.google.gson.Gson;
+import com.google.inject.Guice;
+
+/**
+ * @author Adrian Cole
+ */
+@Test(groups = "unit", testName = "AWSEC2ImageParserTest")
+public class AWSEC2ImageParserTest {
+ public void testParseAlesticCanonicalImage() {
+
+ Set<org.jclouds.compute.domain.Image> result = convertImages("/alestic_canonical.xml");
+
+ assertEquals(
+ Iterables.get(result, 0),
+ new ImageBuilder()
+ .operatingSystem(
+ new OperatingSystem.Builder().family(OsFamily.UBUNTU).arch("paravirtual").version("8.04")
+ .description("ubuntu-images-us/ubuntu-hardy-8.04-i386-server-20091130.manifest.xml")
+ .is64Bit(false).build())
+ .description("ubuntu-images-us/ubuntu-hardy-8.04-i386-server-20091130.manifest.xml")
+ .defaultCredentials(LoginCredentials.builder().user("ubuntu").build()).id("us-east-1/ami-7e28ca17")
+ .providerId("ami-7e28ca17").location(defaultLocation).version("20091130")
+ .userMetadata(ImmutableMap.of(
+ "owner", "099720109477",
+ "rootDeviceType", "instance-store",
+ "virtualizationType", "paravirtual",
+ "hypervisor", "xen"))
+ .status(org.jclouds.compute.domain.Image.Status.AVAILABLE)
+ .backendStatus("available")
+ .build());
+ assertEquals(Iterables.get(result, 0).getStatus(), org.jclouds.compute.domain.Image.Status.AVAILABLE);
+
+ assertEquals(
+ Iterables.get(result, 4),
+ new ImageBuilder()
+ .operatingSystem(
+ new OperatingSystem.Builder().family(OsFamily.UBUNTU).arch("paravirtual").version("8.04")
+ .description("alestic/ubuntu-8.04-hardy-base-20080905.manifest.xml").is64Bit(false)
+ .build()).description("alestic/ubuntu-8.04-hardy-base-20080905.manifest.xml")
+ .defaultCredentials(LoginCredentials.builder().user("ubuntu").build()).id("us-east-1/ami-c0fa1ea9")
+ .providerId("ami-c0fa1ea9").location(defaultLocation).version("20080905")
+ .userMetadata(ImmutableMap.of("owner", "063491364108", "rootDeviceType", "instance-store"))
+ .status(org.jclouds.compute.domain.Image.Status.AVAILABLE).backendStatus("available").build());
+ assertEquals(Iterables.get(result, 4).getStatus(), org.jclouds.compute.domain.Image.Status.AVAILABLE);
+
+ assertEquals(
+ Iterables.get(result, 6),
+ new ImageBuilder()
+ .name("ebs/ubuntu-images/ubuntu-lucid-10.04-i386-server-20100827")
+ .operatingSystem(
+ new OperatingSystem.Builder().family(OsFamily.UBUNTU).arch("paravirtual").version("10.04")
+ .description("099720109477/ebs/ubuntu-images/ubuntu-lucid-10.04-i386-server-20100827")
+ .is64Bit(false).build())
+ .description("099720109477/ebs/ubuntu-images/ubuntu-lucid-10.04-i386-server-20100827")
+ .defaultCredentials(LoginCredentials.builder().user("ubuntu").build()).id("us-east-1/ami-10f3a255")
+ .providerId("ami-10f3a255").location(defaultLocation).version("20100827")
+ .userMetadata(ImmutableMap.of(
+ "owner", "099720109477",
+ "rootDeviceType", "ebs",
+ "virtualizationType", "paravirtual",
+ "hypervisor", "xen"))
+ .status(org.jclouds.compute.domain.Image.Status.AVAILABLE).backendStatus("available").build());
+ assertEquals(Iterables.get(result, 6).getStatus(), org.jclouds.compute.domain.Image.Status.AVAILABLE);
+
+ }
+
+ public void testParseVostokImage() {
+
+ Set<org.jclouds.compute.domain.Image> result = convertImages("/vostok.xml");
+
+ assertEquals(
+ Iterables.get(result, 0),
+ new ImageBuilder()
+ .operatingSystem(
+ new OperatingSystem.Builder().family(OsFamily.UNRECOGNIZED).arch("paravirtual").version("")
+ .description("vostok-builds/vostok-0.95-5622/vostok-0.95-5622.manifest.xml")
+ .is64Bit(false).build())
+ .description("vostok-builds/vostok-0.95-5622/vostok-0.95-5622.manifest.xml")
+ .defaultCredentials(LoginCredentials.builder().user("root").build()).id("us-east-1/ami-870de2ee")
+ .providerId("ami-870de2ee").location(defaultLocation).version("5622")
+ .userMetadata(ImmutableMap.of("owner", "133804938231", "rootDeviceType", "instance-store"))
+ .status(org.jclouds.compute.domain.Image.Status.AVAILABLE).build());
+
+ }
+
+ public void testParseCCImage() {
+
+ Set<org.jclouds.compute.domain.Image> result = convertImages("/describe_images_cc.xml");
+
+ assertEquals(
+ Iterables.get(result, 0),
+ new ImageBuilder()
+ .name("EC2 CentOS 5.4 HVM AMI")
+ .operatingSystem(
+ new OperatingSystem.Builder().family(OsFamily.CENTOS).arch("hvm").version("5.4")
+ .description("amazon/EC2 CentOS 5.4 HVM AMI").is64Bit(true).build())
+ .description("EC2 CentOS 5.4 HVM AMI")
+ .defaultCredentials(LoginCredentials.builder().user("root").build()).id("us-east-1/ami-7ea24a17")
+ .providerId("ami-7ea24a17").location(defaultLocation)
+ .userMetadata(ImmutableMap.of(
+ "owner", "206029621532",
+ "rootDeviceType", "ebs",
+ "virtualizationType", "hvm",
+ "hypervisor", "xen"))
+ .status(org.jclouds.compute.domain.Image.Status.AVAILABLE).build());
+ assertEquals(Iterables.get(result, 0).getStatus(), org.jclouds.compute.domain.Image.Status.AVAILABLE);
+
+ }
+
+ public void testParseRightScaleImage() {
+
+ Set<org.jclouds.compute.domain.Image> result = convertImages("/rightscale_images.xml");
+
+ assertEquals(
+ Iterables.get(result, 0),
+ new ImageBuilder()
+ .operatingSystem(
+ new OperatingSystem.Builder().family(OsFamily.CENTOS).arch("paravirtual").version("5.4")
+ .description("rightscale-us-east/CentOS_5.4_x64_v4.4.10.manifest.xml").is64Bit(true)
+ .build()).description("rightscale-us-east/CentOS_5.4_x64_v4.4.10.manifest.xml")
+ .defaultCredentials(LoginCredentials.builder().user("root").build()).id("us-east-1/ami-ccb35ea5")
+ .providerId("ami-ccb35ea5").location(defaultLocation).version("4.4.10")
+ .userMetadata(ImmutableMap.of("owner", "admin", "rootDeviceType", "instance-store"))
+ .status(org.jclouds.compute.domain.Image.Status.AVAILABLE).backendStatus("available").build());
+ assertEquals(Iterables.get(result, 0).getStatus(), org.jclouds.compute.domain.Image.Status.AVAILABLE);
+
+ assertEquals(
+ new Gson().toJson(Iterables.get(result, 1)),
+ "{\"operatingSystem\":{\"family\":\"UBUNTU\",\"arch\":\"paravirtual\",\"version\":\"9.10\",\"description\":\"411009282317/RightImage_Ubuntu_9.10_x64_v4.5.3_EBS_Alpha\",\"is64Bit\":true},\"status\":\"AVAILABLE\",\"backendStatus\":\"available\",\"version\":\"4.5.3_EBS_Alpha\",\"description\":\"RightImage_Ubuntu_9.10_x64_v4.5.3_EBS_Alpha\",\"defaultCredentials\":{\"authenticateSudo\":false,\"identity\":\"root\"},\"id\":\"us-east-1/ami-c19db6b5\",\"type\":\"IMAGE\",\"tags\":[],\"providerId\":\"ami-c19db6b5\",\"name\":\"RightImage_Ubuntu_9.10_x64_v4.5.3_EBS_Alpha\",\"location\":{\"scope\":\"REGION\",\"id\":\"us-east-1\",\"description\":\"us-east-1\",\"iso3166Codes\":[],\"metadata\":{}},\"userMetadata\":{\"owner\":\"411009282317\",\"rootDeviceType\":\"ebs\",\"virtualizationType\":\"paravirtual\",\"hypervisor\":\"xen\"}}");
+
+ assertEquals(
+ new Gson().toJson(Iterables.get(result, 2)),
+ "{\"operatingSystem\":{\"family\":\"WINDOWS\",\"arch\":\"hvm\",\"version\":\"2003\",\"description\":\"411009282317/RightImage Windows_2003_i386_v5.4.3\",\"is64Bit\":false},\"status\":\"AVAILABLE\",\"backendStatus\":\"available\",\"version\":\"5.4.3\",\"description\":\"Built by RightScale\",\"defaultCredentials\":{\"authenticateSudo\":false,\"identity\":\"root\"},\"id\":\"us-east-1/ami-710c2605\",\"type\":\"IMAGE\",\"tags\":[],\"providerId\":\"ami-710c2605\",\"name\":\"RightImage Windows_2003_i386_v5.4.3\",\"location\":{\"scope\":\"REGION\",\"id\":\"us-east-1\",\"description\":\"us-east-1\",\"iso3166Codes\":[],\"metadata\":{}},\"userMetadata\":{\"owner\":\"411009282317\",\"rootDeviceType\":\"ebs\",\"virtualizationType\":\"hvm\",\"hypervisor\":\"xen\"}}");
+ }
+
+ public void testParseAmznImage() {
+
+ Set<org.jclouds.compute.domain.Image> result = convertImages("/amzn_images.xml");
+
+ assertEquals(
+ Iterables.get(result, 0),
+ new ImageBuilder()
+ .name("amzn-ami-0.9.7-beta.i386-ebs")
+ .operatingSystem(
+ new OperatingSystem.Builder().family(OsFamily.AMZN_LINUX).arch("paravirtual")
+ .version("0.9.7-beta").description("137112412989/amzn-ami-0.9.7-beta.i386-ebs")
+ .is64Bit(false).build()).description("Amazon")
+ .defaultCredentials(LoginCredentials.builder().user("ec2-user").build()).id("us-east-1/ami-82e4b5c7")
+ .providerId("ami-82e4b5c7").location(defaultLocation).version("0.9.7-beta")
+ .userMetadata(ImmutableMap.of(
+ "owner", "137112412989",
+ "rootDeviceType", "ebs",
+ "virtualizationType", "paravirtual",
+ "hypervisor", "xen"))
+ .status(org.jclouds.compute.domain.Image.Status.AVAILABLE).build());
+ assertEquals(Iterables.get(result, 0).getStatus(), org.jclouds.compute.domain.Image.Status.AVAILABLE);
+
+ assertEquals(
+ Iterables.get(result, 3),
+ new ImageBuilder()
+ .name("amzn-ami-0.9.7-beta.x86_64-S3")
+ .operatingSystem(
+ new OperatingSystem.Builder().family(OsFamily.AMZN_LINUX).arch("paravirtual")
+ .version("0.9.7-beta")
+ .description("amzn-ami-us-west-1/amzn-ami-0.9.7-beta.x86_64.manifest.xml").is64Bit(true)
+ .build()).description("Amazon Linux AMI x86_64 S3")
+ .defaultCredentials(LoginCredentials.builder().user("ec2-user").build()).id("us-east-1/ami-f2e4b5b7")
+ .providerId("ami-f2e4b5b7").location(defaultLocation).version("0.9.7-beta")
+ .userMetadata(ImmutableMap.of(
+ "owner", "137112412989",
+ "rootDeviceType", "ebs",
+ "virtualizationType", "paravirtual",
+ "hypervisor", "xen"))
+ .status(org.jclouds.compute.domain.Image.Status.AVAILABLE).build());
+ assertEquals(Iterables.get(result, 3).getStatus(), org.jclouds.compute.domain.Image.Status.AVAILABLE);
+
+ }
+
+ static Location defaultLocation = new LocationBuilder().scope(LocationScope.REGION).id("us-east-1")
+ .description("us-east-1").build();
+
+ public static Set<org.jclouds.compute.domain.Image> convertImages(String resource) {
+
+ Map<OsFamily, Map<String, String>> map = new BaseComputeServiceContextModule() {
+ }.provideOsVersionMap(new ComputeServiceConstants.ReferenceData(), Guice.createInjector(new GsonModule())
+ .getInstance(Json.class));
+
+ Set<Image> result = DescribeImagesResponseHandlerTest.parseImages(resource);
+ EC2ImageParser parser = new EC2ImageParser(EC2ComputeServiceDependenciesModule.toPortableImageStatus,
+ new EC2PopulateDefaultLoginCredentialsForImageStrategy(), map, Suppliers
+ .<Set<? extends Location>> ofInstance(ImmutableSet.<Location> of(defaultLocation)), Suppliers
+ .ofInstance(defaultLocation), new AWSEC2ReviseParsedImage(map));
+ return Sets.newLinkedHashSet(Iterables.filter(Iterables.transform(result, parser), Predicates.notNull()));
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/60b2f3fa/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/AWSEC2ReviseParsedImageTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/AWSEC2ReviseParsedImageTest.java b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/AWSEC2ReviseParsedImageTest.java
new file mode 100644
index 0000000..e63a9b4
--- /dev/null
+++ b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/AWSEC2ReviseParsedImageTest.java
@@ -0,0 +1,111 @@
+/*
+ * 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.aws.ec2.compute.strategy;
+
+import static org.testng.Assert.assertEquals;
+
+import java.util.Map;
+
+import org.jclouds.compute.config.BaseComputeServiceContextModule;
+import org.jclouds.compute.domain.ImageBuilder;
+import org.jclouds.compute.domain.OperatingSystem;
+import org.jclouds.compute.domain.OsFamily;
+import org.jclouds.compute.reference.ComputeServiceConstants;
+import org.jclouds.ec2.compute.strategy.ReviseParsedImage;
+import org.jclouds.ec2.domain.Hypervisor;
+import org.jclouds.ec2.domain.Image;
+import org.jclouds.ec2.domain.RootDeviceType;
+import org.jclouds.ec2.domain.VirtualizationType;
+import org.jclouds.json.Json;
+import org.jclouds.json.config.GsonModule;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.inject.Guice;
+
+public class AWSEC2ReviseParsedImageTest {
+ private Map<OsFamily, Map<String, String>> osVersionMap;
+
+ @BeforeClass
+ public void testFixtureSetUp() {
+ osVersionMap = new BaseComputeServiceContextModule() {
+ }.provideOsVersionMap(new ComputeServiceConstants.ReferenceData(), Guice.createInjector(new GsonModule())
+ .getInstance(Json.class));
+ }
+
+ @Test
+ public void testNewWindowsName() throws Exception {
+
+ ReviseParsedImage rpi = new AWSEC2ReviseParsedImage(osVersionMap);
+
+ Image from = newImage("amazon", "Windows_Server-2008-R2_SP1-English-64Bit-Base-2012.03.13");
+ OperatingSystem.Builder osBuilder = OperatingSystem.builder().description("test");
+ ImageBuilder builder = new ImageBuilder().id("1").operatingSystem(osBuilder.build()).status(
+ org.jclouds.compute.domain.Image.Status.AVAILABLE).description("test");
+ OsFamily family = OsFamily.WINDOWS;
+
+ rpi.reviseParsedImage(from, builder, family, osBuilder);
+ OperatingSystem os = osBuilder.build();
+ assertEquals(os.getFamily(), OsFamily.WINDOWS);
+ assertEquals(os.getVersion(), "2008");
+ assertEquals(builder.build().getVersion(), "2012.03.13");
+ }
+
+ @Test
+ public void testOldWindowsName() throws Exception {
+
+ ReviseParsedImage rpi = new AWSEC2ReviseParsedImage(osVersionMap);
+
+ Image from = newImage("amazon", "Windows-2008R2-SP1-English-Base-2012.01.12");
+ OperatingSystem.Builder osBuilder = OperatingSystem.builder().description("test");
+ ImageBuilder builder = new ImageBuilder().id("1").operatingSystem(osBuilder.build()).status(
+ org.jclouds.compute.domain.Image.Status.AVAILABLE).description("test");
+ OsFamily family = OsFamily.WINDOWS;
+
+ rpi.reviseParsedImage(from, builder, family, osBuilder);
+ OperatingSystem os = osBuilder.build();
+ assertEquals(os.getFamily(), OsFamily.WINDOWS);
+ assertEquals(os.getVersion(), "2008");
+ assertEquals(builder.build().getVersion(), "2012.01.12");
+ }
+
+ private static Image newImage(String imageOwnerId, String imageName) {
+ String region = "us-east-1";
+ Image.Architecture architecture = Image.Architecture.X86_64;
+ String description = "";
+ String imageId = "";
+ Image.ImageState imageState = Image.ImageState.AVAILABLE;
+ Image.ImageType imageType = Image.ImageType.MACHINE;
+ boolean isPublic = true;
+ Iterable<String> productCodes = ImmutableSet.of();
+ String kernelId = "";
+ String platform = "";
+ String ramdiskId = "";
+ RootDeviceType rootDeviceType = RootDeviceType.EBS;
+ String rootDeviceName = "";
+ Map<String, Image.EbsBlockDevice> ebsBlockDevices = ImmutableMap.of();
+ Map<String, String> tags = ImmutableMap.of();
+ VirtualizationType virtualizationType = VirtualizationType.HVM;
+ Hypervisor hypervisor = Hypervisor.XEN;
+ Image from = new Image(region, architecture, imageName, description, imageId, imageOwnerId + "/" + imageName,
+ imageOwnerId, imageState, "available", imageType, isPublic, productCodes, kernelId, platform, ramdiskId,
+ rootDeviceType, rootDeviceName, ebsBlockDevices, tags, virtualizationType, hypervisor);
+ return from;
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/60b2f3fa/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptionsTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptionsTest.java b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptionsTest.java
new file mode 100644
index 0000000..1cc6fcf
--- /dev/null
+++ b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/compute/strategy/CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptionsTest.java
@@ -0,0 +1,957 @@
+/*
+ * 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.aws.ec2.compute.strategy;
+
+import static com.google.common.base.Charsets.UTF_8;
+import static com.google.common.io.BaseEncoding.base64;
+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.aws.ec2.compute.AWSEC2TemplateOptions.Builder.keyPair;
+import static org.jclouds.ec2.compute.strategy.CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptionsTest.CREDENTIALS;
+import static org.jclouds.ec2.compute.strategy.CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptionsTest.KEYPAIR;
+import static org.testng.Assert.assertEquals;
+
+import java.lang.reflect.Method;
+import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
+
+import javax.inject.Provider;
+
+import org.jclouds.aws.domain.Region;
+import org.jclouds.aws.ec2.compute.AWSEC2TemplateOptions;
+import org.jclouds.aws.ec2.domain.PlacementGroup;
+import org.jclouds.aws.ec2.domain.RegionNameAndPublicKeyMaterial;
+import org.jclouds.aws.ec2.functions.CreatePlacementGroupIfNeeded;
+import org.jclouds.aws.ec2.options.AWSRunInstancesOptions;
+import org.jclouds.compute.domain.Hardware;
+import org.jclouds.compute.domain.Template;
+import org.jclouds.compute.functions.GroupNamingConvention;
+import org.jclouds.compute.options.TemplateOptions;
+import org.jclouds.domain.LoginCredentials;
+import org.jclouds.ec2.compute.EC2TemplateBuilderTest;
+import org.jclouds.ec2.compute.domain.EC2HardwareBuilder;
+import org.jclouds.ec2.compute.domain.RegionAndName;
+import org.jclouds.ec2.compute.domain.RegionNameAndIngressRules;
+import org.jclouds.ec2.compute.options.EC2TemplateOptions;
+import org.jclouds.ec2.compute.strategy.CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions;
+import org.jclouds.ec2.domain.BlockDeviceMapping;
+import org.jclouds.ec2.domain.KeyPair;
+import org.jclouds.ec2.options.RunInstancesOptions;
+import org.jclouds.scriptbuilder.domain.Statements;
+import org.testng.annotations.Test;
+
+import com.google.common.base.Function;
+import com.google.common.cache.LoadingCache;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * @author Adrian Cole
+ */
+@Test(groups = "unit", singleThreaded = true, testName = "CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptionsTest")
+public class CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptionsTest {
+ private static final Provider<RunInstancesOptions> OPTIONS_PROVIDER = new javax.inject.Provider<RunInstancesOptions>() {
+
+ @Override
+ public RunInstancesOptions get() {
+ return new AWSRunInstancesOptions();
+ }
+
+ };
+
+ @Test(enabled = false)
+ public void testExecuteWithDefaultOptionsEC2() throws SecurityException, NoSuchMethodException {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ Hardware size = EC2HardwareBuilder.m1_small().build();
+ String systemGeneratedKeyPairName = "systemGeneratedKeyPair";
+ String generatedGroup = "group";
+ Set<String> generatedGroups = ImmutableSet.of(generatedGroup);
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = createMock(
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class,
+ new Method[] {
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class
+ .getDeclaredMethod("getOptionsProvider"),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewKeyPairUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewPlacementGroupUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "getSecurityGroupsForTagAndOptions", String.class, String.class, TemplateOptions.class) });
+
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ Template template = createMock(Template.class);
+
+ // setup expectations
+ expect(strategy.getOptionsProvider()).andReturn(OPTIONS_PROVIDER);
+ expect(template.getHardware()).andReturn(size).atLeastOnce();
+ expect(template.getOptions()).andReturn(options).atLeastOnce();
+ expect(options.getBlockDeviceMappings()).andReturn(ImmutableSet.<BlockDeviceMapping> of()).atLeastOnce();
+ expect(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options)).andReturn(
+ systemGeneratedKeyPairName);
+ expect(strategy.getSecurityGroupsForTagAndOptions(region, group, options)).andReturn(generatedGroups);
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getSubnetId()).andReturn(null);
+ expect(options.getUserData()).andReturn(null);
+ expect(options.isMonitoringEnabled()).andReturn(false);
+
+ // replay mocks
+ replay(options);
+ replay(template);
+ replay(strategy);
+
+ // run
+ RunInstancesOptions customize = strategy.execute(region, group, template);
+ assertEquals(customize.buildQueryParameters(), ImmutableMultimap.<String, String> of());
+ assertEquals(
+ customize.buildFormParameters().entries(),
+ ImmutableMultimap.<String, String> of("InstanceType", size.getProviderId(), "SecurityGroup.1",
+ generatedGroup, "KeyName", systemGeneratedKeyPairName).entries());
+ assertEquals(customize.buildRequestHeaders(), ImmutableMultimap.<String, String> of());
+ assertEquals(customize.buildStringPayload(), null);
+
+ // verify mocks
+ verify(options);
+ verify(template);
+ verify(strategy);
+ }
+
+ @Test(enabled = false)
+ public void testExecuteForCCAutomatic() throws SecurityException, NoSuchMethodException {
+ // setup constants
+ String region = Region.US_EAST_1;
+ String group = "group";
+ Hardware size = EC2TemplateBuilderTest.CC1_4XLARGE;
+ String systemGeneratedKeyPairName = "systemGeneratedKeyPair";
+ String generatedGroup = "group";
+ Set<String> generatedGroups = ImmutableSet.of(generatedGroup);
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = createMock(
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class,
+ new Method[] {
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class
+ .getDeclaredMethod("getOptionsProvider"),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewKeyPairUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewPlacementGroupUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "getSecurityGroupsForTagAndOptions", String.class, String.class, TemplateOptions.class) });
+
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ Template template = createMock(Template.class);
+
+ // setup expectations
+ expect(strategy.getOptionsProvider()).andReturn(OPTIONS_PROVIDER);
+ expect(template.getHardware()).andReturn(size).atLeastOnce();
+ expect(template.getOptions()).andReturn(options).atLeastOnce();
+ expect(options.getBlockDeviceMappings()).andReturn(ImmutableSet.<BlockDeviceMapping> of()).atLeastOnce();
+ expect(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options)).andReturn(
+ systemGeneratedKeyPairName);
+ expect(strategy.createNewPlacementGroupUnlessUserSpecifiedOtherwise(region, group, options)).andReturn(
+ generatedGroup);
+ expect(strategy.getSecurityGroupsForTagAndOptions(region, group, options)).andReturn(generatedGroups);
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getSubnetId()).andReturn(null);
+ expect(options.getUserData()).andReturn(null);
+ expect(options.isMonitoringEnabled()).andReturn(false);
+
+ // replay mocks
+ replay(options);
+ replay(template);
+ replay(strategy);
+
+ // run
+ RunInstancesOptions customize = strategy.execute(region, group, template);
+ assertEquals(customize.buildQueryParameters(), ImmutableMultimap.<String, String> of());
+ assertEquals(
+ customize.buildFormParameters().entries(),
+ ImmutableMultimap.<String, String> of("InstanceType", size.getProviderId(), "SecurityGroup.1",
+ generatedGroup, "KeyName", systemGeneratedKeyPairName, "Placement.GroupName", generatedGroup)
+ .entries());
+ assertEquals(customize.buildRequestHeaders(), ImmutableMultimap.<String, String> of());
+ assertEquals(customize.buildStringPayload(), null);
+
+ // verify mocks
+ verify(options);
+ verify(template);
+ verify(strategy);
+ }
+
+ @Test(enabled = false)
+ public void testExecuteForCCUserSpecified() throws SecurityException, NoSuchMethodException {
+ // setup constants
+ String region = Region.US_EAST_1;
+ String group = "group";
+ Hardware size = EC2TemplateBuilderTest.CC1_4XLARGE;
+ String systemGeneratedKeyPairName = "systemGeneratedKeyPair";
+ String generatedGroup = "group";
+ Set<String> generatedGroups = ImmutableSet.of(generatedGroup);
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = createMock(
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class,
+ new Method[] {
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class
+ .getDeclaredMethod("getOptionsProvider"),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewKeyPairUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewPlacementGroupUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "getSecurityGroupsForTagAndOptions", String.class, String.class, TemplateOptions.class) });
+
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ Template template = createMock(Template.class);
+
+ // setup expectations
+ expect(strategy.getOptionsProvider()).andReturn(OPTIONS_PROVIDER);
+ expect(template.getHardware()).andReturn(size).atLeastOnce();
+ expect(template.getOptions()).andReturn(options).atLeastOnce();
+ expect(options.getBlockDeviceMappings()).andReturn(ImmutableSet.<BlockDeviceMapping> of()).atLeastOnce();
+ expect(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options)).andReturn(
+ systemGeneratedKeyPairName);
+ expect(strategy.createNewPlacementGroupUnlessUserSpecifiedOtherwise(region, group, options)).andReturn(
+ generatedGroup);
+ expect(strategy.getSecurityGroupsForTagAndOptions(region, group, options)).andReturn(generatedGroups);
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getSubnetId()).andReturn(null);
+ expect(options.getUserData()).andReturn(null);
+ expect(options.isMonitoringEnabled()).andReturn(false);
+
+ // replay mocks
+ replay(options);
+ replay(template);
+ replay(strategy);
+
+ // run
+ RunInstancesOptions customize = strategy.execute(region, group, template);
+ assertEquals(customize.buildQueryParameters(), ImmutableMultimap.<String, String> of());
+ assertEquals(
+ customize.buildFormParameters().entries(),
+ ImmutableMultimap.<String, String> of("InstanceType", size.getProviderId(), "SecurityGroup.1",
+ generatedGroup, "KeyName", systemGeneratedKeyPairName, "Placement.GroupName", generatedGroup)
+ .entries());
+ assertEquals(customize.buildRequestHeaders(), ImmutableMultimap.<String, String> of());
+ assertEquals(customize.buildStringPayload(), null);
+
+ // verify mocks
+ verify(options);
+ verify(template);
+ verify(strategy);
+ }
+
+ @Test(enabled = false)
+ public void testExecuteWithSubnet() throws SecurityException, NoSuchMethodException {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ Hardware size = EC2HardwareBuilder.m1_small().build();
+ String systemGeneratedKeyPairName = "systemGeneratedKeyPair";
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = createMock(
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class,
+ new Method[] {
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class
+ .getDeclaredMethod("getOptionsProvider"),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewKeyPairUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewPlacementGroupUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "getSecurityGroupsForTagAndOptions", String.class, String.class, TemplateOptions.class) });
+
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ Template template = createMock(Template.class);
+
+ // setup expectations
+ expect(strategy.getOptionsProvider()).andReturn(OPTIONS_PROVIDER);
+ expect(template.getHardware()).andReturn(size).atLeastOnce();
+ expect(template.getOptions()).andReturn(options).atLeastOnce();
+ expect(options.getBlockDeviceMappings()).andReturn(ImmutableSet.<BlockDeviceMapping> of()).atLeastOnce();
+ expect(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options)).andReturn(
+ systemGeneratedKeyPairName);
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getSubnetId()).andReturn("1");
+ expect(options.getUserData()).andReturn(null);
+ expect(options.isMonitoringEnabled()).andReturn(false);
+
+ // replay mocks
+ replay(options);
+ replay(template);
+ replay(strategy);
+
+ // run
+ RunInstancesOptions customize = strategy.execute(region, group, template);
+ assertEquals(customize.buildQueryParameters(), ImmutableMultimap.<String, String> of());
+ assertEquals(
+ customize.buildFormParameters().entries(),
+ ImmutableMultimap.<String, String> of("InstanceType", size.getProviderId(), "SubnetId", "1", "KeyName",
+ systemGeneratedKeyPairName).entries());
+ assertEquals(customize.buildRequestHeaders(), ImmutableMultimap.<String, String> of());
+ assertEquals(customize.buildStringPayload(), null);
+
+ // verify mocks
+ verify(options);
+ verify(template);
+ verify(strategy);
+ }
+
+ @Test(enabled = false)
+ public void testExecuteWithUserData() throws SecurityException, NoSuchMethodException {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ Hardware size = EC2HardwareBuilder.m1_small().build();
+ String systemGeneratedKeyPairName = "systemGeneratedKeyPair";
+ String generatedGroup = "group";
+ Set<String> generatedGroups = ImmutableSet.of(generatedGroup);
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = createMock(
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class,
+ new Method[] {
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class
+ .getDeclaredMethod("getOptionsProvider"),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewKeyPairUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "createNewPlacementGroupUnlessUserSpecifiedOtherwise", String.class, String.class,
+ TemplateOptions.class),
+ CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class.getDeclaredMethod(
+ "getSecurityGroupsForTagAndOptions", String.class, String.class, TemplateOptions.class) });
+
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ Template template = createMock(Template.class);
+
+ // setup expectations
+ expect(strategy.getOptionsProvider()).andReturn(OPTIONS_PROVIDER);
+ expect(template.getHardware()).andReturn(size).atLeastOnce();
+ expect(template.getOptions()).andReturn(options).atLeastOnce();
+ expect(options.getBlockDeviceMappings()).andReturn(ImmutableSet.<BlockDeviceMapping> of()).atLeastOnce();
+ expect(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options)).andReturn(
+ systemGeneratedKeyPairName);
+ expect(strategy.getSecurityGroupsForTagAndOptions(region, group, options)).andReturn(generatedGroups);
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getSubnetId()).andReturn(null);
+ expect(options.getUserData()).andReturn("hello".getBytes());
+ expect(options.isMonitoringEnabled()).andReturn(false);
+
+ // replay mocks
+ replay(options);
+ replay(template);
+ replay(strategy);
+
+ // run
+ RunInstancesOptions customize = strategy.execute(region, group, template);
+ assertEquals(customize.buildQueryParameters(), ImmutableMultimap.<String, String> of());
+ assertEquals(
+ customize.buildFormParameters().entries(),
+ ImmutableMultimap.<String, String> of("InstanceType", size.getProviderId(), "SecurityGroup.1", "group",
+ "KeyName", systemGeneratedKeyPairName, "UserData", base64().encode("hello".getBytes(UTF_8))).entries());
+ assertEquals(customize.buildRequestHeaders(), ImmutableMultimap.<String, String> of());
+ assertEquals(customize.buildStringPayload(), null);
+
+ // verify mocks
+ verify(options);
+ verify(template);
+ verify(strategy);
+ }
+
+ @Test(expectedExceptions = IllegalArgumentException.class)
+ public void testCreateNewKeyPairUnlessUserSpecifiedOtherwise_reusesKeyWhenToldToWithRunScriptButNoCredentials() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String userSuppliedKeyPair = "myKeyPair";
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ EC2TemplateOptions options = createMock(EC2TemplateOptions.class);
+ KeyPair keyPair = createMock(KeyPair.class);
+
+ // setup expectations
+ expect(options.getKeyPair()).andReturn(userSuppliedKeyPair);
+ expect(options.getPublicKey()).andReturn(null).times(2);
+ expect(options.getLoginPrivateKey()).andReturn(null);
+ expect(options.getRunScript()).andReturn(Statements.exec("echo foo"));
+ expect(strategy.credentialsMap.containsKey(new RegionAndName(region, userSuppliedKeyPair))).andReturn(false);
+
+ // replay mocks
+ replay(options);
+ replay(keyPair);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options), userSuppliedKeyPair);
+
+ // verify mocks
+ verify(options);
+ verify(keyPair);
+ verifyStrategy(strategy);
+ }
+
+ public void testCreateNewKeyPairUnlessUserSpecifiedOtherwise_reusesKeyWhenToldToWithRunScriptAndCredentialsAlreadyInMap() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String userSuppliedKeyPair = "myKeyPair";
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ EC2TemplateOptions options = createMock(EC2TemplateOptions.class);
+ KeyPair keyPair = createMock(KeyPair.class);
+
+ // setup expectations
+ expect(options.getPublicKey()).andReturn(null).times(2);
+ expect(options.getKeyPair()).andReturn(userSuppliedKeyPair);
+ expect(options.getLoginPrivateKey()).andReturn(null);
+ expect(options.getRunScript()).andReturn(Statements.exec("echo foo"));
+ expect(strategy.credentialsMap.containsKey(new RegionAndName(region, userSuppliedKeyPair))).andReturn(true);
+
+ // replay mocks
+ replay(options);
+ replay(keyPair);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options), userSuppliedKeyPair);
+
+ // verify mocks
+ verify(options);
+ verify(keyPair);
+ verifyStrategy(strategy);
+ }
+
+ public void testCreateNewKeyPairUnlessUserSpecifiedOtherwise_ImportPublicKeyWhenOptionIsSet() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String userSuppliedKeyPair = "myKeyPair";
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ EC2TemplateOptions options = createMock(EC2TemplateOptions.class);
+ KeyPair keyPair = createMock(KeyPair.class);
+
+ // we specify we have a public key we want to use for authentication
+ expect(options.getPublicKey()).andReturn("ssh-rsa").times(2);
+ expect(options.getLoginPrivateKey()).andReturn(CREDENTIALS.getPrivateKey()).atLeastOnce();
+
+ // Here, we import the keypair and place it into the cache
+ expect(strategy.importExistingKeyPair.apply(new RegionNameAndPublicKeyMaterial(region, group, "ssh-rsa")))
+ .andReturn(KEYPAIR);
+ expect(options.dontAuthorizePublicKey()).andReturn(options);
+ expect(strategy.credentialsMap.put(new RegionAndName(region, group), KEYPAIR)).andReturn(null);
+ expect(options.getRunScript()).andReturn(Statements.exec("echo foo"));
+
+ // replay mocks
+ replay(options);
+ replay(keyPair);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options), userSuppliedKeyPair);
+
+ // verify mocks
+ verify(options);
+ verify(keyPair);
+ verifyStrategy(strategy);
+ }
+
+ @Test
+ public void testCreateNewKeyPairUnlessUserSpecifiedOtherwise_importsKeyPairAndUnsetsTemplateInstructionWhenPublicKeySuppliedAndAddsCredentialToMapWhenOverridingCredsAreSet() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = keyPair(group).authorizePublicKey("ssh-rsa").overrideLoginCredentials(
+ LoginCredentials.builder().user("foo").privateKey(CREDENTIALS.credential).build());
+ KeyPair keyPair = new KeyPair(region, group, "//TODO", null, null);
+
+ // setup expectations
+ expect(
+ strategy.importExistingKeyPair.apply(new RegionNameAndPublicKeyMaterial(region, group,
+ CREDENTIALS.credential))).andReturn(keyPair);
+ expect(
+ strategy.credentialsMap.put(new RegionAndName(region, group),
+ keyPair.toBuilder().keyMaterial(CREDENTIALS.credential).build())).andReturn(null);
+
+ // replay mocks
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options), group);
+
+ // verify mocks
+ verifyStrategy(strategy);
+ }
+
+ @Test
+ public void testCreateNewKeyPairUnlessUserSpecifiedOtherwise_importsKeyPairAndUnsetsTemplateInstructionWhenPublicKeySupplied() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ AWSEC2TemplateOptions options = keyPair(group).authorizePublicKey("ssh-rsa");
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+
+ KeyPair keyPair = new KeyPair(region, "jclouds#" + group, "fingerprint", null, null);
+
+ // setup expectations
+ expect(strategy.importExistingKeyPair.apply(new RegionNameAndPublicKeyMaterial(region, group, "ssh-rsa")))
+ .andReturn(keyPair);
+ expect(strategy.credentialsMap.put(new RegionAndName(region, group), keyPair)).andReturn(null);
+
+ // replay mocks
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options), "jclouds#" + group);
+
+ // verify mocks
+ verifyStrategy(strategy);
+ }
+
+ public void testCreateNewKeyPairUnlessUserSpecifiedOtherwise_createsNewKeyPairAndReturnsItsNameWhenNoPublicKeySupplied() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String userSuppliedKeyPair = null;
+ boolean shouldAutomaticallyCreateKeyPair = true;
+ String systemGeneratedKeyPairName = "systemGeneratedKeyPair";
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ KeyPair keyPair = createMock(KeyPair.class);
+
+ // setup expectations
+ expect(options.getKeyPair()).andReturn(userSuppliedKeyPair);
+ expect(options.shouldAutomaticallyCreateKeyPair()).andReturn(shouldAutomaticallyCreateKeyPair);
+ expect(strategy.credentialsMap.containsKey(new RegionAndName(region, group))).andReturn(true);
+ expect(strategy.credentialsMap.get(new RegionAndName(region, group))).andReturn(keyPair);
+ expect(options.getPublicKey()).andReturn(null).times(2);
+ expect(keyPair.getKeyName()).andReturn(systemGeneratedKeyPairName).atLeastOnce();
+ expect(options.getRunScript()).andReturn(null);
+
+ // replay mocks
+ replay(options);
+ replay(keyPair);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options),
+ systemGeneratedKeyPairName);
+
+ // verify mocks
+ verify(options);
+ verify(keyPair);
+ verifyStrategy(strategy);
+ }
+
+ public void testCreateNewKeyPairUnlessUserSpecifiedOtherwise_returnsExistingKeyIfAlreadyPresent() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String systemGeneratedKeyPairName = "systemGeneratedKeyPair";
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ KeyPair keyPair = createMock(KeyPair.class);
+
+ // setup expectations
+ expect(options.getLoginPrivateKey()).andReturn(null);
+ expect(options.getRunScript()).andReturn(Statements.exec("echo hello"));
+ expect(options.getPublicKey()).andReturn(null).times(2);
+ expect(options.getKeyPair()).andReturn(systemGeneratedKeyPairName);
+ expect(strategy.credentialsMap.containsKey(new RegionAndName(region, systemGeneratedKeyPairName)))
+ .andReturn(true);
+
+ // replay mocks
+ replay(options);
+ replay(keyPair);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options),
+ systemGeneratedKeyPairName);
+
+ // verify mocks
+ verify(options);
+ verify(keyPair);
+ verifyStrategy(strategy);
+ }
+
+ public void testCreateNewKeyPairUnlessUserSpecifiedOtherwise_doesntCreateAKeyPairAndReturnsNullWhenToldNotTo() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String userSuppliedKeyPair = null;
+ boolean shouldAutomaticallyCreateKeyPair = false; // here's the important
+ // part!
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ KeyPair keyPair = createMock(KeyPair.class);
+
+ // setup expectations
+ expect(options.getPublicKey()).andReturn(null).times(2);
+ expect(options.getKeyPair()).andReturn(userSuppliedKeyPair);
+ expect(options.getRunScript()).andReturn(null);
+ expect(options.shouldAutomaticallyCreateKeyPair()).andReturn(shouldAutomaticallyCreateKeyPair);
+
+ // replay mocks
+ replay(options);
+ replay(keyPair);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewKeyPairUnlessUserSpecifiedOtherwise(region, group, options), null);
+
+ // verify mocks
+ verify(options);
+ verify(keyPair);
+ verifyStrategy(strategy);
+ }
+
+ public void testGetSecurityGroupsForTagAndOptions_createsNewGroupByDefaultWhenNoPortsAreSpecifiedWhenDoesntExist() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String generatedMarkerGroup = "jclouds#group";
+ Set<String> groupNames = ImmutableSet.<String> of();
+ int[] ports = {};
+ boolean shouldAuthorizeSelf = true;
+ Set<String> returnVal = ImmutableSet.<String> of(generatedMarkerGroup);
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+
+ // setup expectations
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getGroups()).andReturn(groupNames).atLeastOnce();
+ expect(options.getInboundPorts()).andReturn(ports).atLeastOnce();
+ RegionNameAndIngressRules regionNameAndIngressRules = new RegionNameAndIngressRules(region, generatedMarkerGroup,
+ ports, shouldAuthorizeSelf);
+ expect(strategy.securityGroupMap.getUnchecked(regionNameAndIngressRules)).andReturn(group);
+
+ // replay mocks
+ replay(options);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.getSecurityGroupsForTagAndOptions(region, group, options), returnVal);
+
+ // verify mocks
+ verify(options);
+ verifyStrategy(strategy);
+ }
+
+ public void testGetSecurityGroupsForTagAndOptions_createsNewGroupByDefaultWhenPortsAreSpecifiedWhenDoesntExist() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String generatedMarkerGroup = "jclouds#group";
+ Set<String> groupNames = ImmutableSet.<String> of();
+ int[] ports = { 22, 80 };
+ boolean shouldAuthorizeSelf = true;
+ Set<String> returnVal = ImmutableSet.<String> of(generatedMarkerGroup);
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+
+ // setup expectations
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getGroups()).andReturn(groupNames).atLeastOnce();
+ expect(options.getInboundPorts()).andReturn(ports).atLeastOnce();
+ RegionNameAndIngressRules regionNameAndIngressRules = new RegionNameAndIngressRules(region, generatedMarkerGroup,
+ ports, shouldAuthorizeSelf);
+ expect(strategy.securityGroupMap.getUnchecked(regionNameAndIngressRules)).andReturn(generatedMarkerGroup);
+
+ // replay mocks
+ replay(options);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.getSecurityGroupsForTagAndOptions(region, group, options), returnVal);
+
+ // verify mocks
+ verify(options);
+ verifyStrategy(strategy);
+ }
+
+ public void testGetSecurityGroupsForTagAndOptions_reusesGroupByDefaultWhenNoPortsAreSpecifiedWhenDoesExist() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String generatedMarkerGroup = "jclouds#group";
+ Set<String> groupNames = ImmutableSet.<String> of();
+ int[] ports = {};
+ boolean shouldAuthorizeSelf = true;
+ Set<String> returnVal = ImmutableSet.<String> of(generatedMarkerGroup);
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+
+ // setup expectations
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getGroups()).andReturn(groupNames).atLeastOnce();
+ expect(options.getInboundPorts()).andReturn(ports).atLeastOnce();
+ RegionNameAndIngressRules regionNameAndIngressRules = new RegionNameAndIngressRules(region, generatedMarkerGroup,
+ ports, shouldAuthorizeSelf);
+ expect(strategy.securityGroupMap.getUnchecked(regionNameAndIngressRules)).andReturn(generatedMarkerGroup);
+
+ // replay mocks
+ replay(options);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.getSecurityGroupsForTagAndOptions(region, group, options), returnVal);
+
+ // verify mocks
+ verify(options);
+ verifyStrategy(strategy);
+ }
+
+ public void testGetSecurityGroupsForTagAndOptions_reusesGroupByDefaultWhenNoPortsAreSpecifiedWhenDoesExistAndAcceptsUserSuppliedGroups() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String generatedMarkerGroup = "jclouds#group";
+ Set<String> groupNames = ImmutableSet.<String> of("group1", "group2");
+ int[] ports = {};
+ boolean shouldAuthorizeSelf = true;
+ boolean groupExisted = true;
+ Set<String> returnVal = ImmutableSet.<String> of(generatedMarkerGroup, "group1", "group2");
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+
+ // setup expectations
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of());
+ expect(options.getGroups()).andReturn(groupNames).atLeastOnce();
+ RegionNameAndIngressRules regionNameAndIngressRules = new RegionNameAndIngressRules(region, generatedMarkerGroup,
+ ports, shouldAuthorizeSelf);
+
+ expect(strategy.securityGroupMap.getUnchecked(regionNameAndIngressRules))
+ .andReturn(groupExisted ? "group" : null);
+
+ // replay mocks
+ replay(options);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.getSecurityGroupsForTagAndOptions(region, group, options), returnVal);
+
+ // verify mocks
+ verify(options);
+ verifyStrategy(strategy);
+ }
+
+ public void testGetSecurityGroupsForTagAndOptions_reusesGroupByDefaultWhenNoPortsAreSpecifiedWhenDoesExistAndAcceptsUserSuppliedGroupIds() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String generatedMarkerGroup = "jclouds#group";
+ Set<String> groupNames = ImmutableSet.<String> of();
+ int[] ports = {};
+ boolean shouldAuthorizeSelf = true;
+ boolean groupExisted = true;
+ Set<String> returnVal = ImmutableSet.<String> of(generatedMarkerGroup);
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+
+ // setup expectations
+ expect(options.getGroupIds()).andReturn(ImmutableSet.<String> of("group1", "group2"));
+ expect(options.getGroups()).andReturn(groupNames).atLeastOnce();
+ RegionNameAndIngressRules regionNameAndIngressRules = new RegionNameAndIngressRules(region, generatedMarkerGroup,
+ ports, shouldAuthorizeSelf);
+
+ expect(strategy.securityGroupMap.getUnchecked(regionNameAndIngressRules))
+ .andReturn(groupExisted ? "group" : null);
+
+ // replay mocks
+ replay(options);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.getSecurityGroupsForTagAndOptions(region, group, options), returnVal);
+
+ // verify mocks
+ verify(options);
+ verifyStrategy(strategy);
+ }
+
+ public void testCreateNewPlacementGroupUnlessUserSpecifiedOtherwise_reusesKeyWhenToldTo() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String userSuppliedPlacementGroup = "myPlacementGroup";
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ PlacementGroup placementGroup = createMock(PlacementGroup.class);
+
+ // setup expectations
+ expect(options.getPlacementGroup()).andReturn(userSuppliedPlacementGroup);
+
+ // replay mocks
+ replay(options);
+ replay(placementGroup);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewPlacementGroupUnlessUserSpecifiedOtherwise(region, group, options),
+ userSuppliedPlacementGroup);
+
+ // verify mocks
+ verify(options);
+ verify(placementGroup);
+ verifyStrategy(strategy);
+ }
+
+ public void testCreateNewPlacementGroupUnlessUserSpecifiedOtherwise_createsNewPlacementGroupAndReturnsItsNameByDefault() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String userSuppliedPlacementGroup = null;
+ boolean shouldAutomaticallyCreatePlacementGroup = true;
+ String generatedMarkerGroup = "jclouds#group#" + Region.AP_SOUTHEAST_1;
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+
+ // setup expectations
+ expect(options.getPlacementGroup()).andReturn(userSuppliedPlacementGroup);
+ expect(options.shouldAutomaticallyCreatePlacementGroup()).andReturn(shouldAutomaticallyCreatePlacementGroup);
+ expect(strategy.placementGroupMap.getUnchecked(new RegionAndName(region, generatedMarkerGroup))).andReturn(
+ generatedMarkerGroup);
+
+ // replay mocks
+ replay(options);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewPlacementGroupUnlessUserSpecifiedOtherwise(region, group, options),
+ generatedMarkerGroup);
+
+ // verify mocks
+ verify(options);
+ verifyStrategy(strategy);
+ }
+
+ public void testCreateNewPlacementGroupUnlessUserSpecifiedOtherwise_doesntCreateAPlacementGroupAndReturnsNullWhenToldNotTo() {
+ // setup constants
+ String region = Region.AP_SOUTHEAST_1;
+ String group = "group";
+ String userSuppliedPlacementGroup = null;
+ boolean shouldAutomaticallyCreatePlacementGroup = false; // here's the
+ // important
+ // part!
+
+ // create mocks
+ CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy = setupStrategy();
+ AWSEC2TemplateOptions options = createMock(AWSEC2TemplateOptions.class);
+ PlacementGroup placementGroup = createMock(PlacementGroup.class);
+
+ // setup expectations
+ expect(options.getPlacementGroup()).andReturn(userSuppliedPlacementGroup);
+ expect(options.shouldAutomaticallyCreatePlacementGroup()).andReturn(shouldAutomaticallyCreatePlacementGroup);
+
+ // replay mocks
+ replay(options);
+ replay(placementGroup);
+ replayStrategy(strategy);
+
+ // run
+ assertEquals(strategy.createNewPlacementGroupUnlessUserSpecifiedOtherwise(region, group, options), null);
+
+ // verify mocks
+ verify(options);
+ verify(placementGroup);
+ verifyStrategy(strategy);
+ }
+
+ private void verifyStrategy(CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy) {
+ verify(strategy.makeKeyPair);
+ verify(strategy.credentialsMap);
+ verify(strategy.securityGroupMap);
+ verify(strategy.placementGroupMap);
+ verify(strategy.importExistingKeyPair);
+ verify(strategy.createPlacementGroupIfNeeded);
+ }
+
+ @SuppressWarnings("unchecked")
+ private CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions setupStrategy() {
+ Function<RegionAndName, KeyPair> makeKeyPair = createMock(Function.class);
+ ConcurrentMap<RegionAndName, KeyPair> credentialsMap = createMock(ConcurrentMap.class);
+ LoadingCache<RegionAndName, String> securityGroupMap = createMock(LoadingCache.class);
+ LoadingCache<RegionAndName, String> placementGroupMap = createMock(LoadingCache.class);
+ Function<RegionNameAndPublicKeyMaterial, KeyPair> importExistingKeyPair = createMock(Function.class);
+ CreatePlacementGroupIfNeeded createPlacementGroupIfNeeded = createMock(CreatePlacementGroupIfNeeded.class);
+ GroupNamingConvention.Factory namingConventionFactory = createMock(GroupNamingConvention.Factory.class);
+ GroupNamingConvention namingConvention = createMock(GroupNamingConvention.class);
+ expect(namingConventionFactory.create()).andReturn(namingConvention).anyTimes();
+ expect(namingConvention.sharedNameForGroup("group")).andReturn("jclouds#group").anyTimes();
+ replay(namingConventionFactory);
+ replay(namingConvention);
+
+ return new CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions(makeKeyPair, credentialsMap,
+ securityGroupMap, OPTIONS_PROVIDER, placementGroupMap, createPlacementGroupIfNeeded, importExistingKeyPair,
+ namingConventionFactory);
+ }
+
+ private void replayStrategy(CreateKeyPairPlacementAndSecurityGroupsAsNeededAndReturnRunOptions strategy) {
+ replay(strategy.makeKeyPair);
+ replay(strategy.credentialsMap);
+ replay(strategy.securityGroupMap);
+ replay(strategy.placementGroupMap);
+ replay(strategy.importExistingKeyPair);
+ replay(strategy.createPlacementGroupIfNeeded);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/60b2f3fa/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/features/AWSAMIApiLiveTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/features/AWSAMIApiLiveTest.java b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/features/AWSAMIApiLiveTest.java
new file mode 100644
index 0000000..e09c4ac
--- /dev/null
+++ b/dependencies/jclouds/provider/aws-ec2/1.7.1-stratos/src/test/java/org/jclouds/aws/ec2/features/AWSAMIApiLiveTest.java
@@ -0,0 +1,58 @@
+/*
+ * 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.aws.ec2.features;
+
+import static org.jclouds.aws.ec2.options.AWSDescribeImagesOptions.Builder.filters;
+import static org.testng.Assert.assertNotNull;
+
+import java.util.Set;
+
+import org.jclouds.aws.domain.Region;
+import org.jclouds.ec2.domain.Image;
+import org.jclouds.ec2.features.AMIApiLiveTest;
+import org.testng.annotations.Test;
+
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * Tests behavior of {@code AMIApi}
+ *
+ * @author Adrian Cole
+ */
+@Test(groups = "live", singleThreaded = true)
+public class AWSAMIApiLiveTest extends AMIApiLiveTest {
+
+ public AWSAMIApiLiveTest() {
+ provider = "aws-ec2";
+ }
+
+ public void testDescribeImagesCC() {
+ Set<? extends Image> ccResults = client.describeImagesInRegion(Region.US_EAST_1,
+ filters(ImmutableMultimap.<String, String> builder()//
+ .put("virtualization-type", "hvm")//
+ .put("architecture", "x86_64")//
+ .putAll("owner-id", ImmutableSet.<String> of("137112412989", "099720109477"))//
+ .put("hypervisor", "xen")//
+ .put("state", "available")//
+ .put("image-type", "machine")//
+ .put("root-device-type", "ebs")//
+ .build()).ownedBy("137112412989", "099720109477"));
+ assertNotNull(ccResults);
+ assert ccResults.size() >= 34 : ccResults;
+ }
+}