You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stratos.apache.org by ni...@apache.org on 2014/04/02 11:14:20 UTC

[08/25] forking jclouds ec2 api

http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/58fe66df/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/compute/strategy/EC2CreateNodesInGroupThenAddToSetTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/compute/strategy/EC2CreateNodesInGroupThenAddToSetTest.java b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/compute/strategy/EC2CreateNodesInGroupThenAddToSetTest.java
new file mode 100644
index 0000000..f0201ad
--- /dev/null
+++ b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/compute/strategy/EC2CreateNodesInGroupThenAddToSetTest.java
@@ -0,0 +1,343 @@
+/*
+ * 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.strategy;
+
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.eq;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.reportMatcher;
+import static org.easymock.EasyMock.verify;
+
+import java.util.Map;
+import java.util.Set;
+
+import org.easymock.IArgumentMatcher;
+import org.jclouds.compute.config.CustomizationResponse;
+import org.jclouds.compute.domain.Hardware;
+import org.jclouds.compute.domain.Image;
+import org.jclouds.compute.domain.NodeMetadata;
+import org.jclouds.compute.domain.NodeMetadata.Status;
+import org.jclouds.compute.domain.NodeMetadataBuilder;
+import org.jclouds.compute.domain.Template;
+import org.jclouds.compute.predicates.AtomicNodeRunning;
+import org.jclouds.compute.strategy.GetNodeMetadataStrategy;
+import org.jclouds.compute.util.ComputeUtils;
+import org.jclouds.domain.Credentials;
+import org.jclouds.domain.Location;
+import org.jclouds.domain.LocationBuilder;
+import org.jclouds.domain.LocationScope;
+import org.jclouds.domain.LoginCredentials;
+import org.jclouds.ec2.EC2Api;
+import org.jclouds.ec2.compute.domain.RegionAndName;
+import org.jclouds.ec2.compute.functions.PresentInstances;
+import org.jclouds.ec2.compute.functions.RunningInstanceToNodeMetadata;
+import org.jclouds.ec2.compute.options.EC2TemplateOptions;
+import org.jclouds.ec2.domain.Reservation;
+import org.jclouds.ec2.domain.RunningInstance;
+import org.jclouds.ec2.options.RunInstancesOptions;
+import org.jclouds.ec2.features.ElasticIPAddressApi;
+import org.jclouds.ec2.features.InstanceApi;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import com.google.common.base.Optional;
+import com.google.common.cache.LoadingCache;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimap;
+
+/**
+ * @author Adrian Cole
+ */
+@Test(groups = "unit", singleThreaded = true, testName = "EC2CreateNodesInGroupThenAddToSetTest")
+public class EC2CreateNodesInGroupThenAddToSetTest {
+
+   @SuppressWarnings("unchecked")
+   public void testIpAllocationThenAfterNodeRunningAssignThenUpdateCache() {
+      Location location = ZONE_AP_SOUTHEAST_1A;
+      String region = "ap-southeast-1";
+      String zone = "ap-southeast-1a";
+
+      String imageId = "ami1";
+      String instanceCreatedId = "instance1";
+      NodeMetadata nodeMetadata = new NodeMetadataBuilder().id(region + "/" + instanceCreatedId)
+            .providerId(instanceCreatedId).status(Status.RUNNING).build();
+      // setup mocks
+      EC2CreateNodesInGroupThenAddToSet strategy = setupStrategy(nodeMetadata);
+      InputParams input = new InputParams(location);
+      InstanceApi instanceClient = createMock(InstanceApi.class);
+      ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class);
+      RunInstancesOptions ec2Options = createMock(RunInstancesOptions.class);
+      RunningInstance instance = createMock(RunningInstance.class);
+      Reservation<? extends RunningInstance> reservation = new Reservation<RunningInstance>(region,
+            ImmutableSet.<String> of(), ImmutableSet.<RunningInstance> of(instance), "ownerId", "requesterId",
+            "reservationId");
+
+      // enable auto-allocation
+      strategy.autoAllocateElasticIps = true;
+
+      // setup expectations
+      expect(input.template.clone()).andReturn(input.template);
+      expect(strategy.client.getInstanceApi()).andReturn((Optional) Optional.of(instanceClient)).atLeastOnce();
+      expect(
+            strategy.createKeyPairAndSecurityGroupsAsNeededAndReturncustomize
+                  .execute(region, input.tag, input.template)).andReturn(ec2Options);
+      expect(strategy.client.getElasticIPAddressApi()).andReturn((Optional) Optional.of(ipClient)).atLeastOnce();
+
+      expect(input.template.getLocation()).andReturn(input.location).atLeastOnce();
+      expect(input.template.getImage()).andReturn(input.image).atLeastOnce();
+      expect(input.image.getProviderId()).andReturn(imageId).atLeastOnce();
+
+      // differences when ip allocation
+      expect(ipClient.allocateAddressInRegion(region)).andReturn("1.1.1.1");
+      expect(strategy.runningInstanceToNodeMetadata.apply(instance)).andReturn(nodeMetadata).atLeastOnce();
+      ipClient.associateAddressInRegion(region, "1.1.1.1", instanceCreatedId);
+      strategy.elasticIpCache.put(new RegionAndName(region, instanceCreatedId), "1.1.1.1");
+
+      expect(instanceClient.runInstancesInRegion(region, zone, imageId, 1, input.count, ec2Options)).andReturn(
+            Reservation.class.cast(reservation));
+      expect(instance.getId()).andReturn(instanceCreatedId).atLeastOnce();
+      // simulate a lazy credentials fetch
+      LoginCredentials creds = LoginCredentials.builder().user("foo").privateKey("bar").build();
+      expect(strategy.instanceToCredentials.apply(instance)).andReturn(Optional.of(creds));
+      expect(instance.getRegion()).andReturn(region).atLeastOnce();
+      expect(strategy.credentialStore.put("node#" + region + "/" + instanceCreatedId, creds)).andReturn(null);
+
+      expect(strategy.presentInstances.apply(ImmutableSet.of(new RegionAndName(region, instanceCreatedId)))).andReturn(ImmutableSet.of(instance));
+      expect(input.template.getOptions()).andReturn(input.options).atLeastOnce();
+      expect(input.options.getLoginUser()).andReturn(null);
+      expect(input.options.getLoginPassword()).andReturn(null);
+      expect(input.options.getLoginPrivateKey()).andReturn(null);
+      expect(input.options.shouldAuthenticateSudo()).andReturn(null);
+
+      expect(
+            strategy.utils.customizeNodesAndAddToGoodMapOrPutExceptionIntoBadMap(eq(input.options),
+                  containsNodeMetadata(nodeMetadata), eq(input.nodes), eq(input.badNodes), eq(input.customization)))
+            .andReturn(null);
+
+      // replay mocks
+      replay(instanceClient);
+      replay(ipClient);
+      replay(ec2Options);
+      replay(instance);
+      input.replayMe();
+      replayStrategy(strategy);
+
+      // run
+      strategy.execute(input.tag, input.count, input.template, input.nodes, input.badNodes, input.customization);
+
+      // verify mocks
+      verify(instanceClient);
+      verify(ipClient);
+      verify(ec2Options);
+      verify(instance);
+      input.verifyMe();
+      verifyStrategy(strategy);
+   }
+
+   @Test
+   public void testZoneAsALocation() {
+      assertRegionAndZoneForLocation(ZONE_AP_SOUTHEAST_1A, "ap-southeast-1", "ap-southeast-1a");
+   }
+
+   @Test
+   public void testRegionAsALocation() {
+      assertRegionAndZoneForLocation(REGION_AP_SOUTHEAST_1, "ap-southeast-1", null);
+   }
+
+   // // fixtures
+
+   public static Iterable<NodeMetadata> containsNodeMetadata(final NodeMetadata in) {
+      reportMatcher(new IArgumentMatcher() {
+
+         @Override
+         public void appendTo(StringBuffer buffer) {
+            buffer.append("contains(");
+            buffer.append(in);
+            buffer.append(")");
+         }
+
+         @Override
+         public boolean matches(Object arg) {
+            return Iterables.contains((Iterable<?>) arg, in);
+         }
+
+      });
+      return null;
+   }
+
+   @SuppressWarnings("unchecked")
+   private void assertRegionAndZoneForLocation(Location location, String region, String zone) {
+      String imageId = "ami1";
+      String instanceCreatedId = "instance1";
+      NodeMetadata nodeMetadata = new NodeMetadataBuilder().id(region + "/" + instanceCreatedId)
+            .providerId(instanceCreatedId).status(Status.RUNNING).build();
+
+      // setup mocks
+      EC2CreateNodesInGroupThenAddToSet strategy = setupStrategy(nodeMetadata);
+      InputParams input = new InputParams(location);
+      InstanceApi instanceClient = createMock(InstanceApi.class);
+      RunInstancesOptions ec2Options = createMock(RunInstancesOptions.class);
+      RunningInstance instance = createMock(RunningInstance.class);
+      Reservation<? extends RunningInstance> reservation = new Reservation<RunningInstance>(region,
+            ImmutableSet.<String> of(), ImmutableSet.<RunningInstance> of(instance), "ownerId", "requesterId",
+            "reservationId");
+
+      // setup expectations
+      expect(input.template.clone()).andReturn(input.template);
+      expect(strategy.client.getInstanceApi()).andReturn((Optional) Optional.of(instanceClient)).atLeastOnce();
+      expect(
+            strategy.createKeyPairAndSecurityGroupsAsNeededAndReturncustomize
+                  .execute(region, input.tag, input.template)).andReturn(ec2Options);
+      expect(input.template.getLocation()).andReturn(input.location).atLeastOnce();
+      expect(input.template.getImage()).andReturn(input.image).atLeastOnce();
+      expect(input.image.getProviderId()).andReturn(imageId).atLeastOnce();
+      expect(instanceClient.runInstancesInRegion(region, zone, imageId, 1, input.count, ec2Options)).andReturn(
+            Reservation.class.cast(reservation));
+      expect(instance.getId()).andReturn(instanceCreatedId).atLeastOnce();
+      // simulate a lazy credentials fetch
+      LoginCredentials creds = LoginCredentials.builder().user("foo").privateKey("bar").build();
+      expect(strategy.instanceToCredentials.apply(instance)).andReturn(Optional.of(creds));
+      expect(instance.getRegion()).andReturn(region).atLeastOnce();
+      expect(strategy.credentialStore.put("node#" + region + "/" + instanceCreatedId, creds)).andReturn(null);
+
+      expect(strategy.presentInstances.apply(ImmutableSet.of(new RegionAndName(region, instanceCreatedId)))).andReturn(ImmutableSet.of(instance));
+      expect(input.template.getOptions()).andReturn(input.options).atLeastOnce();
+      expect(input.options.getLoginUser()).andReturn(null);
+      expect(input.options.getLoginPassword()).andReturn(null);
+      expect(input.options.getLoginPrivateKey()).andReturn(null);
+      expect(input.options.shouldAuthenticateSudo()).andReturn(null);
+
+
+      expect(strategy.runningInstanceToNodeMetadata.apply(instance)).andReturn(nodeMetadata);
+      expect(
+            strategy.utils.customizeNodesAndAddToGoodMapOrPutExceptionIntoBadMap(eq(input.options),
+                  containsNodeMetadata(nodeMetadata), eq(input.nodes), eq(input.badNodes), eq(input.customization)))
+            .andReturn(null);
+
+      // replay mocks
+      replay(instanceClient);
+      replay(ec2Options);
+      replay(instance);
+      input.replayMe();
+      replayStrategy(strategy);
+
+      // run
+      strategy.execute(input.tag, input.count, input.template, input.nodes, input.badNodes, input.customization);
+
+      // verify mocks
+      verify(instanceClient);
+      verify(ec2Options);
+      verify(instance);
+      input.verifyMe();
+      verifyStrategy(strategy);
+   }
+
+   private static final Location REGION_AP_SOUTHEAST_1 = new LocationBuilder().scope(LocationScope.REGION)
+         .id("ap-southeast-1").description("ap-southeast-1")
+         .parent(new LocationBuilder().scope(LocationScope.PROVIDER).id("aws-ec2").description("aws-ec2").build())
+         .build();
+   private static final Location ZONE_AP_SOUTHEAST_1A = new LocationBuilder().scope(LocationScope.ZONE)
+         .id("ap-southeast-1a").description("ap-southeast-1a").parent(REGION_AP_SOUTHEAST_1).build();
+
+   // /////////////////////////////////////////////////////////////////////
+   @SuppressWarnings("unchecked")
+   private static class InputParams {
+      String tag = "foo";
+      int count = 1;
+      Template template = createMock(Template.class);
+      Set<NodeMetadata> nodes = createMock(Set.class);
+      Map<NodeMetadata, Exception> badNodes = createMock(Map.class);
+      Multimap<NodeMetadata, CustomizationResponse> customization = createMock(Multimap.class);
+      Hardware hardware = createMock(Hardware.class);
+      Image image = createMock(Image.class);
+      final Location location;
+      EC2TemplateOptions options = createMock(EC2TemplateOptions.class);
+
+      public InputParams(Location location) {
+         this.location = location;
+      }
+
+      void replayMe() {
+         replay(template);
+         replay(hardware);
+         replay(image);
+         replay(nodes);
+         replay(badNodes);
+         replay(customization);
+         replay(options);
+      }
+
+      void verifyMe() {
+         verify(template);
+         verify(hardware);
+         verify(image);
+         verify(nodes);
+         verify(badNodes);
+         verify(customization);
+         verify(options);
+      }
+   }
+
+   private void verifyStrategy(EC2CreateNodesInGroupThenAddToSet strategy) {
+      verify(strategy.createKeyPairAndSecurityGroupsAsNeededAndReturncustomize);
+      verify(strategy.client);
+      verify(strategy.elasticIpCache);
+      verify(strategy.presentInstances);
+      verify(strategy.runningInstanceToNodeMetadata);
+      verify(strategy.instanceToCredentials);
+      verify(strategy.credentialStore);
+      verify(strategy.utils);
+   }
+
+   @SuppressWarnings("unchecked")
+   private EC2CreateNodesInGroupThenAddToSet setupStrategy(final NodeMetadata node) {
+      EC2Api client = createMock(EC2Api.class);
+      CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions createKeyPairAndSecurityGroupsAsNeededAndReturncustomize = createMock(CreateKeyPairAndSecurityGroupsAsNeededAndReturnRunOptions.class);
+      PresentInstances presentInstances = createMock(PresentInstances.class);
+      RunningInstanceToNodeMetadata runningInstanceToNodeMetadata = createMock(RunningInstanceToNodeMetadata.class);
+      LoadingCache<RunningInstance, Optional<LoginCredentials>> instanceToCredentials = createMock(LoadingCache.class);
+      LoadingCache<RegionAndName, String> elasticIpCache = createMock(LoadingCache.class);
+      GetNodeMetadataStrategy nodeRunning = new GetNodeMetadataStrategy() {
+
+         @Override
+         public NodeMetadata getNode(String input) {
+            Assert.assertEquals(input, node.getId());
+            return node;
+         }
+         
+      };
+      Map<String, Credentials> credentialStore = createMock(Map.class);
+      ComputeUtils utils = createMock(ComputeUtils.class);
+      return new EC2CreateNodesInGroupThenAddToSet(client, elasticIpCache, new AtomicNodeRunning(nodeRunning),
+            createKeyPairAndSecurityGroupsAsNeededAndReturncustomize, presentInstances, runningInstanceToNodeMetadata,
+            instanceToCredentials, credentialStore, utils);
+   }
+
+   private void replayStrategy(EC2CreateNodesInGroupThenAddToSet strategy) {
+      replay(strategy.createKeyPairAndSecurityGroupsAsNeededAndReturncustomize);
+      replay(strategy.client);
+      replay(strategy.elasticIpCache);
+      replay(strategy.presentInstances);
+      replay(strategy.runningInstanceToNodeMetadata);
+      replay(strategy.instanceToCredentials);
+      replay(strategy.credentialStore);
+      replay(strategy.utils);
+   }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/58fe66df/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/compute/strategy/EC2DestroyNodeStrategyTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/compute/strategy/EC2DestroyNodeStrategyTest.java b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/compute/strategy/EC2DestroyNodeStrategyTest.java
new file mode 100644
index 0000000..6bc929c
--- /dev/null
+++ b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/compute/strategy/EC2DestroyNodeStrategyTest.java
@@ -0,0 +1,189 @@
+/*
+ * 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.strategy;
+
+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 java.util.concurrent.ExecutionException;
+
+import org.jclouds.compute.domain.NodeMetadata;
+import org.jclouds.compute.strategy.GetNodeMetadataStrategy;
+import org.jclouds.ec2.EC2Api;
+import org.jclouds.ec2.compute.domain.RegionAndName;
+import org.jclouds.ec2.features.ElasticIPAddressApi;
+import org.jclouds.ec2.features.InstanceApi;
+import org.testng.annotations.Test;
+
+import com.google.common.base.Optional;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+
+/**
+ * @author Adrian Cole
+ */
+@Test(groups = "unit", singleThreaded = true, testName = "EC2DestroyNodeStrategyTest")
+public class EC2DestroyNodeStrategyTest {
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testDestroyNodeTerminatesInstanceAndReturnsRefreshedNode() throws Exception {
+      EC2Api client = createMock(EC2Api.class);
+      InstanceApi instanceClient = createMock(InstanceApi.class);
+      GetNodeMetadataStrategy getNode = createMock(GetNodeMetadataStrategy.class);
+      LoadingCache<RegionAndName, String> elasticIpCache = createMock(LoadingCache.class);
+
+      NodeMetadata node = createMock(NodeMetadata.class);
+
+      expect(client.getInstanceApi()).andReturn((Optional) Optional.of(instanceClient)).atLeastOnce();
+      expect(instanceClient.terminateInstancesInRegion("region", "i-blah")).andReturn(null);
+      expect(getNode.getNode("region/i-blah")).andReturn(node);
+
+      replay(client);
+      replay(getNode);
+      replay(instanceClient);
+      replay(elasticIpCache);
+
+      EC2DestroyNodeStrategy destroyer = new EC2DestroyNodeStrategy(client, getNode, elasticIpCache);
+
+      assertEquals(destroyer.destroyNode("region/i-blah"), node);
+
+      verify(client);
+      verify(getNode);
+      verify(instanceClient);
+      verify(elasticIpCache);
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testDestroyNodeDisassociatesAndReleasesIpThenTerminatesInstanceAndReturnsRefreshedNode()
+            throws Exception {
+      EC2Api client = createMock(EC2Api.class);
+      GetNodeMetadataStrategy getNode = createMock(GetNodeMetadataStrategy.class);
+      LoadingCache<RegionAndName, String> elasticIpCache = createMock(LoadingCache.class);
+      ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class);
+      InstanceApi instanceClient = createMock(InstanceApi.class);
+
+      NodeMetadata node = createMock(NodeMetadata.class);
+
+      expect(elasticIpCache.get(new RegionAndName("region", "i-blah"))).andReturn("1.1.1.1");
+
+      expect(client.getElasticIPAddressApi()).andReturn((Optional) Optional.of(ipClient)).atLeastOnce();
+      ipClient.disassociateAddressInRegion("region", "1.1.1.1");
+      ipClient.releaseAddressInRegion("region", "1.1.1.1");
+      elasticIpCache.invalidate(new RegionAndName("region", "i-blah"));
+
+
+      expect(client.getInstanceApi()).andReturn((Optional) Optional.of(instanceClient)).atLeastOnce();
+      expect(instanceClient.terminateInstancesInRegion("region", "i-blah")).andReturn(null);
+      expect(getNode.getNode("region/i-blah")).andReturn(node);
+
+      replay(client);
+      replay(getNode);
+      replay(elasticIpCache);
+      replay(instanceClient);
+      replay(ipClient);
+
+      EC2DestroyNodeStrategy destroyer = new EC2DestroyNodeStrategy(client, getNode, elasticIpCache);
+      destroyer.autoAllocateElasticIps = true;
+
+      assertEquals(destroyer.destroyNode("region/i-blah"), node);
+
+      verify(client);
+      verify(getNode);
+      verify(elasticIpCache);
+      verify(instanceClient);
+      verify(ipClient);
+   }
+   
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testDestroyNodeSafeOnCacheMissThenTerminatesInstanceAndReturnsRefreshedNode()
+            throws Exception {
+      EC2Api client = createMock(EC2Api.class);
+      GetNodeMetadataStrategy getNode = createMock(GetNodeMetadataStrategy.class);
+      LoadingCache<RegionAndName, String> elasticIpCache = createMock(LoadingCache.class);
+      ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class);
+      InstanceApi instanceClient = createMock(InstanceApi.class);
+
+      NodeMetadata node = createMock(NodeMetadata.class);
+
+      expect(elasticIpCache.get(new RegionAndName("region", "i-blah"))).andThrow(new CacheLoader.InvalidCacheLoadException(null));
+
+      expect(client.getInstanceApi()).andReturn((Optional) Optional.of(instanceClient)).atLeastOnce();
+      expect(instanceClient.terminateInstancesInRegion("region", "i-blah")).andReturn(null);
+      expect(getNode.getNode("region/i-blah")).andReturn(node);
+
+      replay(client);
+      replay(getNode);
+      replay(elasticIpCache);
+      replay(instanceClient);
+      replay(ipClient);
+
+      EC2DestroyNodeStrategy destroyer = new EC2DestroyNodeStrategy(client, getNode, elasticIpCache);
+      destroyer.autoAllocateElasticIps = true;
+
+      assertEquals(destroyer.destroyNode("region/i-blah"), node);
+
+      verify(client);
+      verify(getNode);
+      verify(elasticIpCache);
+      verify(instanceClient);
+      verify(ipClient);
+   }
+   
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testDestroyNodeSafeOnCacheExecutionExceptionThenTerminatesInstanceAndReturnsRefreshedNode()
+            throws Exception {
+      EC2Api client = createMock(EC2Api.class);
+      GetNodeMetadataStrategy getNode = createMock(GetNodeMetadataStrategy.class);
+      LoadingCache<RegionAndName, String> elasticIpCache = createMock(LoadingCache.class);
+      ElasticIPAddressApi ipClient = createMock(ElasticIPAddressApi.class);
+      InstanceApi instanceClient = createMock(InstanceApi.class);
+
+      NodeMetadata node = createMock(NodeMetadata.class);
+
+      expect(elasticIpCache.get(new RegionAndName("region", "i-blah"))).andThrow(new ExecutionException(null));
+
+      expect(client.getInstanceApi()).andReturn((Optional) Optional.of(instanceClient)).atLeastOnce();
+      expect(instanceClient.terminateInstancesInRegion("region", "i-blah")).andReturn(null);
+      expect(getNode.getNode("region/i-blah")).andReturn(node);
+
+      replay(client);
+      replay(getNode);
+      replay(elasticIpCache);
+      replay(instanceClient);
+      replay(ipClient);
+
+      EC2DestroyNodeStrategy destroyer = new EC2DestroyNodeStrategy(client, getNode, elasticIpCache);
+      destroyer.autoAllocateElasticIps = true;
+
+      assertEquals(destroyer.destroyNode("region/i-blah"), node);
+
+      verify(client);
+      verify(getNode);
+      verify(elasticIpCache);
+      verify(instanceClient);
+      verify(ipClient);
+   }
+}

