grempe-amazon-ec2 0.2.9

data/tasks/deployment.rake

@@ -0,0 +1,27 @@
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end

data/tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/tasks/website.rake

@@ -0,0 +1,17 @@
+desc 'Generate website files'
+task :website_generate => :ruby_env do
+  (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
+    sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host = "#{rubyforge_username}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{RUBYFORGE_PROJECT}/"
+  local_dir = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload, :publish_docs]

data/test/test_EC2.rb

@@ -0,0 +1,52 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:grempe@rubyforge.org)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "The EC2 method " do
+
+  setup do
+  end
+
+  specify "EC2::Base attribute readers should be available" do
+    @ec2 = 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 "EC2::Base should work with insecure connections as well" do
+    @ec2 = 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 "EC2.canonical_string(path) should data that is stripped of ?,&,= " do
+    path = "?name1=value1&name2=value2&name3=value3"
+    EC2.canonical_string(path).should.equal "name1value1name2value2name3value3"
+  end
+
+  specify "EC2.encode should return the expected string" do
+    EC2.encode("secretaccesskey", "foobar123", urlencode=true).should.equal "e3jeuDc3DIX2mW8cVqWiByj4j5g%3D"
+    EC2.encode("secretaccesskey", "foobar123", urlencode=false).should.equal "e3jeuDc3DIX2mW8cVqWiByj4j5g="
+  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:grempe@rubyforge.org)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "The EC2 console " do
+
+  setup do
+    @ec2 = 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 EC2::Response
+    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(EC2::ArgumentError)
+    lambda { @ec2.get_console_output(:instance_id => nil) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.get_console_output(:instance_id => "") }.should.raise(EC2::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:grempe@rubyforge.org)
+# Copyright:: Copyright (c) 2007-2008 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 elastic IP addresses " do
+
+  setup do
+    @ec2 = 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 EC2::Response
+
+    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(EC2::ArgumentError)
+  #  lambda { @ec2.create_keypair() }.should.raise(EC2::ArgumentError)
+  #  lambda { @ec2.create_keypair( :key_name => nil ) }.should.raise(EC2::ArgumentError)
+  #  lambda { @ec2.create_keypair( :key_name => "" ) }.should.raise(EC2::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 EC2::Response
+
+    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 EC2::Response
+
+    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 EC2::Response
+
+    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(EC2::ArgumentError)
+    lambda { @ec2.associate_address() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.associate_address( :instance_id => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.associate_address( :public_ip => "" ) }.should.raise(EC2::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 EC2::Response
+
+    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(EC2::ArgumentError)
+    lambda { @ec2.disassociate_address() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.disassociate_address( :public_ip => "" ) }.should.raise(EC2::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:grempe@rubyforge.org)
+# Copyright:: Copyright (c) 2007-2008 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-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 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=>'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 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 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(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 => '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(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :group => nil) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :group => "") }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :user_id => nil) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :user_id => "") }.should.raise(EC2::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(EC2::ArgumentError)
+    lambda { @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"productCodes", :product_code=>"") }.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 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 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 "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 EC2::Response
+
+    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(EC2::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"") }.should.raise(EC2::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(EC2::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"", :attribute=>"launchPermission") }.should.raise(EC2::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(EC2::ArgumentError)
+    lambda { @ec2.describe_image_attribute(:image_id=>"", :attribute=>"productCodes") }.should.raise(EC2::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(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