newrelic-amazon-ec2 0.6.2

data/test/test_EC2_console.rb

@@ -0,0 +1,54 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@rempe.us)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/grempe/amazon-ec2/tree/master
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "The EC2 console " do
+
+  before do
+    @ec2 = AWS::EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @get_console_output_response_body = <<-RESPONSE
+    <GetConsoleOutputResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <instanceId>i-28a64341</instanceId>
+      <timestamp>2007-01-03 15:00:00</timestamp>
+      <output>
+        YyB2ZXJzaW9uIDQuMC4xIDIwMDUwNzI3IChSZWQgSGF0IDQuMC4xLTUpKSAjMSBTTVAgVGh1IE9j
+        dCAyNiAwODo0MToyNiBTQVNUIDIwMDYKQklPUy1wcm92aWRlZCBwaHlzaWNhbCBSQU0gbWFwOgpY
+        ZW46IDAwMDAwMDAwMDAwMDAwMDAgLSAwMDAwMDAwMDZhNDAwMDAwICh1c2FibGUpCjk4ME1CIEhJ
+        R0hNRU0gYXZhaWxhYmxlLgo3MjdNQiBMT1dNRU0gYXZhaWxhYmxlLgpOWCAoRXhlY3V0ZSBEaXNh
+        YmxlKSBwcm90ZWN0aW9uOiBhY3RpdmUKSVJRIGxvY2t1cCBkZXRlY3Rpb24gZGlzYWJsZWQKQnVp
+        bHQgMSB6b25lbGlzdHMKS2VybmVsIGNvbW1hbmQgbGluZTogcm9vdD0vZGV2L3NkYTEgcm8gNApF
+        bmFibGluZyBmYXN0IEZQVSBzYXZlIGFuZCByZXN0b3JlLi4uIGRvbmUuCg==
+        </output>
+    </GetConsoleOutputResponse>
+    RESPONSE
+
+  end
+
+
+  specify "should return info written to a specific instances console" do
+    @ec2.stubs(:make_request).with('GetConsoleOutput', {"InstanceId"=>"i-2ea64347"}).
+       returns stub(:body => @get_console_output_response_body, :is_a? => true)
+    @ec2.get_console_output( :instance_id => "i-2ea64347" ).should.be.an.instance_of Hash
+    response = @ec2.get_console_output( :instance_id => "i-2ea64347" )
+    response.instanceId.should.equal "i-28a64341"
+    response.timestamp.should.equal "2007-01-03 15:00:00"
+  end
+
+
+  specify "method get_console_output should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.get_console_output() }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.get_console_output(:instance_id => nil) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.get_console_output(:instance_id => "") }.should.raise(AWS::ArgumentError)
+  end
+
+
+end

data/test/test_EC2_elastic_ips.rb