http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/58fe66df/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/config/EC2HttpApiModuleExpectTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/config/EC2HttpApiModuleExpectTest.java b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/config/EC2HttpApiModuleExpectTest.java
new file mode 100644
index 0000000..0785228
--- /dev/null
+++ b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/config/EC2HttpApiModuleExpectTest.java
@@ -0,0 +1,145 @@
+/*
+ * 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.config;
+
+import static org.testng.Assert.assertEquals;
+
+import java.net.URI;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+import org.jclouds.ec2.internal.BaseEC2ApiExpectTest;
+import org.jclouds.http.HttpRequest;
+import org.jclouds.http.HttpResponse;
+import org.jclouds.location.Region;
+import org.jclouds.location.Zone;
+import org.jclouds.location.functions.RegionToEndpointOrProviderIfNull;
+import org.jclouds.location.functions.ZoneToEndpoint;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import com.google.common.base.Function;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMap.Builder;
+import com.google.common.collect.ImmutableSet;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.google.inject.Module;
+import com.google.inject.TypeLiteral;
+
+/**
+ * @author Adrian Cole
+ */
+@Test(groups = "unit", testName = "EC2HttpApiModuleExpectTest")
+public class EC2HttpApiModuleExpectTest extends BaseEC2ApiExpectTest<Injector> {
+   private Injector injector;
+
+   @BeforeClass
+   @Override
+   protected void setupDefaultRequests() {
+      super.setupDefaultRequests();
+      Builder<HttpRequest, HttpResponse> builder = ImmutableMap.<HttpRequest, HttpResponse> builder();
+      builder.put(describeRegionsRequest, describeRegionsResponse);
+      builder.putAll(describeAvailabilityZonesRequestResponse);
+
+      injector = requestsSendResponses(builder.build());
+   }
+
+   public void testLocationIdAndURIBindings() {
+
+      assertEquals(injector.getInstance(Key.get(new TypeLiteral<Supplier<Set<String>>>() {
+      }, Region.class)).get(), ImmutableSet.<String> of("sa-east-1", "ap-northeast-1", "eu-west-1", "us-east-1",
+            "us-west-1", "us-west-2", "ap-southeast-1"));
+
+      assertEquals(injector.getInstance(Key.get(new TypeLiteral<Supplier<Set<String>>>() {
+      }, Zone.class)).get(), ImmutableSet.<String> of("sa-east-1a", "sa-east-1b", "ap-northeast-1a", "ap-northeast-1b",
+            "eu-west-1a", "eu-west-1b", "eu-west-1c", "us-east-1a", "us-east-1b", "us-east-1c", "us-east-1d",
+            "us-east-1e", "us-west-1a", "us-west-1b", "us-west-1c", "us-west-2a", "us-west-2b", "us-west-2c",
+            "ap-southeast-1a", "ap-southeast-1b"));
+
+      Map<String, Supplier<URI>> regionToURISupplier = injector.getInstance(
+            Key.get(new TypeLiteral<Supplier<Map<String, Supplier<URI>>>>() {
+            }, Region.class)).get();
+
+      assertEquals(regionToURISupplier.get("sa-east-1").get(), URI.create("https://ec2.sa-east-1.amazonaws.com"));
+      assertEquals(regionToURISupplier.get("ap-northeast-1").get(),
+            URI.create("https://ec2.ap-northeast-1.amazonaws.com"));
+      assertEquals(regionToURISupplier.get("eu-west-1").get(), URI.create("https://ec2.eu-west-1.amazonaws.com"));
+      assertEquals(regionToURISupplier.get("us-east-1").get(), URI.create("https://ec2.us-east-1.amazonaws.com"));
+      assertEquals(regionToURISupplier.get("us-west-1").get(), URI.create("https://ec2.us-west-1.amazonaws.com"));
+      assertEquals(regionToURISupplier.get("us-west-2").get(), URI.create("https://ec2.us-west-2.amazonaws.com"));
+      assertEquals(regionToURISupplier.get("ap-southeast-1").get(),
+            URI.create("https://ec2.ap-southeast-1.amazonaws.com"));
+
+      Map<String, Supplier<Set<String>>> regionToZoneIdSupplier = injector.getInstance(
+            Key.get(new TypeLiteral<Supplier<Map<String, Supplier<Set<String>>>>>() {
+            }, Zone.class)).get();
+
+      assertEquals(regionToZoneIdSupplier.get("sa-east-1").get(), ImmutableSet.of("sa-east-1a", "sa-east-1b"));
+      assertEquals(regionToZoneIdSupplier.get("ap-northeast-1").get(),
+            ImmutableSet.of("ap-northeast-1a", "ap-northeast-1b"));
+      assertEquals(regionToZoneIdSupplier.get("eu-west-1").get(),
+            ImmutableSet.of("eu-west-1a", "eu-west-1b", "eu-west-1c"));
+      assertEquals(regionToZoneIdSupplier.get("us-east-1").get(),
+            ImmutableSet.of("us-east-1a", "us-east-1b", "us-east-1c", "us-east-1d", "us-east-1e"));
+      assertEquals(regionToZoneIdSupplier.get("us-west-1").get(),
+            ImmutableSet.of("us-west-1a", "us-west-1b", "us-west-1c"));
+      assertEquals(regionToZoneIdSupplier.get("us-west-2").get(),
+            ImmutableSet.of("us-west-2a", "us-west-2b", "us-west-2c"));
+      assertEquals(regionToZoneIdSupplier.get("ap-southeast-1").get(),
+            ImmutableSet.of("ap-southeast-1a", "ap-southeast-1b"));
+
+      Map<String, Supplier<URI>> zoneToURISupplier = injector.getInstance(
+            Key.get(new TypeLiteral<Supplier<Map<String, Supplier<URI>>>>() {
+            }, Zone.class)).get();
+
+      assertEquals(zoneToURISupplier.get("sa-east-1a").get(), URI.create("https://ec2.sa-east-1.amazonaws.com"));
+
+      assertEquals(zoneToURISupplier.get("ap-northeast-1a").get(),
+            URI.create("https://ec2.ap-northeast-1.amazonaws.com"));
+
+      assertEquals(zoneToURISupplier.get("eu-west-1a").get(), URI.create("https://ec2.eu-west-1.amazonaws.com"));
+
+      assertEquals(zoneToURISupplier.get("us-east-1a").get(), URI.create("https://ec2.us-east-1.amazonaws.com"));
+
+      assertEquals(zoneToURISupplier.get("us-west-1a").get(), URI.create("https://ec2.us-west-1.amazonaws.com"));
+
+      assertEquals(zoneToURISupplier.get("us-west-2a").get(), URI.create("https://ec2.us-west-2.amazonaws.com"));
+
+      assertEquals(zoneToURISupplier.get("ap-southeast-1a").get(),
+            URI.create("https://ec2.ap-southeast-1.amazonaws.com"));
+
+   }
+
+   public void testZoneToEndpoint() {
+      assertEquals(injector.getInstance(ZoneToEndpoint.class).apply("us-west-2a"),
+            URI.create("https://ec2.us-west-2.amazonaws.com"));
+   }
+   
+   public void testRegionToEndpointOrProviderIfNull() {
+      assertEquals(injector.getInstance(RegionToEndpointOrProviderIfNull.class).apply("us-west-2"),
+            URI.create("https://ec2.us-west-2.amazonaws.com"));
+   }
+   
+   @Override
+   public Injector createClient(Function<HttpRequest, HttpResponse> fn, Module module, Properties props) {
+      return createInjector(fn, module, props);
+   }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/58fe66df/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiExpectTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiExpectTest.java b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiExpectTest.java
new file mode 100644
index 0000000..7b57b2a
--- /dev/null
+++ b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiExpectTest.java
@@ -0,0 +1,76 @@
+/*
+ * 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.features;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static org.testng.Assert.assertEquals;
+
+import org.jclouds.ec2.EC2Api;
+import org.jclouds.ec2.domain.Image;
+import org.jclouds.ec2.internal.BaseEC2ApiExpectTest;
+import org.jclouds.http.HttpRequest;
+import org.jclouds.http.HttpResponse;
+import org.testng.annotations.Test;
+
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * @author Andrew Bayer
+ */
+@Test(groups = "unit", testName = "AMIApiExpectTest")
+public class AMIApiExpectTest extends BaseEC2ApiExpectTest<EC2Api> {
+
+   HttpRequest filter = HttpRequest.builder().method("POST")
+           .endpoint("https://ec2.us-east-1.amazonaws.com/")
+           .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+           .addFormParam("Action", "DescribeImages")
+           .addFormParam("Filter.1.Name", "owner-id")
+           .addFormParam("Filter.1.Value.1", "206029621532")
+           .addFormParam("Signature", "BxOCrCYJujtaUqSPagRvv1ki76veVBiKK3yWHvRWgR0%3D")
+           .addFormParam("SignatureMethod", "HmacSHA256")
+           .addFormParam("SignatureVersion", "2")
+           .addFormParam("Timestamp", "2012-04-16T15%3A54%3A08.897Z")
+           .addFormParam("Version", "2010-08-31")
+           .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testFilterWhenResponseIs2xx() {
+      HttpResponse filterResponse = HttpResponse.builder().statusCode(200)
+              .payload(payloadFromResourceWithContentType("/describe_images.xml", "text/xml")).build();
+
+      EC2Api apiWhenExist = requestsSendResponses(describeRegionsRequest, describeRegionsResponse, filter, filterResponse);
+
+      Image image = getOnlyElement(apiWhenExist.getAMIApi().get().describeImagesInRegionWithFilter("us-east-1",
+              ImmutableMultimap.<String, String>builder()
+                      .put("owner-id", "206029621532")
+                      .build()));
+
+      assertEquals(image.getId(), "ami-be3adfd7");
+   }
+
+   public void testFilterWhenResponseIs404() {
+      HttpResponse filterResponse = HttpResponse.builder().statusCode(404).build();
+
+      EC2Api apiWhenNotExist = requestsSendResponses(describeRegionsRequest, describeRegionsResponse, filter, filterResponse);
+
+      assertEquals(apiWhenNotExist.getAMIApi().get().describeImagesInRegionWithFilter("us-east-1",
+              ImmutableMultimap.<String, String>builder()
+                      .put("owner-id", "206029621532")
+                      .build()),
+              ImmutableSet.of());
+   }
+}

http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/58fe66df/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiLiveTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiLiveTest.java b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiLiveTest.java
new file mode 100644
index 0000000..2b56e0a
--- /dev/null
+++ b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiLiveTest.java
@@ -0,0 +1,249 @@
+/*
+ * 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.features;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.concat;
+import static com.google.common.collect.Iterables.getFirst;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.collect.Sets.newHashSet;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.jclouds.ec2.options.DescribeImagesOptions.Builder.imageIds;
+import static org.jclouds.ec2.options.RegisterImageBackedByEbsOptions.Builder.addNewBlockDevice;
+import static org.jclouds.util.Predicates2.retry;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertTrue;
+
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.Set;
+
+import org.jclouds.aws.AWSResponseException;
+import org.jclouds.compute.RunNodesException;
+import org.jclouds.compute.domain.Template;
+import org.jclouds.compute.domain.TemplateBuilderSpec;
+import org.jclouds.compute.internal.BaseComputeServiceContextLiveTest;
+import org.jclouds.ec2.EC2Api;
+import org.jclouds.ec2.domain.BlockDevice;
+import org.jclouds.ec2.domain.Image;
+import org.jclouds.ec2.domain.Image.ImageType;
+import org.jclouds.ec2.domain.RootDeviceType;
+import org.jclouds.ec2.domain.RunningInstance;
+import org.jclouds.ec2.domain.Snapshot;
+import org.jclouds.ec2.predicates.InstanceStateRunning;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+
+/**
+ * Tests behavior of {@code AMIApi}
+ * 
+ * @author Adrian Cole
+ */
+@Test(groups = "live", singleThreaded = true)
+public class AMIApiLiveTest extends BaseComputeServiceContextLiveTest {
+   private TemplateBuilderSpec ebsTemplate;
+
+   public AMIApiLiveTest() {
+      provider = "ec2";
+   }
+
+   @Override
+   protected Properties setupProperties() {
+      Properties overrides = super.setupProperties();
+      String ebsSpec = checkNotNull(setIfTestSystemPropertyPresent(overrides, provider + ".ebs-template"), provider
+            + ".ebs-template");
+      ebsTemplate = TemplateBuilderSpec.parse(ebsSpec);
+      return overrides;
+   }
+
+   protected EC2Api ec2Api;
+   protected AMIApi client;
+
+   protected Predicate<RunningInstance> runningTester;
+
+   protected Set<String> imagesToDeregister = newHashSet();
+   protected Set<String> snapshotsToDelete = newHashSet();
+   protected String regionId;
+   protected String ebsBackedImageId;
+   protected String ebsBackedImageName = "jcloudstest1";
+   protected String imageId;
+
+   @Override
+   @BeforeClass(groups = { "integration", "live" })
+   public void setupContext() {
+      super.setupContext();
+      ec2Api = view.unwrapApi(EC2Api.class);
+      runningTester = retry(new InstanceStateRunning(ec2Api), 600, 5, SECONDS);
+
+      client = ec2Api.getAMIApi().get();
+      if (ebsTemplate != null) {
+         Template template = view.getComputeService().templateBuilder().from(ebsTemplate).build();
+         regionId = template.getLocation().getId();
+         imageId = template.getImage().getProviderId();
+         for (Image image : client.describeImagesInRegionWithFilter(regionId,
+                 ImmutableMultimap.<String, String>builder()
+                         .put("name", ebsBackedImageName).build())) {
+            if (ebsBackedImageName.equals(image.getName()))
+               client.deregisterImageInRegion(regionId, image.getId());
+         }
+      }
+   }
+
+   public void testDescribeImageNotExists() {
+      assertEquals(client.describeImagesInRegion(null, imageIds("ami-cdf819a3")).size(), 0);
+   }
+
+   @Test(expectedExceptions = IllegalArgumentException.class)
+   public void testDescribeImageBadId() {
+      client.describeImagesInRegion(null, imageIds("asdaasdsa"));
+   }
+
+   public void testDescribeImages() {
+      // Just run in the first region - no need to take the time on all of them.
+      String region = getFirst(ec2Api.getConfiguredRegions(), null);
+      assertNotNull(region, "region should not be null");
+      Set<? extends Image> allResults = client.describeImagesInRegion(region);
+      assertNotNull(allResults);
+      assertTrue(allResults.size() >= 2);
+      Iterator<? extends Image> iterator = allResults.iterator();
+      String id1 = iterator.next().getId();
+      String id2 = iterator.next().getId();
+      Set<? extends Image> twoResults = client.describeImagesInRegion(region, imageIds(id1, id2));
+      assertNotNull(twoResults);
+      assertEquals(twoResults.size(), 2);
+      iterator = twoResults.iterator();
+      assertEquals(iterator.next().getId(), id1);
+      assertEquals(iterator.next().getId(), id2);
+   }
+
+   @Test
+   public void testDescribeImagesWithFilter() {
+      // Just run in the first region - no need to take the time on all of them.
+      String region = getFirst(ec2Api.getConfiguredRegions(), null);
+      assertNotNull(region, "region should not be null");
+      Set<? extends Image> allResults = client.describeImagesInRegion(region);
+      assertNotNull(allResults);
+      assertTrue(allResults.size() >= 2);
+      String id1 = allResults.iterator().next().getId();
+      Set<? extends Image> filterResult = client.describeImagesInRegionWithFilter(region,
+              ImmutableMultimap.<String, String>builder()
+                      .put("image-id", id1)
+                      .build());
+      assertNotNull(filterResult);
+      assertEquals(filterResult.size(), 1);
+      assertEquals(filterResult.iterator().next().getId(), id1);
+   }
+
+   @Test(expectedExceptions = AWSResponseException.class)
+   public void testDescribeImagesWithInvalidFilter() {
+      // Just run in the first region - no need to take the time on all of them.
+      String region = getFirst(ec2Api.getConfiguredRegions(), null);
+      assertNotNull(region, "region should not be null");
+
+      Set<? extends Image> allResults = client.describeImagesInRegion(region);
+      assertNotNull(allResults);
+      assertTrue(allResults.size() >= 2);
+      String id1 = allResults.iterator().next().getId();
+      Set<? extends Image> filterResult = client.describeImagesInRegionWithFilter(region,
+              ImmutableMultimap.<String, String>builder()
+                      .put("invalid-filter-id", id1)
+                      .build());
+      assertNotNull(filterResult);
+      assertEquals(filterResult.size(), 1);
+      assertEquals(filterResult.iterator().next().getId(), id1);
+   }
+
+   @Test
+   public void testCreateAndListEBSBackedImage() throws Exception {
+      Snapshot snapshot = createSnapshot();
+
+      // List of images before...
+      int sizeBefore = client.describeImagesInRegionWithFilter(regionId,
+              ImmutableMultimap.<String, String>builder()
+                      .put("name", ebsBackedImageName).build()).size();
+
+      // Register a new image...
+      ebsBackedImageId = client.registerUnixImageBackedByEbsInRegion(regionId, ebsBackedImageName, snapshot.getId(),
+            addNewBlockDevice("/dev/sda2", "myvirtual", 1).withDescription("adrian"));
+      imagesToDeregister.add(ebsBackedImageId);
+      final Image ebsBackedImage = getOnlyElement(client.describeImagesInRegion(regionId, imageIds(ebsBackedImageId)));
+      assertEquals(ebsBackedImage.getName(), ebsBackedImageName);
+      assertEquals(ebsBackedImage.getImageType(), ImageType.MACHINE);
+      assertEquals(ebsBackedImage.getRootDeviceType(), RootDeviceType.EBS);
+      assertEquals(ebsBackedImage.getRootDeviceName(), "/dev/sda1");
+      assertEquals(ebsBackedImage.getDescription(), "adrian");
+      assertEquals(
+            ebsBackedImage.getEbsBlockDevices().entrySet(),
+            ImmutableMap.of("/dev/sda1", new Image.EbsBlockDevice(snapshot.getId(), snapshot.getVolumeSize(), true),
+                  "/dev/sda2", new Image.EbsBlockDevice(null, 1, false)).entrySet());
+
+      // List of images after - should be one larger than before
+      int after = client.describeImagesInRegionWithFilter(regionId,
+              ImmutableMultimap.<String, String>builder()
+                      .put("name", ebsBackedImageName).build()).size();
+
+      assertEquals(after, sizeBefore + 1);
+   }
+
+   // Fires up an instance, finds its root volume ID, takes a snapshot, then
+   // terminates the instance.
+   private Snapshot createSnapshot() throws RunNodesException {
+
+      String instanceId = null;
+      try {
+         RunningInstance instance = getOnlyElement(concat(ec2Api.getInstanceApi().get().runInstancesInRegion(
+               regionId, null, imageId, 1, 1)));
+         instanceId = instance.getId();
+         
+         assertTrue(runningTester.apply(instance), instanceId + "didn't achieve the state running!");
+
+         instance = getOnlyElement(concat(ec2Api.getInstanceApi().get().describeInstancesInRegion(regionId,
+               instanceId)));
+         BlockDevice device = instance.getEbsBlockDevices().get("/dev/sda1");
+         assertNotNull(device, "device: /dev/sda1 not present on: " + instance);
+         Snapshot snapshot = ec2Api.getElasticBlockStoreApi().get().createSnapshotInRegion(regionId,
+               device.getVolumeId());
+         snapshotsToDelete.add(snapshot.getId());
+         return snapshot;
+      } finally {
+         if (instanceId != null)
+            ec2Api.getInstanceApi().get().terminateInstancesInRegion(regionId, instanceId);
+      }
+   }
+
+   @Test(dependsOnMethods = "testCreateAndListEBSBackedImage")
+   public void testGetLaunchPermissionForImage() {
+      client.getLaunchPermissionForImageInRegion(regionId, ebsBackedImageId);
+   }
+
+   @Override
+   @AfterClass(groups = { "integration", "live" })
+   protected void tearDownContext() {
+      for (String imageId : imagesToDeregister)
+         client.deregisterImageInRegion(regionId, imageId);
+      for (String snapshotId : snapshotsToDelete)
+         ec2Api.getElasticBlockStoreApi().get().deleteSnapshotInRegion(regionId, snapshotId);
+      super.tearDownContext();
+   }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-stratos/blob/58fe66df/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiTest.java
----------------------------------------------------------------------
diff --git a/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiTest.java b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiTest.java
new file mode 100644
index 0000000..b4b7f85
--- /dev/null
+++ b/dependencies/jclouds/apis/ec2/1.7.1-stratos/src/test/java/org/jclouds/ec2/features/AMIApiTest.java
@@ -0,0 +1,521 @@
+/*
+ * 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.features;
+
+import static org.jclouds.ec2.options.DescribeImagesOptions.Builder.executableBy;
+import static org.jclouds.reflect.Reflection2.method;
+
+import java.io.IOException;
+
+import org.jclouds.Fallbacks.EmptySetOnNotFoundOr404;
+import org.jclouds.ec2.options.CreateImageOptions;
+import org.jclouds.ec2.options.DescribeImagesOptions;
+import org.jclouds.ec2.options.RegisterImageBackedByEbsOptions;
+import org.jclouds.ec2.options.RegisterImageOptions;
+import org.jclouds.ec2.xml.BlockDeviceMappingHandler;
+import org.jclouds.ec2.xml.DescribeImagesResponseHandler;
+import org.jclouds.ec2.xml.ImageIdHandler;
+import org.jclouds.ec2.xml.PermissionHandler;
+import org.jclouds.http.HttpRequest;
+import org.jclouds.http.functions.ParseSax;
+import org.jclouds.http.functions.ReleasePayloadAndReturn;
+import org.jclouds.rest.internal.GeneratedHttpRequest;
+import org.testng.annotations.Test;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.reflect.Invokable;
+/**
+ * Tests behavior of {@code AMIApi}
+ * 
+ * @author Adrian Cole
+ */
+// NOTE:without testName, this will not call @Before* and fail w/NPE during surefire
+@Test(groups = "unit", testName = "AMIApiTest")
+public class AMIApiTest extends BaseEC2ApiTest<AMIApi> {
+
+   HttpRequest createImage = HttpRequest.builder().method("POST")
+                                        .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                        .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                        .addFormParam("Action", "CreateImage")
+                                        .addFormParam("InstanceId", "instanceId")
+                                        .addFormParam("Name", "name")
+                                        .addFormParam("Signature", "MuMtOMs697BLVks2RUZUNeLdVCo6NXPHuDhh0nmNtvc%3D")
+                                        .addFormParam("SignatureMethod", "HmacSHA256")
+                                        .addFormParam("SignatureVersion", "2")
+                                        .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                        .addFormParam("Version", "2010-08-31")
+                                        .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testCreateImage() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "createImageInRegion", String.class, String.class, String.class,
+               CreateImageOptions[].class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "name", "instanceId"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, createImage.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, ImageIdHandler.class);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest createImageOptions = HttpRequest.builder().method("POST")
+                                               .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                               .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                               .addFormParam("Action", "CreateImage")
+                                               .addFormParam("Description", "description")
+                                               .addFormParam("InstanceId", "instanceId")
+                                               .addFormParam("Name", "name")
+                                               .addFormParam("NoReboot", "true")
+                                               .addFormParam("Signature", "8SgbaWihxOICMXDLvwk3ahy/99nhZvTvbno%2B8dMyvJg%3D")
+                                               .addFormParam("SignatureMethod", "HmacSHA256")
+                                               .addFormParam("SignatureVersion", "2")
+                                               .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                               .addFormParam("Version", "2010-08-31")
+                                               .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testCreateImageOptions() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "createImageInRegion", String.class, String.class, String.class,
+               CreateImageOptions[].class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "name", "instanceId", new CreateImageOptions()
+               .withDescription("description").noReboot()));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, createImageOptions.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, ImageIdHandler.class);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest describeImages = HttpRequest.builder().method("POST")
+                                           .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                           .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                           .addFormParam("Action", "DescribeImages")
+                                           .addFormParam("Signature", "hQxNAaRVX6OvXV0IKgx1vV0FoNbRyuHQ2fhRhaPJnS8%3D")
+                                           .addFormParam("SignatureMethod", "HmacSHA256")
+                                           .addFormParam("SignatureVersion", "2")
+                                           .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                           .addFormParam("Version", "2010-08-31")
+                                           .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testDescribeImages() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "describeImagesInRegion", String.class,
+               DescribeImagesOptions[].class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList((String) null));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, describeImages.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, DescribeImagesResponseHandler.class);
+      assertFallbackClassEquals(method, EmptySetOnNotFoundOr404.class);
+
+      checkFilters(request);
+   }
+
+   HttpRequest describeImagesOptions = HttpRequest.builder().method("POST")
+                                                  .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                  .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                  .addFormParam("Action", "DescribeImages")
+                                                  .addFormParam("ExecutableBy", "me")
+                                                  .addFormParam("ImageId.1", "1")
+                                                  .addFormParam("ImageId.2", "2")
+                                                  .addFormParam("Owner.1", "fred")
+                                                  .addFormParam("Owner.2", "nancy")
+                                                  .addFormParam("Signature", "cIft3g1fwMu52NgB0En9NtHyXjVhmeSx7TBP7YR%2BTvI%3D")
+                                                  .addFormParam("SignatureMethod", "HmacSHA256")
+                                                  .addFormParam("SignatureVersion", "2")
+                                                  .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                  .addFormParam("Version", "2010-08-31")
+                                                  .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testDescribeImagesOptions() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "describeImagesInRegion", String.class,
+               DescribeImagesOptions[].class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, executableBy("me").ownedBy("fred", "nancy").imageIds(
+               "1", "2")));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, describeImagesOptions.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, DescribeImagesResponseHandler.class);
+      assertFallbackClassEquals(method, EmptySetOnNotFoundOr404.class);
+
+      checkFilters(request);
+   }
+
+   HttpRequest deregisterImage = HttpRequest.builder().method("POST")
+                                            .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                            .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                            .addFormParam("Action", "DeregisterImage")
+                                            .addFormParam("ImageId", "imageId")
+                                            .addFormParam("Signature", "tm6nGoPPJh7xt5TSdV5Ov0DJvcGTAW%2BYSfXL7j%2BTkOA%3D")
+                                            .addFormParam("SignatureMethod", "HmacSHA256")
+                                            .addFormParam("SignatureVersion", "2")
+                                            .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                            .addFormParam("Version", "2010-08-31")
+                                            .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testDeregisterImage() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "deregisterImageInRegion", String.class, String.class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "imageId"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, deregisterImage.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ReleasePayloadAndReturn.class);
+      assertSaxResponseParserClassEquals(method, null);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest registerImageFromManifest = HttpRequest.builder().method("POST")
+                                                      .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                      .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                      .addFormParam("Action", "RegisterImage")
+                                                      .addFormParam("ImageLocation", "pathToManifest")
+                                                      .addFormParam("Name", "name")
+                                                      .addFormParam("Signature", "Ie7k7w4Bdki3uCGeSFGdJ5EKrp/ohkHvWwivbIaVLEM%3D")
+                                                      .addFormParam("SignatureMethod", "HmacSHA256")
+                                                      .addFormParam("SignatureVersion", "2")
+                                                      .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                      .addFormParam("Version", "2010-08-31")
+                                                      .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testRegisterImageFromManifest() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "registerImageFromManifestInRegion", String.class, String.class,
+               String.class, RegisterImageOptions[].class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "name", "pathToManifest"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, registerImageFromManifest.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, ImageIdHandler.class);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest registerImageFromManifestOptions = HttpRequest.builder().method("POST")
+                                                             .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                             .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                             .addFormParam("Action", "RegisterImage")
+                                                             .addFormParam("Description", "description")
+                                                             .addFormParam("ImageLocation", "pathToManifest")
+                                                             .addFormParam("Name", "name")
+                                                             .addFormParam("Signature", "ilWV1eAWW6kTK/jHliQ%2BIkzJR4DRNy4ye%2BSKtnUjjDs%3D")
+                                                             .addFormParam("SignatureMethod", "HmacSHA256")
+                                                             .addFormParam("SignatureVersion", "2")
+                                                             .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                             .addFormParam("Version", "2010-08-31")
+                                                             .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testRegisterImageFromManifestOptions() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "registerImageFromManifestInRegion", String.class, String.class,
+               String.class, RegisterImageOptions[].class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "name", "pathToManifest", new RegisterImageOptions()
+               .withDescription("description")));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, registerImageFromManifestOptions.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, ImageIdHandler.class);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest registerImageBackedByEBS = HttpRequest.builder().method("POST")
+                                                     .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                     .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                     .addFormParam("Action", "RegisterImage")
+                                                     .addFormParam("BlockDeviceMapping.0.DeviceName", "/dev/sda1")
+                                                     .addFormParam("BlockDeviceMapping.0.Ebs.SnapshotId", "snapshotId")
+                                                     .addFormParam("Name", "imageName")
+                                                     .addFormParam("RootDeviceName", "/dev/sda1")
+                                                     .addFormParam("Signature", "ZbZcY6uwxPbD65jFmiNZXoWeHY/2zqRuGuDmTfkt84A%3D")
+                                                     .addFormParam("SignatureMethod", "HmacSHA256")
+                                                     .addFormParam("SignatureVersion", "2")
+                                                     .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                     .addFormParam("Version", "2010-08-31")
+                                                     .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testRegisterImageBackedByEBS() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "registerUnixImageBackedByEbsInRegion", String.class,
+               String.class, String.class, RegisterImageBackedByEbsOptions[].class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "imageName", "snapshotId"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, registerImageBackedByEBS.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, ImageIdHandler.class);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest registerImageBackedByEBSOptions = HttpRequest.builder().method("POST")
+                                                            .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                            .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                            .addFormParam("Action", "RegisterImage")
+                                                            .addFormParam("BlockDeviceMapping.0.DeviceName", "/dev/sda1")
+                                                            .addFormParam("BlockDeviceMapping.0.Ebs.SnapshotId", "snapshotId")
+                                                            .addFormParam("BlockDeviceMapping.1.DeviceName", "/dev/device")
+                                                            .addFormParam("BlockDeviceMapping.1.Ebs.DeleteOnTermination", "false")
+                                                            .addFormParam("BlockDeviceMapping.1.Ebs.SnapshotId", "snapshot")
+                                                            .addFormParam("BlockDeviceMapping.2.DeviceName", "/dev/newdevice")
+                                                            .addFormParam("BlockDeviceMapping.2.Ebs.DeleteOnTermination", "false")
+                                                            .addFormParam("BlockDeviceMapping.2.Ebs.VolumeSize", "100")
+                                                            .addFormParam("BlockDeviceMapping.2.VirtualName", "newblock")
+                                                            .addFormParam("Description", "description")
+                                                            .addFormParam("Name", "imageName")
+                                                            .addFormParam("RootDeviceName", "/dev/sda1")
+                                                            .addFormParam("Signature", "DrNujyZMGrKvuw73A7ObFTThXvc/MRfNqjvIy8gey5g%3D")
+                                                            .addFormParam("SignatureMethod", "HmacSHA256")
+                                                            .addFormParam("SignatureVersion", "2")
+                                                            .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                            .addFormParam("Version", "2010-08-31")
+                                                            .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testRegisterImageBackedByEBSOptions() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "registerUnixImageBackedByEbsInRegion", String.class,
+               String.class, String.class, RegisterImageBackedByEbsOptions[].class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "imageName", "snapshotId",
+               new RegisterImageBackedByEbsOptions().withDescription("description").addBlockDeviceFromSnapshot(
+                        "/dev/device", null, "snapshot").addNewBlockDevice("/dev/newdevice", "newblock", 100)));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, registerImageBackedByEBSOptions.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, ImageIdHandler.class);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest getBlockDeviceMappingsForImage = HttpRequest.builder().method("POST")
+                                                           .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                           .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                           .addFormParam("Action", "DescribeImageAttribute")
+                                                           .addFormParam("Attribute", "blockDeviceMapping")
+                                                           .addFormParam("ImageId", "imageId")
+                                                           .addFormParam("Signature", "MJCIc1roG%2BnIWxRSUqV9KP9Wc4AWuuiNkxeDSih5/mI%3D")
+                                                           .addFormParam("SignatureMethod", "HmacSHA256")
+                                                           .addFormParam("SignatureVersion", "2")
+                                                           .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                           .addFormParam("Version", "2010-08-31")
+                                                           .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testGetBlockDeviceMappingsForImage() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "getBlockDeviceMappingsForImageInRegion", String.class,
+               String.class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "imageId"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, getBlockDeviceMappingsForImage.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, BlockDeviceMappingHandler.class);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest getLaunchPermissionForImage = HttpRequest.builder().method("POST")
+                                                        .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                        .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                        .addFormParam("Action", "DescribeImageAttribute")
+                                                        .addFormParam("Attribute", "launchPermission")
+                                                        .addFormParam("ImageId", "imageId")
+                                                        .addFormParam("Signature", "iN7JbsAhM1NAES3o%2BOw8BaaFJ%2B1g9imBjcU4mFCyrxM%3D")
+                                                        .addFormParam("SignatureMethod", "HmacSHA256")
+                                                        .addFormParam("SignatureVersion", "2")
+                                                        .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                        .addFormParam("Version", "2010-08-31")
+                                                        .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testGetLaunchPermissionForImage() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "getLaunchPermissionForImageInRegion", String.class, String.class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "imageId"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, getLaunchPermissionForImage.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ParseSax.class);
+      assertSaxResponseParserClassEquals(method, PermissionHandler.class);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest addLaunchPermission = HttpRequest.builder().method("POST")
+                                                          .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                          .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                          .addFormParam("Action", "ModifyImageAttribute")
+                                                          .addFormParam("Attribute", "launchPermission")
+                                                          .addFormParam("ImageId", "imageId")
+                                                          .addFormParam("OperationType", "add")
+                                                          .addFormParam("Signature", "ZuMuzW/iQDRURhUJaBzvoAdNJrE454y6X0jM24lcxxk%3D")
+                                                          .addFormParam("SignatureMethod", "HmacSHA256")
+                                                          .addFormParam("SignatureVersion", "2")
+                                                          .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                          .addFormParam("UserGroup.1", "all")
+                                                          .addFormParam("UserId.1", "bob")
+                                                          .addFormParam("UserId.2", "sue")
+                                                          .addFormParam("Version", "2010-08-31")
+                                                          .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testAddLaunchPermissionsToImage() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "addLaunchPermissionsToImageInRegion", String.class,
+               Iterable.class, Iterable.class, String.class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, ImmutableList.of("bob", "sue"), ImmutableList
+               .of("all"), "imageId"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, addLaunchPermission.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+
+      assertResponseParserClassEquals(method, request, ReleasePayloadAndReturn.class);
+      assertSaxResponseParserClassEquals(method, null);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest removeLaunchPermission = HttpRequest.builder().method("POST")
+                                                   .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                   .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                   .addFormParam("Action", "ModifyImageAttribute")
+                                                   .addFormParam("Attribute", "launchPermission")
+                                                   .addFormParam("ImageId", "imageId")
+                                                   .addFormParam("OperationType", "remove")
+                                                   .addFormParam("Signature", "HreSEawbVaUp/UMicCJbhrx%2BmoX01f2pEphJCPz8/5g%3D")
+                                                   .addFormParam("SignatureMethod", "HmacSHA256")
+                                                   .addFormParam("SignatureVersion", "2")
+                                                   .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                   .addFormParam("UserGroup.1", "all")
+                                                   .addFormParam("UserId.1", "bob")
+                                                   .addFormParam("UserId.2", "sue")
+                                                   .addFormParam("Version", "2010-08-31")
+                                                   .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testRemoveLaunchPermissionsFromImage() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "removeLaunchPermissionsFromImageInRegion", String.class,
+               Iterable.class, Iterable.class, String.class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, ImmutableList.of("bob", "sue"), ImmutableList
+               .of("all"), "imageId"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, removeLaunchPermission.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+      assertResponseParserClassEquals(method, request, ReleasePayloadAndReturn.class);
+      assertSaxResponseParserClassEquals(method, null);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+
+   HttpRequest resetLaunchPermissionsOnImage = HttpRequest.builder().method("POST")
+                                                          .endpoint("https://ec2.us-east-1.amazonaws.com/")
+                                                          .addHeader("Host", "ec2.us-east-1.amazonaws.com")
+                                                          .addFormParam("Action", "ResetImageAttribute")
+                                                          .addFormParam("Attribute", "launchPermission")
+                                                          .addFormParam("ImageId", "imageId")
+                                                          .addFormParam("Signature", "fVCR9aGYvNX/Jt1/uqBGcUQRLrHwxtcvmNYKzpul1P4%3D")
+                                                          .addFormParam("SignatureMethod", "HmacSHA256")
+                                                          .addFormParam("SignatureVersion", "2")
+                                                          .addFormParam("Timestamp", "2009-11-08T15%3A54%3A08.897Z")
+                                                          .addFormParam("Version", "2010-08-31")
+                                                          .addFormParam("AWSAccessKeyId", "identity").build();
+
+   public void testResetLaunchPermissionsOnImage() throws SecurityException, NoSuchMethodException, IOException {
+      Invokable<?, ?> method = method(AMIApi.class, "resetLaunchPermissionsOnImageInRegion", String.class,
+               String.class);
+      GeneratedHttpRequest request = processor.createRequest(method, Lists.<Object> newArrayList(null, "imageId"));
+
+      request = (GeneratedHttpRequest) request.getFilters().get(0).filter(request);
+      
+      assertRequestLineEquals(request, "POST https://ec2.us-east-1.amazonaws.com/ HTTP/1.1");
+      assertNonPayloadHeadersEqual(request, "Host: ec2.us-east-1.amazonaws.com\n");
+      assertPayloadEquals(request, resetLaunchPermissionsOnImage.getPayload().getRawContent().toString(),
+            "application/x-www-form-urlencoded", false);
+      assertResponseParserClassEquals(method, request, ReleasePayloadAndReturn.class);
+      assertSaxResponseParserClassEquals(method, null);
+      assertFallbackClassEquals(method, null);
+
+      checkFilters(request);
+   }
+}