krisr-amazon-ec2 0.5.0

data/test/test_EC2.rb

@@ -0,0 +1,68 @@
+#--
+# 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 method " do
+
+  before do
+  end
+
+  specify "AWS::EC2::Base attribute readers should be available" do
+    @ec2 = AWS::EC2::Base.new( :access_key_id => "not a key",
+                          :secret_access_key => "not a secret",
+                          :use_ssl => true,
+                          :server => "foo.example.com" )
+
+    @ec2.use_ssl.should.equal true
+    @ec2.port.should.equal 443
+    @ec2.server.should.equal "foo.example.com"
+  end
+
+  specify "AWS::EC2::Base should work with insecure connections as well" do
+    @ec2 = AWS::EC2::Base.new( :access_key_id => "not a key",
+                          :secret_access_key => "not a secret",
+                          :use_ssl => false,
+                          :server => "foo.example.com" )
+
+    @ec2.use_ssl.should.equal false
+    @ec2.port.should.equal 80
+    @ec2.server.should.equal "foo.example.com"
+  end
+
+  specify "AWS::EC2::Base should allow specification of port" do
+    @ec2 = AWS::EC2::Base.new( :access_key_id => "not a key",
+                          :secret_access_key => "not a secret",
+                          :use_ssl => true,
+                          :server => "foo.example.com",
+                          :port => 8443 )
+
+    @ec2.use_ssl.should.equal true
+    @ec2.port.should.equal 8443
+    @ec2.server.should.equal "foo.example.com"
+  end
+
+  specify "AWS.canonical_string(path) should conform to Amazon's requirements " do
+    path = {"name1" => "value1", "name2" => "value2", "name3" => "value3"}
+    if ENV['EC2_URL'].nil? || ENV['EC2_URL'] == 'https://ec2.amazonaws.com'
+      AWS.canonical_string(path, 'ec2.amazonaws.com').should.equal "POST\nec2.amazonaws.com\n/\nname1=value1&name2=value2&name3=value3"
+    elsif ENV['EC2_URL'] == 'https://us-east-1.ec2.amazonaws.com'
+      AWS.canonical_string(path, 'ec2.amazonaws.com').should.equal "POST\nus-east-1.ec2.amazonaws.com\n/\nname1=value1&name2=value2&name3=value3"
+    elsif ENV['EC2_URL'] == 'https://eu-west-1.ec2.amazonaws.com'
+      AWS.canonical_string(path, 'ec2.amazonaws.com').should.equal "POST\neu-west-1.ec2.amazonaws.com\n/\nname1=value1&name2=value2&name3=value3"
+    end
+  end
+
+  specify "AWS.encode should return the expected string" do
+    AWS.encode("secretaccesskey", "foobar123", urlencode=true).should.equal "e3jeuDc3DIX2mW8cVqWiByj4j5g%3D"
+    AWS.encode("secretaccesskey", "foobar123", urlencode=false).should.equal "e3jeuDc3DIX2mW8cVqWiByj4j5g="
+  end
+
+end

data/test/test_EC2_availability_zones.rb

@@ -0,0 +1,49 @@
+#--
+# 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 availability zones" do
+
+  before do
+    @ec2 = AWS::EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @describe_availability_zones_response_body = <<-RESPONSE
+    <DescribeAvailabilityZonesResponse xmlns="http://ec2.amazonaws.com/doc/2008-02-01/">
+      <availabilityZoneInfo>
+        <item>
+          <zoneName>us-east-1a</zoneName>
+          <zoneState>available</zoneState>
+        </item>
+        <item>
+          <zoneName>us-east-1b</zoneName>
+          <zoneState>available</zoneState>
+        </item>
+      </availabilityZoneInfo>
+    </DescribeAvailabilityZonesResponse>
+    RESPONSE
+
+ end
+
+  specify "should be able to be described with describe_availability_zones" do
+    @ec2.stubs(:make_request).with('DescribeAvailabilityZones', { "ZoneName.1" => "us-east-1a", "ZoneName.2" => "us-east-1b" }).
+      returns stub(:body => @describe_availability_zones_response_body, :is_a? => true)
+    @ec2.describe_availability_zones( :zone_name => ["us-east-1a", "us-east-1b"] ).should.be.an.instance_of Hash
+
+    response = @ec2.describe_availability_zones( :zone_name => ["us-east-1a", "us-east-1b"] )
+
+    response.availabilityZoneInfo.item[0].zoneName.should.equal "us-east-1a"
+    response.availabilityZoneInfo.item[0].zoneState.should.equal "available"
+
+    response.availabilityZoneInfo.item[1].zoneName.should.equal "us-east-1b"
+    response.availabilityZoneInfo.item[1].zoneState.should.equal "available"
+  end
+
+end

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