@@ -0,0 +1,144 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@rempe.us)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/grempe/amazon-ec2/tree/master
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "EC2 elastic IP addresses " do
+
+  before do
+    @ec2 = AWS::EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @allocate_address_body = <<-RESPONSE
+    <AllocateAddressResponse xmlns="http://ec2.amazonaws.com/doc/2008-02-01">
+      <publicIp>67.202.55.255</publicIp>
+    </AllocateAddressResponse>
+    RESPONSE
+
+    @describe_addresses_response_body = <<-RESPONSE
+    <DescribeAddressesResponse xmlns="http://ec2.amazonaws.com/doc/2008-02-01">
+       <addressesSet>
+         <item>
+           <instanceId>i-28a64341</instanceId>
+           <publicIp>67.202.55.255</publicIp>
+         </item>
+       </addressesSet>
+    </DescribeAddressesResponse>
+    RESPONSE
+
+    @release_address_response_body = <<-RESPONSE
+    <ReleaseAddressResponse xmlns="http://ec2.amazonaws.com/doc/2008-02-01">
+      <return>true</return>
+    </ReleaseAddressResponse>
+    RESPONSE
+
+    @associate_address_response_body = <<-RESPONSE
+    <AssociateAddressResponse xmlns="http://ec2.amazonaws.com/doc/2008-02-01">
+      <return>true</return>
+    </AssociateAddressResponse>
+    RESPONSE
+
+    @disassociate_address_response_body = <<-RESPONSE
+    <DisassociateAddressResponse xmlns="http://ec2.amazonaws.com/doc/2008-02-01">
+      <return>true</return>
+    </DisassociateAddressResponse>
+    RESPONSE
+
+  end
+
+
+  specify "should be able to be created" do
+    @ec2.stubs(:make_request).with('AllocateAddress', {}).
+      returns stub(:body => @allocate_address_body, :is_a? => true)
+
+    @ec2.allocate_address.should.be.an.instance_of Hash
+
+    response = @ec2.allocate_address
+    response.publicIp.should.equal "67.202.55.255"
+  end
+
+
+  #specify "method create_keypair should reject bad arguments" do
+  #  @ec2.stubs(:make_request).with('CreateKeyPair', {"KeyName"=>"example-key-name"}).
+  #    returns stub(:body => @create_keypair_response_body, :is_a? => true)
+  #
+  #  lambda { @ec2.create_keypair( :key_name => "example-key-name" ) }.should.not.raise(AWS::ArgumentError)
+  #  lambda { @ec2.create_keypair() }.should.raise(AWS::ArgumentError)
+  #  lambda { @ec2.create_keypair( :key_name => nil ) }.should.raise(AWS::ArgumentError)
+  #  lambda { @ec2.create_keypair( :key_name => "" ) }.should.raise(AWS::ArgumentError)
+  #end
+
+
+  specify "should be able to be described with describe_addresses" do
+    @ec2.stubs(:make_request).with('DescribeAddresses', {"PublicIp.1"=>"67.202.55.255"}).
+      returns stub(:body => @describe_addresses_response_body, :is_a? => true)
+
+    @ec2.describe_addresses( :public_ip => "67.202.55.255" ).should.be.an.instance_of Hash
+
+    response = @ec2.describe_addresses( :public_ip => "67.202.55.255" )
+    response.addressesSet.item[0].instanceId.should.equal "i-28a64341"
+    response.addressesSet.item[0].publicIp.should.equal "67.202.55.255"
+  end
+
+
+  specify "should be able to be released with release_address" do
+    @ec2.stubs(:make_request).with('ReleaseAddress', {"PublicIp" => "67.202.55.255"}).
+      returns stub(:body => @release_address_response_body, :is_a? => true)
+
+    @ec2.release_address( :public_ip => "67.202.55.255" ).should.be.an.instance_of Hash
+
+    response = @ec2.release_address( :public_ip => "67.202.55.255" )
+    response.return.should.equal "true"
+  end
+
+
+  specify "should be able to be associated with an instance with associate_address" do
+    @ec2.stubs(:make_request).with('AssociateAddress', {"InstanceId" => "i-2ea64347", "PublicIp"=>"67.202.55.255"}).
+      returns stub(:body => @associate_address_response_body, :is_a? => true)
+
+    @ec2.associate_address( :instance_id => "i-2ea64347", :public_ip => "67.202.55.255" ).should.be.an.instance_of Hash
+
+    response = @ec2.associate_address( :instance_id => "i-2ea64347", :public_ip => "67.202.55.255" )
+    response.return.should.equal "true"
+  end
+
+
+  specify "method associate_address should reject bad arguments" do
+    @ec2.stubs(:make_request).with('AssociateAddress', {"InstanceId" => "i-2ea64347", "PublicIp"=>"67.202.55.255"}).
+      returns stub(:body => @associate_address_response_body, :is_a? => true)
+
+    lambda { @ec2.associate_address( :instance_id => "i-2ea64347", :public_ip => "67.202.55.255" ) }.should.not.raise(AWS::ArgumentError)
+    lambda { @ec2.associate_address() }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.associate_address( :instance_id => nil ) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.associate_address( :public_ip => "" ) }.should.raise(AWS::ArgumentError)
+  end
+
+
+  specify "should be able to be disassociated with an instance with disassociate_address" do
+    @ec2.stubs(:make_request).with('DisassociateAddress', {'PublicIp' => '67.202.55.255'}).
+      returns stub(:body => @disassociate_address_response_body, :is_a? => true)
+
+    @ec2.disassociate_address( :public_ip => "67.202.55.255" ).should.be.an.instance_of Hash
+
+    response = @ec2.disassociate_address( :public_ip => "67.202.55.255" )
+    response.return.should.equal "true"
+  end
+
+
+  specify "method disassociate_address should reject bad arguments" do
+    @ec2.stubs(:make_request).with('DisassociateAddress', {'PublicIp' => '67.202.55.255'}).
+      returns stub(:body => @disassociate_address_response_body, :is_a? => true)
+
+    lambda { @ec2.disassociate_address( :public_ip => "67.202.55.255" ) }.should.not.raise(AWS::ArgumentError)
+    lambda { @ec2.disassociate_address() }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.disassociate_address( :public_ip => "" ) }.should.raise(AWS::ArgumentError)
+  end
+
+
+end

