amazon-ec2 0.1.0 → 0.2.0

data/test/test_EC2_image_attributes.rb

@@ -0,0 +1,188 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "EC2 image_attributes " do
+  
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+    
+    @modify_image_attribute_response_body = <<-RESPONSE
+    <ModifyImageAttributeResponse xm-lns="http://ec2.amazonaws.com/doc/2007-01-19">
+      <return>true</return>
+    </ModifyImageAttributeResponse>
+    RESPONSE
+    
+    @reset_image_attribute_response_body = <<-RESPONSE
+    <ResetImageAttributeResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19"> 
+      <return>true</return>
+    </ResetImageAttributeResponse>
+    RESPONSE
+    
+    @describe_image_attribute_response_body = <<-RESPONSE
+    <DescribeImageAttributeResponse xm-lns="http://ec2.amazonaws.com/doc/2007-01-19">
+      <imageId>ami-61a54008</imageId>
+      <launchPermission>
+        <item>
+          <group>all</group>
+        </item>
+        <item>
+          <userId>495219933132</userId>
+        </item>
+      </launchPermission>
+    </DescribeImageAttributeResponse>
+    RESPONSE
+    
+  end
+  
+  
+  specify "should be able to be changed with modify_image_attribute (with :attribute and single value :user_id and :group)" do
+    @ec2.stubs(:make_request).with('ModifyImageAttribute', {"ImageId"=>"ami-61a54008", 
+                                                            "Attribute"=>"launchPermission", 
+                                                            "OperationType"=>"add",
+                                                            "UserId.1"=>"123",
+                                                            "Group.1"=>"all"}).
+       returns stub(:body => @modify_image_attribute_response_body, :is_a? => true)
+    @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :user_id=>["123"], :group=>["all"]).should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "should be able to be changed with modify_image_attribute ( with :attribute but specifying :group only)" do
+    @ec2.stubs(:make_request).with('ModifyImageAttribute', {"ImageId"=>"ami-61a54008", 
+                                                            "Attribute"=>"launchPermission", 
+                                                            "OperationType"=>"add",
+                                                            "Group.1"=>"all"}).
+       returns stub(:body => @modify_image_attribute_response_body, :is_a? => true)
+    @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :group=>["all"]).should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "should be able to be changed with modify_image_attribute ( with :operation_type 'remove')" do
+    @ec2.stubs(:make_request).with('ModifyImageAttribute', {"ImageId"=>"ami-61a54008", 
+                                                            "Attribute"=>"launchPermission", 
+                                                            "OperationType"=>"remove",
+                                                            "Group.1"=>"all"}).
+       returns stub(:body => @modify_image_attribute_response_body, :is_a? => true)
+    @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"remove", :group=>["all"]).should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "should be able to be changed with modify_image_attribute ( with :attribute but specifying :user_id only)" do
+    @ec2.stubs(:make_request).with('ModifyImageAttribute', {"ImageId"=>"ami-61a54008", 
+                                                            "Attribute"=>"launchPermission", 
+                                                            "OperationType"=>"add",
+                                                            "UserId.1"=>"123"}).returns stub(:body => @modify_image_attribute_response_body, :is_a? => true)
+                                                            
+    @ec2.modify_image_attribute(:image_id=>"ami-61a54008", 
+                                :attribute=>"launchPermission", 
+                                :operation_type=>"add", 
+                                :user_id=>["123"]).should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "should be able to be changed with modify_image_attribute ( with :attribute and multiple :user_id and :group elements)" do
+    @ec2.stubs(:make_request).with('ModifyImageAttribute', {"ImageId"=>"ami-61a54008", 
+                                                            "Attribute"=>"launchPermission", 
+                                                            "OperationType"=>"add",
+                                                            "UserId.1"=>"123",
+                                                            "UserId.2"=>"345",
+                                                            "Group.1"=>"123",
+                                                            "Group.2"=>"all"}).returns stub(:body => @modify_image_attribute_response_body, :is_a? => true)
+       
+    @ec2.modify_image_attribute(:image_id=>"ami-61a54008", 
+                                :attribute=>"launchPermission", 
+                                :operation_type=>"add", 
+                                :user_id=>["123", "345"], 
+                                :group=>["123", "all"]).should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "should raise an exception when modify_image_attribute is called with incorrect arguments" do
+    # method args can't be nil or empty
+    lambda { @ec2.modify_image_attribute() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"") }.should.raise(EC2::ArgumentError)
+    
+    # :image_id option must be not be empty or nil
+    lambda { @ec2.modify_image_attribute(:image_id=>nil, :attribute=>"launchPermission", :operation_type=>"add", :group=>["all"]) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"", :attribute=>"launchPermission", :operation_type=>"add", :group=>["all"]) }.should.raise(EC2::ArgumentError)
+    
+    # :attribute currently has one option which is 'launchPermission', it should fail with any other value, nil, or empty
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>nil, :operation_type=>"add", :group=>["all"]) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"", :operation_type=>"add", :group=>["all"]) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"foo", :operation_type=>"add", :group=>["all"]) }.should.raise(EC2::ArgumentError)
+    
+    # :attribute option should fail if neither :group nor :user_id are also provided
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add") }.should.raise(EC2::ArgumentError)
+    
+    # :operation_type currently has two options which are 'add' and 'remove', and it should fail with any other, nil or empty
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>nil, :group=>["all"]) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"", :group=>["all"]) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"foo", :group=>["all"]) }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+  specify "method describe_image_attribute should return the proper attributes" do
+    @ec2.stubs(:make_request).with('DescribeImageAttribute', {"ImageId"=>"ami-61a54008", 
+                                                              "Attribute"=>"launchPermission" }).
+      returns stub(:body => @describe_image_attribute_response_body, :is_a? => true)
+    
+    @ec2.describe_image_attribute(:image_id => "ami-61a54008", :attribute => "launchPermission").
+      should.be.an.instance_of EC2::Response
+    
+    response = @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission")
+    response.imageId.should.equal "ami-61a54008"
+    response.launchPermission.item[0].group.should.equal "all"
+    response.launchPermission.item[1].userId.should.equal "495219933132"
+  end
+  
+  
+  specify "should raise an exception when describe_image_attribute is called with incorrect arguments" do
+    # method args can't be nil or empty
+    lambda { @ec2.describe_image_attribute() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"") }.should.raise(EC2::ArgumentError)
+    
+    # :image_id option must be not be empty or nil
+    lambda { @ec2.describe_image_attribute(:image_id=>nil, :attribute=>"launchPermission") }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"", :attribute=>"launchPermission") }.should.raise(EC2::ArgumentError)
+    
+    # :attribute currently has one option which is 'launchPermission', it should fail with any other value, nil, or empty
+    lambda { @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>nil) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>"") }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>"foo") }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+  specify "should be able to reset attributes with reset_image_attribute " do
+    @ec2.stubs(:make_request).with('ResetImageAttribute', {"ImageId"=>"ami-61a54008", 
+                                                            "Attribute"=>"launchPermission"}).
+       returns stub(:body => @reset_image_attribute_response_body, :is_a? => true)
+    @ec2.reset_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission").should.be.an.instance_of EC2::Response
+    @ec2.reset_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission").return.should.equal "true"
+  end
+  
+  
+  specify "should raise an exception when reset_image_attribute is called with incorrect arguments" do
+    # method args can't be nil or empty
+    lambda { @ec2.reset_image_attribute() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.reset_image_attribute(:image_id=>"") }.should.raise(EC2::ArgumentError)
+    
+    # :image_id option must be not be empty or nil
+    lambda { @ec2.reset_image_attribute(:image_id=>nil, :attribute=>"launchPermission") }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.reset_image_attribute(:image_id=>"", :attribute=>"launchPermission") }.should.raise(EC2::ArgumentError)
+    
+    # :attribute currently has one option which is 'launchPermission', it should fail with any other value, nil, or empty
+    lambda { @ec2.reset_image_attribute(:image_id=>"ami-61a54008", :attribute=>nil) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.reset_image_attribute(:image_id=>"ami-61a54008", :attribute=>"") }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.reset_image_attribute(:image_id=>"ami-61a54008", :attribute=>"foo") }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+end