data/test/test_EC2_image_attributes.rb

@@ -0,0 +1,238 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@rempe.us)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/grempe/amazon-ec2/tree/master
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "EC2 image_attributes " do
+
+  before do
+    @ec2 = AWS::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-03-01">
+      <return>true</return>
+    </ModifyImageAttributeResponse>
+    RESPONSE
+
+    @reset_image_attribute_response_body = <<-RESPONSE
+    <ResetImageAttributeResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <return>true</return>
+    </ResetImageAttributeResponse>
+    RESPONSE
+
+    @describe_image_attribute_response_body_launch_permissions = <<-RESPONSE
+    <DescribeImageAttributeResponse xm-lns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <imageId>ami-61a54008</imageId>
+      <launchPermission>
+        <item>
+          <group>all</group>
+        </item>
+        <item>
+          <userId>495219933132</userId>
+        </item>
+      </launchPermission>
+    </DescribeImageAttributeResponse>
+    RESPONSE
+
+    @describe_image_attribute_response_body_product_codes = <<-RESPONSE
+    <DescribeImageAttributeResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-03">
+      <imageId>ami-61a54008</imageId>
+      <productCodes>
+        <item>
+          <productCode>774F4FF8</productCode>
+        </item>
+      </productCodes>
+    </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 Hash
+  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 Hash
+  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 Hash
+  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 Hash
+  end
+
+
+  specify "should be able to be changed with modify_image_attribute ( with :attribute=>'productCodes')" do
+    @ec2.stubs(:make_request).with('ModifyImageAttribute', {"ImageId"=>"ami-61a54008",
+                                                            "Attribute"=>"productCodes",
+                                                            "OperationType"=>"",
+                                                            "ProductCode.1"=>"774F4FF8"}).returns stub(:body => @modify_image_attribute_response_body, :is_a? => true)
+
+    @ec2.modify_image_attribute(:image_id=>"ami-61a54008",
+                                :attribute=>"productCodes",
+                                :product_code=>["774F4FF8"]).should.be.an.instance_of Hash
+  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 Hash
+  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(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"") }.should.raise(AWS::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(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"", :attribute=>"launchPermission", :operation_type=>"add", :group=>["all"]) }.should.raise(AWS::ArgumentError)
+
+    # :attribute currently has two options which are 'launchPermission' and 'productCodes, 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(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"", :operation_type=>"add", :group=>["all"]) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"foo", :operation_type=>"add", :group=>["all"]) }.should.raise(AWS::ArgumentError)
+
+    # :attribute => 'launchPermission' 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(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :group => nil) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :group => "") }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :user_id => nil) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :user_id => "") }.should.raise(AWS::ArgumentError)
+
+    # :attribute => 'productCodes' option should fail if :product_code isn't also provided
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"productCodes", :product_code=>nil) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"productCodes", :product_code=>"") }.should.raise(AWS::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(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"", :group=>["all"]) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"foo", :group=>["all"]) }.should.raise(AWS::ArgumentError)
+  end
+
+
+  specify "method describe_image_attribute should return the proper attributes when called with launchPermission" do
+    @ec2.stubs(:make_request).with('DescribeImageAttribute', {"ImageId"=>"ami-61a54008",
+                                                              "Attribute"=>"launchPermission" }).
+      returns stub(:body => @describe_image_attribute_response_body_launch_permissions, :is_a? => true)
+
+    @ec2.describe_image_attribute(:image_id => "ami-61a54008", :attribute => "launchPermission").
+      should.be.an.instance_of Hash
+
+    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 "method describe_image_attribute should return the proper attributes when called with productCodes" do
+    @ec2.stubs(:make_request).with('DescribeImageAttribute', {"ImageId"=>"ami-61a54008",
+                                                              "Attribute"=>"productCodes" }).
+      returns stub(:body => @describe_image_attribute_response_body_product_codes, :is_a? => true)
+
+    @ec2.describe_image_attribute(:image_id => "ami-61a54008", :attribute => "productCodes").
+      should.be.an.instance_of Hash
+
+    response = @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>"productCodes")
+    response.imageId.should.equal "ami-61a54008"
+    response.productCodes.item[0].productCode.should.equal "774F4FF8"
+  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(AWS::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"") }.should.raise(AWS::ArgumentError)
+
+    # :image_id option must be not be empty or nil w/ launchPermission
+    lambda { @ec2.describe_image_attribute(:image_id=>nil, :attribute=>"launchPermission") }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"", :attribute=>"launchPermission") }.should.raise(AWS::ArgumentError)
+
+    # :image_id option must be not be empty or nil w/ productCodes
+    lambda { @ec2.describe_image_attribute(:image_id=>nil, :attribute=>"productCodes") }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"", :attribute=>"productCodes") }.should.raise(AWS::ArgumentError)
+
+    # :attribute currently has two options which are 'launchPermission' and 'productCodes', it should fail with any other values,
+    # nil, or empty
+    lambda { @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>nil) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>"") }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>"foo") }.should.raise(AWS::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 Hash
+    @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(AWS::ArgumentError)
+    lambda { @ec2.reset_image_attribute(:image_id=>"") }.should.raise(AWS::ArgumentError)
+
+    # :image_id option must be not be empty or nil
+    lambda { @ec2.reset_image_attribute(:image_id=>nil, :attribute=>"launchPermission") }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.reset_image_attribute(:image_id=>"", :attribute=>"launchPermission") }.should.raise(AWS::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(AWS::ArgumentError)
+    lambda { @ec2.reset_image_attribute(:image_id=>"ami-61a54008", :attribute=>"") }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.reset_image_attribute(:image_id=>"ami-61a54008", :attribute=>"foo") }.should.raise(AWS::ArgumentError)
+  end
+
+
+end