data/test/test_EC2_images.rb

@@ -0,0 +1,191 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "An EC2 image " do
+  
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+    
+    @register_image_response_body = <<-RESPONSE
+    <RegisterImageResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19"> 
+      <imageId>ami-61a54008</imageId>
+    </RegisterImageResponse>
+    RESPONSE
+    
+    @describe_image_response_body = <<-RESPONSE
+    <DescribeImagesResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19"> 
+      <imagesSet>
+        <item>
+          <imageId>ami-61a54008</imageId>
+          <imageLocation>foobar1/image.manifest.xml</imageLocation>
+          <imageState>available</imageState>
+          <imageOwnerId>AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA</imageOwnerId>
+          <isPublic>true</isPublic>
+        </item>
+        <item>
+          <imageId>ami-61a54009</imageId>
+          <imageLocation>foobar2/image.manifest.xml</imageLocation>
+          <imageState>deregistered</imageState>
+          <imageOwnerId>ZZZZTLBUXIEON5NQVUUX6OMPWBZIZZZZ</imageOwnerId>
+          <isPublic>false</isPublic>
+        </item>
+      </imagesSet>
+    </DescribeImagesResponse>
+    RESPONSE
+    
+    @deregister_image_response_body = <<-RESPONSE
+    <DeregisterImageResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19"> 
+      <return>true</return> 
+    </DeregisterImageResponse>
+    RESPONSE
+    
+  end
+  
+  
+  specify "should be able to be registered" do
+    @ec2.stubs(:make_request).with('RegisterImage', {"ImageLocation"=>"mybucket-myimage.manifest.xml"}).
+      returns stub(:body => @register_image_response_body, :is_a? => true)
+    @ec2.register_image(:image_location => "mybucket-myimage.manifest.xml").imageId.should.equal "ami-61a54008"
+    @ec2.register_image(:image_location => "mybucket-myimage.manifest.xml").should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "method register_image should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.register_image() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.register_image(:image_location => "") }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+  specify "should be able to be described and return the correct Ruby response class for parent and members" do
+    @ec2.stubs(:make_request).with('DescribeImages', {}).
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images.should.be.an.instance_of EC2::Response
+    response = @ec2.describe_images
+    response.should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "should be able to be described with no params and return an imagesSet" do
+    @ec2.stubs(:make_request).with('DescribeImages', {}).
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images.imagesSet.item.length.should.equal 2
+  end
+  
+  specify "should be able to be described by an Array of ImageId.N ID's and return an array of Items" do
+    @ec2.stubs(:make_request).with('DescribeImages', {"ImageId.1"=>"ami-61a54008", "ImageId.2"=>"ami-61a54009"}).
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images( :image_id => ["ami-61a54008", "ami-61a54009"] ).imagesSet.item.length.should.equal 2
+    
+    response = @ec2.describe_images( :image_id => ["ami-61a54008", "ami-61a54009"] )
+    
+    # test first 'Item' object returned
+    response.imagesSet.item[0].imageId.should.equal "ami-61a54008"
+    response.imagesSet.item[0].imageLocation.should.equal "foobar1/image.manifest.xml"
+    response.imagesSet.item[0].imageState.should.equal "available"
+    response.imagesSet.item[0].imageOwnerId.should.equal "AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA"
+    response.imagesSet.item[0].isPublic.should.equal "true"
+    
+    # test second 'Item' object returned
+    response.imagesSet.item[1].imageId.should.equal "ami-61a54009"
+    response.imagesSet.item[1].imageLocation.should.equal "foobar2/image.manifest.xml"
+    response.imagesSet.item[1].imageState.should.equal "deregistered"
+    response.imagesSet.item[1].imageOwnerId.should.equal "ZZZZTLBUXIEON5NQVUUX6OMPWBZIZZZZ"
+    response.imagesSet.item[1].isPublic.should.equal "false"
+  end
+  
+  
+  specify "should be able to be described by an owners with Owner.N ID's and return an array of Items" do
+    @ec2.stubs(:make_request).with('DescribeImages', "Owner.1" => "AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA", "Owner.2" => "ZZZZTLBUXIEON5NQVUUX6OMPWBZIZZZZ").
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images( :owner_id => ["AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA", "ZZZZTLBUXIEON5NQVUUX6OMPWBZIZZZZ"] ).imagesSet.item.length.should.equal 2
+    
+    # owner ID's
+    response = @ec2.describe_images( :owner_id => ["AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA", "ZZZZTLBUXIEON5NQVUUX6OMPWBZIZZZZ"] )
+    response.imagesSet.item[0].imageId.should.equal "ami-61a54008"
+    response.imagesSet.item[1].imageId.should.equal "ami-61a54009"
+  end
+  
+  
+  specify "should be able to be described by an owner of 'self' and return an array of Items that I own" do
+    @ec2.stubs(:make_request).with('DescribeImages', "Owner.1" => "self").
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images( :owner_id => "self" ).imagesSet.item.length.should.equal 2
+    
+    # 'self' - Those that I own
+    response = @ec2.describe_images( :owner_id => "self" )
+    response.imagesSet.item[0].imageId.should.equal "ami-61a54008"
+  end
+  
+  
+  specify "should be able to be described by an owner of 'amazon' and return an array of Items that are Amazon Public AMI's" do
+    @ec2.stubs(:make_request).with('DescribeImages', "Owner.1" => "amazon").
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images( :owner_id => "amazon" ).imagesSet.item.length.should.equal 2
+    
+    # 'amazon' - Those that are owned and created by AWS
+    response = @ec2.describe_images( :owner_id => "amazon" )
+    response.imagesSet.item[0].imageId.should.equal "ami-61a54008"
+  end
+  
+  
+  specify "should be able to be described by an owners with Owner.N ID's who can execute AMI's and return an array of Items" do
+    @ec2.stubs(:make_request).with('DescribeImages', "ExecutableBy.1" => "AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA", "ExecutableBy.2" => "ZZZZTLBUXIEON5NQVUUX6OMPWBZIZZZZ").
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images( :executable_by => ["AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA", "ZZZZTLBUXIEON5NQVUUX6OMPWBZIZZZZ"] ).imagesSet.item.length.should.equal 2
+    
+    # executable by owner ID's
+    response = @ec2.describe_images( :executable_by => ["AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA", "ZZZZTLBUXIEON5NQVUUX6OMPWBZIZZZZ"] )
+    response.imagesSet.item[0].imageId.should.equal "ami-61a54008"
+    response.imagesSet.item[1].imageId.should.equal "ami-61a54009"
+  end
+  
+  
+  specify "should be able to be described by an owners with Owner.N of 'self' who can execute AMI's and return an array of Items" do
+    @ec2.stubs(:make_request).with('DescribeImages', "ExecutableBy.1" => "self").
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images( :executable_by => "self" ).imagesSet.item.length.should.equal 2
+    
+    # executable by owner ID's
+    response = @ec2.describe_images( :executable_by => "self" )
+    response.imagesSet.item[0].imageId.should.equal "ami-61a54008"
+    response.imagesSet.item[1].imageId.should.equal "ami-61a54009"
+  end
+  
+  
+  specify "should be able to be described by an owners with Owner.N of 'all' who can execute AMI's and return an array of Items" do
+    @ec2.stubs(:make_request).with('DescribeImages', "ExecutableBy.1" => "all").
+      returns stub(:body => @describe_image_response_body, :is_a? => true)
+    @ec2.describe_images( :executable_by => "all" ).imagesSet.item.length.should.equal 2
+    
+    # executable by owner ID's
+    response = @ec2.describe_images( :executable_by => "all" )
+    response.imagesSet.item[0].imageId.should.equal "ami-61a54008"
+    response.imagesSet.item[1].imageId.should.equal "ami-61a54009"
+  end
+  
+  
+  specify "should be able to be de-registered" do
+    @ec2.stubs(:make_request).with('DeregisterImage', {"ImageId"=>"ami-61a54008"}).
+      returns stub(:body => @deregister_image_response_body, :is_a? => true)
+    @ec2.deregister_image(:image_id => "ami-61a54008" ).should.be.an.instance_of EC2::Response
+    @ec2.deregister_image(:image_id => "ami-61a54008" ).return.should.equal "true"
+  end
+  
+  
+  specify "method deregister_image should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.deregister_image() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.deregister_image( :image_id => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.deregister_image( :image_id => "" ) }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+end