data/test/test_EC2_images.rb

@@ -0,0 +1,197 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@rempe.us)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://github.com/grempe/amazon-ec2/tree/master
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "An EC2 image " do
+
+  before do
+    @ec2 = AWS::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-03-01">
+      <imageId>ami-61a54008</imageId>
+    </RegisterImageResponse>
+    RESPONSE
+
+    @describe_image_response_body = <<-RESPONSE
+    <DescribeImagesResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <imagesSet>
+        <item>
+          <imageId>ami-61a54008</imageId>
+          <imageLocation>foobar1/image.manifest.xml</imageLocation>
+          <imageState>available</imageState>
+          <imageOwnerId>AAAATLBUXIEON5NQVUUX6OMPWBZIAAAA</imageOwnerId>
+          <isPublic>true</isPublic>
+          <productCodes>
+            <item>
+              <productCode>774F4FF8</productCode>
+            </item>
+          </productCodes>
+        </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-03-01">
+      <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 Hash
+  end
+
+
+  specify "method register_image should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.register_image() }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.register_image(:image_location => "") }.should.raise(AWS::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 Hash
+    response = @ec2.describe_images
+    response.should.be.an.instance_of Hash
+  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"
+    response.imagesSet.item[0].productCodes.item[0].productCode.should.equal "774F4FF8"
+
+    # 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 Hash
+    @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(AWS::ArgumentError)
+    lambda { @ec2.deregister_image( :image_id => nil ) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.deregister_image( :image_id => "" ) }.should.raise(AWS::ArgumentError)
+  end
+
+
+end