data/test/test_EC2_instances.rb

@@ -0,0 +1,303 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "EC2 instances " do
+  
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+    
+    @run_instances_response_body = <<-RESPONSE
+    <RunInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19">
+      <reservationId>r-47a5402e</reservationId>
+      <ownerId>495219933132</ownerId>
+      <groupSet>
+        <item>
+          <groupId>default</groupId>
+        </item>
+      </groupSet>
+      <instancesSet>
+        <item>
+          <instanceId>i-2ba64342</instanceId>
+          <imageId>ami-60a54009</imageId>
+          <instanceState>
+            <code>0</code>
+            <name>pending</name>
+          </instanceState>
+          <privateDnsName/>
+          <dnsName/>
+          <keyName>example-key-name</keyName>
+        </item>
+        <item>
+          <instanceId>i-2bc64242</instanceId>
+          <imageId>ami-60a54009</imageId>
+          <instanceState>
+            <code>0</code>
+            <name>pending</name>
+          </instanceState>
+          <privateDnsName/>
+          <dnsName/>
+          <keyName>example-key-name</keyName>
+        </item>
+        <item>
+          <instanceId>i-2be64332</instanceId>
+          <imageId>ami-60a54009</imageId>
+          <instanceState>
+            <code>0</code>
+            <name>pending</name>
+          </instanceState>
+          <privateDnsName/>
+          <dnsName/>
+          <keyName>example-key-name</keyName>
+        </item>
+      </instancesSet>
+    </RunInstancesResponse>
+    RESPONSE
+    
+    @describe_instances_response_body = <<-RESPONSE
+    <DescribeInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19">
+      <reservationSet>
+        <item>
+          <reservationId>r-44a5402d</reservationId>
+          <ownerId>UYY3TLBUXIEON5NQVUUX6OMPWBZIQNFM</ownerId>
+          <groupSet>
+            <item>
+              <groupId>default</groupId>
+            </item>
+          </groupSet>
+          <instancesSet>
+            <item>
+              <instanceId>i-28a64341</instanceId>
+              <imageId>ami-6ea54007</imageId>
+              <instanceState>
+                <code>0</code>
+                <name>running</name>
+              </instanceState>
+              <privateDnsName>domU-12-31-35-00-1E-01.z-2.compute-1.internal</privateDnsName>
+              <dnsName>ec2-72-44-33-4.z-2.compute-1.amazonaws.com</dnsName>
+              <keyName>example-key-name</keyName>
+            </item>
+          </instancesSet>
+        </item>
+      </reservationSet>
+    </DescribeInstancesResponse>
+    RESPONSE
+    
+    @reboot_instances_response_body = <<-RESPONSE
+    <RebootInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19">
+      <return>true</return>
+    </RebootInstancesResponse>
+    RESPONSE
+    
+    @terminate_instances_response_body = <<-RESPONSE
+    <TerminateInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19"> 
+      <instancesSet> 
+        <item> 
+          <instanceId>i-28a64341</instanceId> 
+          <shutdownState> 
+            <code>32</code> 
+            <name>shutting-down</name> 
+          </shutdownState> 
+          <previousState> 
+            <code>0</code> 
+            <name>pending</name> 
+          </previousState> 
+        </item> 
+        <item> 
+          <instanceId>i-21a64348</instanceId> 
+          <shutdownState> 
+            <code>32</code> 
+            <name>shutting-down</name> 
+          </shutdownState> 
+          <previousState> 
+            <code>0</code> 
+            <name>pending</name> 
+          </previousState> 
+        </item> 
+      </instancesSet> 
+    </TerminateInstancesResponse>
+    RESPONSE
+  end
+  
+  
+  specify "should be able to be run" do
+    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "AddressingType" => 'public').
+      returns stub(:body => @run_instances_response_body, :is_a? => true)
+      
+    @ec2.run_instances( :image_id => "ami-60a54009" ).should.be.an.instance_of EC2::Response
+    
+    response = @ec2.run_instances( :image_id => "ami-60a54009" )
+    
+    response.reservationId.should.equal "r-47a5402e"
+    response.ownerId.should.equal "495219933132"
+    
+    response.groupSet.item[0].groupId.should.equal "default"
+    
+    response.instancesSet.item.length.should.equal 3
+    
+    response.instancesSet.item[0].instanceId.should.equal "i-2ba64342"
+    response.instancesSet.item[0].imageId.should.equal "ami-60a54009"
+    response.instancesSet.item[0].instanceState.code.should.equal "0"
+    response.instancesSet.item[0].instanceState.name.should.equal "pending"
+    response.instancesSet.item[0].privateDnsName
+    response.instancesSet.item[0].dnsName.should.be.nil
+    response.instancesSet.item[0].keyName.should.equal "example-key-name"
+    
+    response.instancesSet.item[1].instanceId.should.equal "i-2bc64242"
+    response.instancesSet.item[1].imageId.should.equal "ami-60a54009"
+    response.instancesSet.item[1].instanceState.code.should.equal "0"
+    response.instancesSet.item[1].instanceState.name.should.equal "pending"
+    response.instancesSet.item[1].privateDnsName
+    response.instancesSet.item[1].dnsName.should.be.nil
+    response.instancesSet.item[1].keyName.should.equal "example-key-name"
+    
+    response.instancesSet.item[2].instanceId.should.equal "i-2be64332"
+    response.instancesSet.item[2].imageId.should.equal "ami-60a54009"
+    response.instancesSet.item[2].instanceState.code.should.equal "0"
+    response.instancesSet.item[2].instanceState.name.should.equal "pending"
+    response.instancesSet.item[2].privateDnsName
+    response.instancesSet.item[2].dnsName.should.be.nil
+    response.instancesSet.item[2].keyName.should.equal "example-key-name"
+  end
+  
+  
+  specify "method 'run_instances' should reject invalid arguments" do
+    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "AddressingType" => 'public').
+      returns stub(:body => @run_instances_response_body, :is_a? => true)
+    
+    lambda { @ec2.run_instances() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "" ) }.should.raise(EC2::ArgumentError)
+    
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1 ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 0 ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :min_count => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :min_count => "" ) }.should.raise(EC2::ArgumentError)
+    
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :max_count => 1 ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :max_count => 0 ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :max_count => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :max_count => "" ) }.should.raise(EC2::ArgumentError)
+    
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :addressing_type => "public" ) }.should.not.raise(EC2::ArgumentError)
+    #lambda { @ec2.run_instances( :image_id => "ami-60a54009", :addressing_type => "direct" ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :addressing_type => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :addressing_type => "" ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :addressing_type => "foo" ) }.should.raise(EC2::ArgumentError)
+    
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :base64_encoded => true ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :base64_encoded => false ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :base64_encoded => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :base64_encoded => "" ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.run_instances( :image_id => "ami-60a54009", :base64_encoded => "foo" ) }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+  specify "should be able to call run_instances with :user_data and :base64_encoded => true (default is false)" do
+    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "UserData" => "foo", "AddressingType" => 'public').
+      returns stub(:body => @run_instances_response_body, :is_a? => true)
+    @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1, :max_count => 1, :group_id => [], :user_data => "foo", :base64_encoded => true ).should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "should be able to call run_instances with :user_data and :base64_encoded => false" do
+    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "UserData" => "Zm9v", "AddressingType" => 'public').
+      returns stub(:body => @run_instances_response_body, :is_a? => true)
+    @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1, :max_count => 1, :group_id => [], :user_data => "foo", :base64_encoded => false ).should.be.an.instance_of EC2::Response
+  end
+  
+  
+  specify "should be able to be described and return the correct Ruby response class" do
+    @ec2.stubs(:make_request).with('DescribeInstances', {}).
+      returns stub(:body => @describe_instances_response_body, :is_a? => true)
+    @ec2.describe_instances.should.be.an.instance_of EC2::Response
+    response = @ec2.describe_instances
+    response.reservationSet.item[0].reservationId.should.equal "r-44a5402d"
+  end
+  
+  
+  specify "should be able to be described with no params and return an array of Items" do
+    @ec2.stubs(:make_request).with('DescribeInstances', {}).
+      returns stub(:body => @describe_instances_response_body, :is_a? => true)
+    @ec2.describe_instances.reservationSet.item.length.should.equal 1
+    response = @ec2.describe_instances
+    response.reservationSet.item[0].reservationId.should.equal "r-44a5402d"
+    response.reservationSet.item[0].ownerId.should.equal "UYY3TLBUXIEON5NQVUUX6OMPWBZIQNFM"
+    response.reservationSet.item[0].groupSet.item[0].groupId.should.equal "default"
+    response.reservationSet.item[0].instancesSet.item[0].instanceId.should.equal "i-28a64341"
+    response.reservationSet.item[0].instancesSet.item[0].imageId.should.equal "ami-6ea54007"
+    response.reservationSet.item[0].instancesSet.item[0].instanceState.code.should.equal "0"
+    response.reservationSet.item[0].instancesSet.item[0].instanceState.name.should.equal "running"
+    response.reservationSet.item[0].instancesSet.item[0].privateDnsName.should.equal "domU-12-31-35-00-1E-01.z-2.compute-1.internal"
+    response.reservationSet.item[0].instancesSet.item[0].dnsName.should.equal "ec2-72-44-33-4.z-2.compute-1.amazonaws.com"
+    response.reservationSet.item[0].instancesSet.item[0].keyName.should.equal "example-key-name"
+  end
+  
+  
+  specify "should be able to be described with params of Array of :instance_id's and return an array of Items" do
+    @ec2.stubs(:make_request).with('DescribeInstances', {"InstanceId.1" => "i-28a64341"}).
+      returns stub(:body => @describe_instances_response_body, :is_a? => true)
+    @ec2.describe_instances( :instance_id => "i-28a64341" ).reservationSet.item.length.should.equal 1
+    response = @ec2.describe_instances( :instance_id => "i-28a64341" )
+    response.reservationSet.item[0].reservationId.should.equal "r-44a5402d"
+    response.reservationSet.item[0].ownerId.should.equal "UYY3TLBUXIEON5NQVUUX6OMPWBZIQNFM"
+    response.reservationSet.item[0].groupSet.item[0].groupId.should.equal "default"
+    response.reservationSet.item[0].instancesSet.item[0].instanceId.should.equal "i-28a64341"
+    response.reservationSet.item[0].instancesSet.item[0].imageId.should.equal "ami-6ea54007"
+    response.reservationSet.item[0].instancesSet.item[0].instanceState.code.should.equal "0"
+    response.reservationSet.item[0].instancesSet.item[0].instanceState.name.should.equal "running"
+    response.reservationSet.item[0].instancesSet.item[0].privateDnsName.should.equal "domU-12-31-35-00-1E-01.z-2.compute-1.internal"
+    response.reservationSet.item[0].instancesSet.item[0].dnsName.should.equal "ec2-72-44-33-4.z-2.compute-1.amazonaws.com"
+    response.reservationSet.item[0].instancesSet.item[0].keyName.should.equal "example-key-name"
+  end
+  
+  
+  specify "method reboot_instances should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.reboot_instances() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.reboot_instances( :instance_id => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.reboot_instances( :instance_id => "" ) }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+  specify "should be able to be rebooted when provided with an :instance_id" do
+    @ec2.expects(:make_request).with('RebootInstances', {"InstanceId.1"=>"i-2ea64347", "InstanceId.2"=>"i-21a64348"}).
+      returns stub(:body => @reboot_instances_response_body, :is_a? => true)
+    @ec2.reboot_instances( :instance_id => ["i-2ea64347", "i-21a64348"] ).class.should.equal EC2::Response
+  end
+  
+  
+  specify "method terminate_instances should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.terminate_instances() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.terminate_instances( :instance_id => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.terminate_instances( :instance_id => "" ) }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+  specify "should be able to be terminated when provided with an :instance_id" do
+    @ec2.stubs(:make_request).with('TerminateInstances', {"InstanceId.1"=>"i-28a64341", "InstanceId.2"=>"i-21a64348"}).
+      returns stub(:body => @terminate_instances_response_body, :is_a? => true)
+    @ec2.terminate_instances( :instance_id => ["i-28a64341", "i-21a64348"] ).class.should.equal EC2::Response
+    
+    @response = @ec2.terminate_instances( :instance_id => ["i-28a64341", "i-21a64348"] )
+    
+    @response.instancesSet.item[0].instanceId.should.equal "i-28a64341"
+    @response.instancesSet.item[0].shutdownState.code.should.equal "32"
+    @response.instancesSet.item[0].shutdownState.name.should.equal "shutting-down"
+    @response.instancesSet.item[0].previousState.code.should.equal "0"
+    @response.instancesSet.item[0].previousState.name.should.equal "pending"
+    
+    @response.instancesSet.item[1].instanceId.should.equal "i-21a64348"
+    @response.instancesSet.item[1].shutdownState.code.should.equal "32"
+    @response.instancesSet.item[1].shutdownState.name.should.equal "shutting-down"
+    @response.instancesSet.item[1].previousState.code.should.equal "0"
+    @response.instancesSet.item[1].previousState.name.should.equal "pending"
+  end
+  
+end