grempe-amazon-ec2 0.2.15 → 0.3.0

data/bin/ec2-gem-example.rb

@@ -11,6 +11,7 @@
 
 require 'rubygems'
 require File.dirname(__FILE__) + '/../lib/EC2'
+require 'pp'
 
 # pull these from the local shell environment variables set in ~/.bash_login
 # or using appropriate methods specific to your login shell.
@@ -36,23 +37,23 @@ p ec2.methods.sort
 
 puts "----- listing images owned by 'amazon' -----"
 ec2.describe_images(:owner_id => "amazon").imagesSet.item.each do |image|
-  image.members.each do |member|
-    puts "#{member} => #{image[member]}" 
+  image.keys.each do |key|
+    puts "#{key} => #{image[key]}" 
   end
 end
 
 puts "----- listing all running instances -----"
-puts ec2.describe_instances()
+pp ec2.describe_instances()
 
 puts "----- creating a security group -----"
-puts ec2.create_security_group(:group_name => "ec2-example-rb-test-group", :group_description => "ec-example.rb test group description.")
+pp ec2.create_security_group(:group_name => "ec2-example-rb-test-group", :group_description => "ec-example.rb test group description.")
 
 puts "----- listing security groups -----"
-puts ec2.describe_security_groups()
+pp ec2.describe_security_groups()
 
 puts "----- deleting a security group -----"
-puts ec2.delete_security_group(:group_name => "ec2-example-rb-test-group")
+pp ec2.delete_security_group(:group_name => "ec2-example-rb-test-group")
 
 puts "----- listing my keypairs (verbose mode) -----"
-puts ec2.describe_keypairs()
+pp ec2.describe_keypairs()
 

data/lib/EC2/responses.rb

@@ -8,6 +8,17 @@
 # Home::      http://amazon-ec2.rubyforge.org
 #++
 
+# This allows us to access hash values as if they were methods
+# e.g. foo[:bar] can be accessed as foo.bar
+
+class Hash
+  def method_missing(meth, *args, &block)
+    if args.size == 0
+      self[meth.to_s] || self[meth.to_sym]
+    end
+  end
+end
+
 module EC2
 
   # The make_request() and ec2_error? methods, which are shared by all, will raise any
@@ -23,14 +34,6 @@ module EC2
   # may be raised by this library in YOUR code with a 'rescue' clauses.  It is up to you
   # how gracefully you want to handle these exceptions that are raised.
 
-  # Credits :
-  # I learned the magic of making an OpenStruct object able to respond as a fully Enumerable
-  # object (responds to .each, etc.) thanks to a great blog article on Struct and OpenStruct
-  # at http://errtheblog.com/post/30
-  #
-  # Thanks to Sean Knapp for the XmlSimple response patch which greatly simplified the response
-  # mechanism for the whole library while making it more accurate and much less brittle to boot!
-  #
 
   require 'rubygems'
   begin
@@ -39,137 +42,23 @@ module EC2
     require 'xml-simple' unless defined? XmlSimple
   end
 
-
-  class Response < OpenStruct
-
-    include Enumerable
-
+  class Response
 
     def self.parse(options = {})
       options = {
         :xml => "",
         :parse_options => { 'ForceArray' => ['item'], 'SuppressEmpty' => nil }
       }.merge(options)
-      response = Response.new(XmlSimple.xml_in(options[:xml], options[:parse_options]))
-
-      # set the xml attribute of the response object to contain the original XML that was
-      # returned by amazon.  This allows anyone to bypass our parsing if desired and just
-      # get right at the raw XML response.
-      response.xml = options[:xml]
+      
+      # NOTE: Parsing the response as a nested set of Response objects was extremely
+      # memory intensive and appeared to leak (the memory was not freed on subsequent requests).
+      # It was changed to return the raw XmlSimple response.
+      
+      response = XmlSimple.xml_in(options[:xml], options[:parse_options])
+            
       return response
     end
 
-
-    # Every member of an OpenStruct object has getters and setters, the latter of which
-    # has a method ending in "=". Find all of these methods, excluding those defined on
-    # parent classes.
-    def members
-      methods(false).sort.grep(/=/).map { |m| m[0...-1] }
-    end
-
-
-    # Required by the Enumerable module. Iterate over each item in the members array
-    # and pass as a value the block passed to each using yield.
-    def each
-      members.each do |method|
-        yield send(method)
-      end
-      self
-    end
-
-
-    # Same as the each method, but with both key and value.
-    #
-    #Sample Use:
-    # obj.each_pair { |k,v| puts "key: #{k}, value: #{v}" }
-    def each_pair
-      members.each do |method|
-        yield method, send(method)
-      end
-      self
-    end
-
-
-    # Alternative method for getting members.
-    def [](member)
-      send(member)
-    end
-
-
-    # Alternative method for setting members.
-    def []=(member, value)
-      send("#{member}=", value)
-    end
-
-
-    # Helper for converting to string which support a long and short version
-    # to avoid recursion problems with parents.
-    def to_string(short=false)
-      s = "#<#{self.class}:0x#{(2 ** 32 + object_id).to_s(16).upcase}"
-      if (short)
-        s += " ..."
-      else
-        each_pair { |k,v|
-          if (v == self.parent && v.kind_of?(Response))
-            v = v.to_string(true)
-          elsif (v.kind_of?(String))
-            v = "\"#{v.gsub("\"", "\\\"")}\""
-          elsif (v.kind_of?(NilClass))
-            v = "nil"
-          end
-          s += " #{k}=#{v}"
-        }
-      end
-      s += ">"
-      return s
-    end
-
-
-    # Override of to string method.
-    def to_s
-      return to_string
-    end
-
-
-    private
-
-    # Initialize the object by passing data to the OpenStruct initialize method
-    # and then converting ourself to guarantee we have top-to-bottom data
-    # representation as a Response object.
-    def initialize(data, parent=nil)
-      super(data)
-      self.parent = parent
-      Response.convert(self, parent)
-    end
-
-
-    # The "brains" of our Response class. This method takes an arbitray object and
-    # depending on its class attempts to convert it.
-    def self.convert(obj, parent)
-      if (obj.kind_of?(Response))
-        # Recursively convert the object.
-        obj.each_pair { |k,v|
-          if (v != obj.parent)
-            obj[k] = convert(v, obj)
-          end
-        }
-        return obj
-      elsif (obj.kind_of?(Hash))
-        # Hashes make good Responses already thanks to OpenStruct.
-        return Response.new(obj, parent)
-      elsif (obj.kind_of?(Array))
-        # With arrays, make sure each element is appropriately converted.
-        new_arr = []
-        obj.each { |elem|
-          new_arr << convert(elem, parent)
-        }
-        return new_arr
-      else
-        # At this point we're out of ideas, so let's hope it is a string.
-        return obj
-      end
-    end
-
-  end  # class Response < OpenStruct
+  end  # class Response
 
 end  # module EC2

data/lib/EC2/snapshots.rb

@@ -0,0 +1,95 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library, EBS snaphshots support
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Yann Klis  (mailto:yann.klis@novelys.com)
+# Copyright:: Copyright (c) 2008 Yann Klis
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+module EC2
+
+  class Base
+
+    #Amazon Developer Guide Docs:
+    #
+    # The DescribeSnapshots operation describes the status of Amazon EBS snapshots.
+    #
+    #Required Arguments:
+    #
+    # none
+    #
+    #Optional Arguments:
+    #
+    # :snapshot_id => Array (default : [])
+    #
+
+    def describe_snapshots( options = {} )
+
+      options = { :snapshot_id => [] }.merge(options)
+
+      params = pathlist("SnapshotId", options[:snapshot_id] )
+
+      return response_generator(:action => "DescribeSnapshots", :params => params)
+
+    end
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The CreateSnapshot operation creates a snapshot of an Amazon EBS volume and stores it in Amazon S3. You can use snapshots for backups, to launch instances from identical snapshots, and to save data before shutting down an instance.
+    #
+    #Required Arguments:
+    #
+    # :volume_id => String (default : '')
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    
+    def create_snapshot( options = {} )
+
+      # defaults
+      options = { :volume_id => '' }.merge(options)
+      
+      raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+
+      params = {
+        "VolumeId" => options[:volume_id]
+      }
+
+      return response_generator(:action => "CreateSnapshot", :params => params)
+      
+    end
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The DeleteSnapshot operation deletes a snapshot of an Amazon EBS  volume that is stored in Amazon S3.
+    #
+    #Required Arguments:
+    #
+    # :snapshot_id => String (default : '')
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    
+    def delete_snapshot( options = {} )
+
+      options = { :snapshot_id => '' }.merge(options)
+      
+      raise ArgumentError, "No :snapshot_id provided" if options[:snapshot_id].nil? || options[:snapshot_id].empty?
+
+      params = {
+        "SnapshotId" => options[:snapshot_id]
+      }
+
+      return response_generator(:action => "DeleteSnapshot", :params => params)
+      
+    end
+    
+  end
+end
+

data/lib/EC2/volumes.rb

@@ -0,0 +1,171 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library, EBS volumes support
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Yann Klis  (mailto:yann.klis@novelys.com)
+# Copyright:: Copyright (c) 2008 Yann Klis
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+module EC2
+
+  class Base
+
+    #Amazon Developer Guide Docs:
+    #
+    # The DescribeVolumes operation lists one or more Amazon EBS volumes that you own, If you do not specify any volumes, Amazon EBS returns all volumes that you own.
+    #
+    #Required Arguments:
+    #
+    # none
+    #
+    #Optional Arguments:
+    #
+    # :volume_id => Array (default : [])
+    #
+
+    def describe_volumes( options = {} )
+
+      options = { :volume_id => [] }.merge(options)
+
+      params = pathlist("VolumeId", options[:volume_id] )
+
+      return response_generator(:action => "DescribeVolumes", :params => params)
+
+    end
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The CreateVolume operation creates a new Amazon EBS volume that you can mount from any Amazon EC2 instance.
+    #
+    #Required Arguments:
+    #
+    # :availability_zone => String (default : '')
+    #
+    #Optional Arguments:
+    #
+    # :size => String (default : '')
+    # :snapshot_id => String (default : '')
+    #
+    
+    def create_volume( options = {} )
+
+      # defaults
+      options = { :availability_zone => '' }.merge(options)
+      
+      raise ArgumentError, "No :availability_zone provided" if options[:availability_zone].nil? || options[:availability_zone].empty?
+      
+      options = { :size => '' }.merge(options)
+      options = { :snapshot_id => '' }.merge(options)
+
+      params = {
+        "AvailabilityZone" => options[:availability_zone],
+        "Size" => options[:size],
+        "SnapshotId" => options[:snapshot_id]
+      }
+
+      return response_generator(:action => "CreateVolume", :params => params)
+      
+    end
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The DeleteVolume operation deletes an Amazon EBS volume.
+    #
+    #Required Arguments:
+    #
+    # :volume_id => String (default : '')
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    
+    def delete_volume( options = {} )
+
+      options = { :volume_id => '' }.merge(options)
+      
+      raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+
+      params = {
+        "VolumeId" => options[:volume_id]
+      }
+
+      return response_generator(:action => "DeleteVolume", :params => params)
+      
+    end
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The AttachVolume operation attaches an Amazon EBS volume to an instance.
+    #
+    #Required Arguments:
+    #
+    # :volume_id => String (default : '')
+    # :instance_id => String (default : '')
+    # :device => String (default : '')
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    
+    def attach_volume( options = {} )
+
+      options = { :volume_id => '' }.merge(options)
+      options = { :instance_id => '' }.merge(options)
+      options = { :device => '' }.merge(options)
+      
+      raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+      raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+      raise ArgumentError, "No :volume_id provided" if options[:device].nil? || options[:device].empty?
+      
+      params = {
+        "VolumeId" => options[:volume_id],
+        "InstanceId" => options[:instance_id],
+        "Device" => options[:device]
+      }
+
+      return response_generator(:action => "AttachVolume", :params => params)
+      
+    end
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The DetachVolume operation detaches an Amazon EBS volume from an instance.
+    #
+    #Required Arguments:
+    #
+    # :volume_id => String (default : '')
+    #
+    #Optional Arguments:
+    #
+    # :instance_id => String (default : '')
+    # :device => String (default : '')
+    # :force => Boolean (default : '')
+    #
+    
+    def detach_volume( options = {} )
+
+      options = { :volume_id => '' }.merge(options)
+      
+      raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+      
+      options = { :instance_id => '' }.merge(options)
+      options = { :device => '' }.merge(options)
+      options = { :force => '' }.merge(options)
+      
+      params = {
+        "VolumeId" => options[:volume_id],
+        "InstanceId" => options[:instance_id],
+        "Device" => options[:device],
+        "Force" => options[:force]
+      }
+
+      return response_generator(:action => "DetachVolume", :params => params)
+      
+    end
+  end
+end
+

data/lib/EC2.rb

@@ -22,7 +22,7 @@ module EC2
   DEFAULT_HOST = 'ec2.amazonaws.com'
 
   # This is the version of the API as defined by Amazon Web Services
-  API_VERSION = '2008-02-01'
+  API_VERSION = '2008-05-05'
 
   # Builds the canonical string for signing. This strips out all '&', '?', and '='
   # from the query string to be signed.

data/test/test_EC2_availability_zones.rb

@@ -35,7 +35,7 @@ context "EC2 availability zones" do
   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 EC2::Response
+    @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"] )
 

data/test/test_EC2_console.rb

@@ -37,7 +37,7 @@ context "The EC2 console " do
   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
+    @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"

data/test/test_EC2_elastic_ips.rb

@@ -57,7 +57,7 @@ context "EC2 elastic IP addresses " 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
+    @ec2.allocate_address.should.be.an.instance_of Hash
 
     response = @ec2.allocate_address
     response.publicIp.should.equal "67.202.55.255"
@@ -79,7 +79,7 @@ context "EC2 elastic IP 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
+    @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"
@@ -91,7 +91,7 @@ context "EC2 elastic IP addresses " 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
+    @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"
@@ -102,7 +102,7 @@ context "EC2 elastic IP addresses " 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
+    @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"
@@ -124,7 +124,7 @@ context "EC2 elastic IP addresses " 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
+    @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"

data/test/test_EC2_image_attributes.rb

@@ -62,7 +62,7 @@ context "EC2 image_attributes " do
                                                             "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
+    @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
 
 
@@ -72,7 +72,7 @@ context "EC2 image_attributes " do
                                                             "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
+    @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"add", :group=>["all"]).should.be.an.instance_of Hash
   end
 
 
@@ -82,7 +82,7 @@ context "EC2 image_attributes " do
                                                             "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
+    @ec2.modify_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission", :operation_type=>"remove", :group=>["all"]).should.be.an.instance_of Hash
   end
 
 
@@ -95,7 +95,7 @@ context "EC2 image_attributes " do
     @ec2.modify_image_attribute(:image_id=>"ami-61a54008",
                                 :attribute=>"launchPermission",
                                 :operation_type=>"add",
-                                :user_id=>["123"]).should.be.an.instance_of EC2::Response
+                                :user_id=>["123"]).should.be.an.instance_of Hash
   end
 
 
@@ -107,7 +107,7 @@ context "EC2 image_attributes " do
 
     @ec2.modify_image_attribute(:image_id=>"ami-61a54008",
                                 :attribute=>"productCodes",
-                                :product_code=>["774F4FF8"]).should.be.an.instance_of EC2::Response
+                                :product_code=>["774F4FF8"]).should.be.an.instance_of Hash
   end
 
 
@@ -124,7 +124,7 @@ context "EC2 image_attributes " do
                                 :attribute=>"launchPermission",
                                 :operation_type=>"add",
                                 :user_id=>["123", "345"],
-                                :group=>["123", "all"]).should.be.an.instance_of EC2::Response
+                                :group=>["123", "all"]).should.be.an.instance_of Hash
   end
 
 
@@ -166,7 +166,7 @@ context "EC2 image_attributes " do
       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
+      should.be.an.instance_of Hash
 
     response = @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission")
     response.imageId.should.equal "ami-61a54008"
@@ -181,7 +181,7 @@ context "EC2 image_attributes " do
       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
+      should.be.an.instance_of Hash
 
     response = @ec2.describe_image_attribute(:image_id=>"ami-61a54008", :attribute=>"productCodes")
     response.imageId.should.equal "ami-61a54008"
@@ -214,7 +214,7 @@ context "EC2 image_attributes " 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").should.be.an.instance_of Hash
     @ec2.reset_image_attribute(:image_id=>"ami-61a54008", :attribute=>"launchPermission").return.should.equal "true"
   end
 

data/test/test_EC2_images.rb

@@ -60,7 +60,7 @@ context "An EC2 image " 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
+    @ec2.register_image(:image_location => "mybucket-myimage.manifest.xml").should.be.an.instance_of Hash
   end
 
 
@@ -73,9 +73,9 @@ context "An EC2 image " do
   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
+    @ec2.describe_images.should.be.an.instance_of Hash
     response = @ec2.describe_images
-    response.should.be.an.instance_of EC2::Response
+    response.should.be.an.instance_of Hash
   end
 
 
@@ -182,7 +182,7 @@ context "An EC2 image " do
   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" ).should.be.an.instance_of Hash
     @ec2.deregister_image(:image_id => "ami-61a54008" ).return.should.equal "true"
   end
 

data/test/test_EC2_instances.rb

@@ -146,7 +146,7 @@ context "EC2 instances " do
     @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "AddressingType" => 'public', 'InstanceType' => 'm1.small').
       returns stub(:body => @run_instances_response_body, :is_a? => true)
 
-    @ec2.run_instances( :image_id => "ami-60a54009" ).should.be.an.instance_of EC2::Response
+    @ec2.run_instances( :image_id => "ami-60a54009" ).should.be.an.instance_of Hash
 
     response = @ec2.run_instances( :image_id => "ami-60a54009" )
 
@@ -223,27 +223,27 @@ context "EC2 instances " do
   specify "should be able specify an availability_zone" do
     @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "Placement.AvailabilityZone" => "zone123", "UserData" => "foo", "AddressingType" => 'public', 'InstanceType' => 'm1.small').
       returns stub(:body => @run_instances_response_body, :is_a? => true)
-    @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1, :max_count => 1, :availability_zone => "zone123", :group_id => [], :user_data => "foo", :base64_encoded => true ).should.be.an.instance_of EC2::Response
+    @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1, :max_count => 1, :availability_zone => "zone123", :group_id => [], :user_data => "foo", :base64_encoded => true ).should.be.an.instance_of Hash
   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', 'InstanceType' => 'm1.small').
       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
+    @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 Hash
   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', 'InstanceType' => 'm1.small').
       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
+    @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 Hash
   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
+    @ec2.describe_instances.should.be.an.instance_of Hash
     response = @ec2.describe_instances
     response.reservationSet.item[0].reservationId.should.equal "r-44a5402d"
   end
@@ -297,7 +297,7 @@ context "EC2 instances " do
   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
+    @ec2.reboot_instances( :instance_id => ["i-2ea64347", "i-21a64348"] ).class.should.equal Hash
   end
 
 
@@ -311,7 +311,7 @@ context "EC2 instances " do
   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
+    @ec2.terminate_instances( :instance_id => ["i-28a64341", "i-21a64348"] ).class.should.equal Hash
 
     @response = @ec2.terminate_instances( :instance_id => ["i-28a64341", "i-21a64348"] )
 

data/test/test_EC2_keypairs.rb

@@ -69,7 +69,7 @@ context "EC2 keypairs " do
     @ec2.stubs(:make_request).with('CreateKeyPair', {"KeyName"=>"example-key-name"}).
       returns stub(:body => @create_keypair_response_body, :is_a? => true)
 
-    @ec2.create_keypair( :key_name => "example-key-name" ).should.be.an.instance_of EC2::Response
+    @ec2.create_keypair( :key_name => "example-key-name" ).should.be.an.instance_of Hash
 
     response = @ec2.create_keypair( :key_name => "example-key-name" )
     response.keyName.should.equal "example-key-name"
@@ -93,7 +93,7 @@ context "EC2 keypairs " do
   specify "should be able to be described with describe_keypairs" do
     @ec2.stubs(:make_request).with('DescribeKeyPairs', {"KeyName.1"=>"example-key-name"}).
       returns stub(:body => @describe_keypairs_response_body, :is_a? => true)
-    @ec2.describe_keypairs( :key_name => "example-key-name" ).should.be.an.instance_of EC2::Response
+    @ec2.describe_keypairs( :key_name => "example-key-name" ).should.be.an.instance_of Hash
     response = @ec2.describe_keypairs( :key_name => "example-key-name" )
     response.keySet.item[0].keyName.should.equal "example-key-name"
     response.keySet.item[0].keyFingerprint.should.equal "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f"
@@ -103,7 +103,7 @@ context "EC2 keypairs " do
   specify "should be able to be deleted with delete_keypairs" do
     @ec2.stubs(:make_request).with('DeleteKeyPair', {"KeyName"=>"example-key-name"}).
       returns stub(:body => @delete_keypair_body, :is_a? => true)
-    @ec2.delete_keypair( :key_name => "example-key-name" ).should.be.an.instance_of EC2::Response
+    @ec2.delete_keypair( :key_name => "example-key-name" ).should.be.an.instance_of Hash
     response = @ec2.delete_keypair( :key_name => "example-key-name" )
     response.return.should.equal "true"
   end

data/test/test_EC2_products.rb

@@ -29,7 +29,7 @@ context "An EC2 instance " do
     @ec2.stubs(:make_request).with('ConfirmProductInstance', {"ProductCode"=>"774F4FF8", "InstanceId"=>"i-10a64379"}).
        returns stub(:body => @confirm_product_instance_response_body, :is_a? => true)
 
-    @ec2.confirm_product_instance( :product_code => "774F4FF8", :instance_id => "i-10a64379" ).should.be.an.instance_of EC2::Response
+    @ec2.confirm_product_instance( :product_code => "774F4FF8", :instance_id => "i-10a64379" ).should.be.an.instance_of Hash
     response = @ec2.confirm_product_instance( :product_code => "774F4FF8", :instance_id => "i-10a64379" )
     response.ownerId.should.equal "254933287430"
     response.result.should.equal "true"

data/test/test_EC2_responses.rb

@@ -21,82 +21,32 @@ context "The Response classes " do
     RESPONSE
 
     @response = EC2::Response.parse(:xml => @http_xml)
-
-    # test out adding arbitrary new values to the OpenStruct
-    @response.name = "foo"
-    @response.number = '123'
-  end
-
-
-  specify "should properly run the to_string(short) method for the short version" do
-    # sample response looks like: "#<EC2::Response:0x100A45F2E ...>".  Our response should look
-    # exactly the same, except it should have different hex digits in the middle (after 0x)
-    # that are nine chars long.
-    @response.to_string(true).should =~ /^#<EC2::Response:0x[0-9A-F]{1,9} ...>/
   end
 
 
-  specify "should properly run the to_string(false) method for the long version" do
-    @response.to_string(false).should =~ /^#<EC2::Response:0x[0-9A-F]{1,9} name=\"foo\" number=\"123\" parent=nil return=\"true\"/
+  specify "should show the response as a formatted string when calling #inspect" do
+    @response.inspect.should.equal %{{"return"=>"true", "xmlns"=>"http://ec2.amazonaws.com/doc/2007-03-01"}}
   end
 
 
-  specify "should properly run the to_string(false) method for the long version when called with no params" do
-    @response.to_string.should =~ /^#<EC2::Response:0x[0-9A-F]{1,9} name=\"foo\" number=\"123\" parent=nil return=\"true\"/
-  end
-
-
-  specify "should provide the same results from to_s as from to_string(false) " do
-    @response.to_s.should =~ /^#<EC2::Response:0x[0-9A-F]{1,9} name=\"foo\" number=\"123\" parent=nil return=\"true\"/
-  end
-
-
-  specify "should be a kind of type OpenStruct" do
-    @response.kind_of?(OpenStruct).should.equal true
-    @response.kind_of?(Enumerable).should.equal true
+  specify "should be a Hash" do
+    @response.kind_of?(Hash).should.equal true
   end
 
 
   specify "should return its members" do
-    @response.members.length.should.equal 6
-    test_array = ["return", "xmlns", "number", "name", "parent", "xml"].sort
-    @response.members.sort.should.equal test_array
-  end
-
-
-  specify "should properly respond to its 'each' method" do
-    answer = @response.each do |f| f ; end
-    answer.name.should.equal "foo"
-    answer.number.should.equal '123'
-  end
-
-
-  specify "should respond to the '[]' method" do
-    @response[:name].should.equal "foo"
+    @response.keys.length.should.equal 2
+    test_array = ["return", "xmlns"].sort
+    @response.keys.sort.should.equal test_array
   end
 
 
-  specify "should respond correctly to the '[]=' method and set a variable" do
-    @response[:name].should.equal "foo"
-    @response[:name]="bar"
-    @response[:name].should.equal "bar"
-  end
-
-
-  specify "should respond correctly to the 'each_pair' method" do
-    @response.each_pair {|k,v|
-      case k
-      when "name"
-        v.should.equal "foo"
-      when "number"
-        v.should.equal '123'
-      end
-    }
-  end
-
-  specify "should return the original amazon XML response in the 'xml' attribute of the response object." do
-    @response.xml.should.equal @http_xml
-  end
+  # Note: since we are now returning a hash of the xml, there should be no need for anyone to re-parse the xml.
+  # Therefore storing the xml on the object is a waste of memory, and is not done.
+  #
+  # specify "should return the original amazon XML response in the 'xml' attribute of the response object." do
+  #  @response.xml.should.equal @http_xml
+  # end
 
 
 end

data/test/test_EC2_security_groups.rb

@@ -84,7 +84,7 @@ context "EC2 security groups " do
   specify "should be able to be created" do
     @ec2.stubs(:make_request).with('CreateSecurityGroup', {"GroupName"=>"WebServers", "GroupDescription"=>"Web"}).
       returns stub(:body => @create_security_group_response_body, :is_a? => true)
-    @ec2.create_security_group( :group_name => "WebServers", :group_description => "Web" ).should.be.an.instance_of EC2::Response
+    @ec2.create_security_group( :group_name => "WebServers", :group_description => "Web" ).should.be.an.instance_of Hash
   end
 
 
@@ -108,7 +108,7 @@ context "EC2 security groups " do
   specify "should be able to be deleted" do
     @ec2.stubs(:make_request).with('DeleteSecurityGroup', {"GroupName"=>"WebServers"}).
       returns stub(:body => @delete_security_group_response_body, :is_a? => true)
-    @ec2.delete_security_group( :group_name => "WebServers" ).should.be.an.instance_of EC2::Response
+    @ec2.delete_security_group( :group_name => "WebServers" ).should.be.an.instance_of Hash
   end
 
 
@@ -128,7 +128,7 @@ context "EC2 security groups " do
   specify "should be able to be described with describe_security_groups" do
     @ec2.stubs(:make_request).with('DescribeSecurityGroups', { "GroupName.1" => "WebServers", "GroupName.2" => "RangedPortsBySource" }).
       returns stub(:body => @describe_security_groups_response_body, :is_a? => true)
-    @ec2.describe_security_groups( :group_name => ["WebServers", "RangedPortsBySource"] ).should.be.an.instance_of EC2::Response
+    @ec2.describe_security_groups( :group_name => ["WebServers", "RangedPortsBySource"] ).should.be.an.instance_of Hash
 
     response = @ec2.describe_security_groups( :group_name => ["WebServers", "RangedPortsBySource"] )
 
@@ -178,7 +178,7 @@ context "EC2 security groups " do
                                            :cidr_ip => "0.0.0.0/24",
                                            :source_security_group_name => "Source SG Name",
                                            :source_security_group_owner_id => "123"
-                                           ).should.be.an.instance_of EC2::Response
+                                           ).should.be.an.instance_of Hash
   end
 
 
@@ -199,7 +199,7 @@ context "EC2 security groups " do
                                         :cidr_ip => "0.0.0.0/24",
                                         :source_security_group_name => "Source SG Name",
                                         :source_security_group_owner_id => "123"
-                                        ).should.be.an.instance_of EC2::Response
+                                        ).should.be.an.instance_of Hash
   end
 
 end

data/test/test_EC2_snapshots.rb

@@ -0,0 +1,83 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library, EBS snapshots support
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Yann Klis  (mailto:yann.klis@novelys.com)
+# Copyright:: Copyright (c) 2008 Yann Klis
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "EC2 snaphots " do
+
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @describe_snapshots_response_body = <<-RESPONSE
+    <DescribeSnapshotsResponse xmlns="http://ec2.amazonaws.com/doc/2008-05-05">
+      <snapshotId>snap-78a54011</snapshotId>
+      <volumeId>vol-4d826724</volumeId>
+      <status>pending</status>
+      <startTime>2008-05-07T12:51:50.000Z</startTime>
+      <progress>80%</progress>
+    </DescribeSnapshotsResponse>
+    RESPONSE
+
+    @create_snapshot_response_body = <<-RESPONSE
+    <CreateSnapshotResponse xmlns="http://ec2.amazonaws.com/doc/2008-05-05">
+      <snapshotId>snap-78a54011</snapshotId>
+      <volumeId>vol-4d826724</volumeId>
+      <status>pending</status>
+      <startTime>2008-05-07T12:51:50.000Z</startTime>
+      <progress></progress>
+    </CreateSnapshotResponse>
+    RESPONSE
+
+    @delete_snapshot_response_body = <<-RESPONSE
+    <DeleteSnapshotResponse xmlns="http://ec2.amazonaws.com/doc/2008-05-05">
+      <return>true</return>
+    </DeleteSnapshotResponse>
+    RESPONSE
+
+  end
+
+
+  specify "should be able to be described with describe_snapshots" do
+    @ec2.stubs(:make_request).with('DescribeSnapshots', {"SnapshotId.1"=>"snap-78a54011"}).
+      returns stub(:body => @describe_snapshots_response_body, :is_a? => true)
+
+    @ec2.describe_snapshots( :snapshot_id => "snap-78a54011" ).should.be.an.instance_of Hash
+
+    response = @ec2.describe_snapshots( :snapshot_id => "snap-78a54011" )
+    response.snapshotId.should.equal "snap-78a54011"
+    response.volumeId.should.equal "vol-4d826724"
+    response.status.should.equal "pending"
+    response.progress.should.equal "80%"
+  end
+
+  specify "should be able to be created with a volume_id" do
+    @ec2.stubs(:make_request).with('CreateSnapshot', {"VolumeId" => "vol-4d826724"}).
+      returns stub(:body => @create_snapshot_response_body, :is_a? => true)
+
+    @ec2.create_snapshot( :volume_id => "vol-4d826724" ).should.be.an.instance_of Hash
+
+    response = @ec2.create_snapshot( :volume_id => "vol-4d826724" )
+    response.snapshotId.should.equal "snap-78a54011"
+    response.volumeId.should.equal "vol-4d826724"
+    response.status.should.equal "pending"
+    response.progress.should.equal nil
+  end
+
+  specify "should be able to be deleted with a snapsot_id" do
+    @ec2.stubs(:make_request).with('DeleteSnapshot', {"SnapshotId" => "snap-78a54011"}).
+      returns stub(:body => @delete_snapshot_response_body, :is_a? => true)
+
+    @ec2.delete_snapshot( :snapshot_id => "snap-78a54011" ).should.be.an.instance_of Hash
+
+    response = @ec2.delete_snapshot( :snapshot_id => "snap-78a54011" )
+    response.return.should.equal "true"
+  end
+
+end

data/test/test_EC2_volumes.rb

@@ -0,0 +1,144 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library, EBS volumes support
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Yann Klis  (mailto:yann.klis@novelys.com)
+# Copyright:: Copyright (c) 2008 Yann Klis
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "EC2 volumes " do
+
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @describe_volumes_response_body = <<-RESPONSE
+    <DescribeVolumesResponse xmlns="http://ec2.amazonaws.com/doc/2008-05-05">
+      <volumeSet>
+        <item>
+          <volumeId>vol-4282672b</volumeId>
+          <size>800</size>
+          <status>in-use</status>
+          <createTime>2008-05-07T11:51:50.000Z</createTime>
+          <attachmentSet>
+            <item>
+              <volumeId>vol-4282672b</volumeId>
+              <instanceId>i-6058a509</instanceId>
+              <size>800</size>
+              <status>attached</status>
+              <attachTime>2008-05-07T12:51:50.000Z</attachTime>
+            </item>
+          </attachmentSet>
+        </item>
+      </volumeSet>
+    </DescribeVolumesResponse>
+    RESPONSE
+
+    @create_volume_response_body = <<-RESPONSE
+    <CreateVolumeResponse xmlns="http://ec2.amazonaws.com/doc/2008-05-05">
+      <volumeId>vol-4d826724</volumeId>
+      <size>800</size>
+      <status>creating</status>
+      <createTime>2008-05-07T11:51:50.000Z</createTime>
+      <zone>us-east-1a</zone>
+      <snapshotId></snapshotId>
+    </CreateVolumeResponse>
+    RESPONSE
+
+    @delete_volume_response_body = <<-RESPONSE
+    <ReleaseAddressResponse xmlns="http://ec2.amazonaws.com/doc/2008-05-05">
+      <return>true</return>
+    </ReleaseAddressResponse>
+    RESPONSE
+
+    @attach_volume_response_body = <<-RESPONSE
+    <AttachVolumeResponse xmlns="http://ec2.amazonaws.com/doc/2008-05-05">
+      <volumeId>vol-4d826724</volumeId>
+      <instanceId>i-6058a509</instanceId>
+      <device>/dev/sdh</device>
+      <status>attaching</status>
+      <attachTime>2008-05-07T11:51:50.000Z</attachTime>
+    </AttachVolumeResponse>
+    RESPONSE
+
+    @detach_volume_response_body = <<-RESPONSE
+    <DetachVolumeResponse xmlns="http://ec2.amazonaws.com/doc/2008-05-05">
+      <volumeId>vol-4d826724</volumeId>
+      <instanceId>i-6058a509</instanceId>
+      <device>/dev/sdh</device>
+      <status>detaching</status>
+      <attachTime>2008-05-08T11:51:50.000Z</attachTime>
+    </DetachVolumeResponse>
+    RESPONSE
+
+  end
+
+
+  specify "should be able to be described with describe_volumes" do
+    @ec2.stubs(:make_request).with('DescribeVolumes', {"VolumeId.1"=>"vol-4282672b"}).
+      returns stub(:body => @describe_volumes_response_body, :is_a? => true)
+
+    @ec2.describe_volumes( :volume_id => ["vol-4282672b"] ).should.be.an.instance_of Hash
+
+    response = @ec2.describe_volumes( :volume_id => ["vol-4282672b"] )
+    response.volumeSet.item[0].volumeId.should.equal "vol-4282672b"
+# FIXME
+#    response.volumeSet.item[0].size.should.equal "800"
+    response.volumeSet.item[0].attachmentSet.item[0].volumeId.should.equal "vol-4282672b"
+    response.volumeSet.item[0].attachmentSet.item[0].instanceId.should.equal "i-6058a509"
+  end
+
+  specify "should be able to be created with an availability_zone with size" do
+    @ec2.stubs(:make_request).with('CreateVolume', {"AvailabilityZone" => "us-east-1a", "Size"=>"800", "SnapshotId"=>""}).
+      returns stub(:body => @create_volume_response_body, :is_a? => true)
+
+    @ec2.create_volume( :availability_zone => "us-east-1a", :size => "800" ).should.be.an.instance_of Hash
+
+    response = @ec2.create_volume( :availability_zone => "us-east-1a", :size => "800" )
+    response.volumeId.should.equal "vol-4d826724"
+# FIXME
+#    response.size.should.equal "800"
+    response.status.should.equal "creating"
+    response.zone.should.equal "us-east-1a"
+  end
+
+  specify "should be able to be deleted with a volume_id" do
+    @ec2.stubs(:make_request).with('DeleteVolume', {"VolumeId" => "vol-4282672b"}).
+      returns stub(:body => @delete_volume_response_body, :is_a? => true)
+
+    @ec2.delete_volume( :volume_id => "vol-4282672b" ).should.be.an.instance_of Hash
+
+    response = @ec2.delete_volume( :volume_id => "vol-4282672b" )
+    response.return.should.equal "true"
+  end
+
+  specify "should be able to be attached with a volume_id with an instance_id with a device" do
+    @ec2.stubs(:make_request).with('AttachVolume', {"VolumeId" => "vol-4d826724", "InstanceId"=>"i-6058a509", "Device"=>"/dev/sdh"}).
+      returns stub(:body => @attach_volume_response_body, :is_a? => true)
+
+    @ec2.attach_volume( :volume_id => "vol-4d826724", :instance_id => "i-6058a509", :device => "/dev/sdh" ).should.be.an.instance_of Hash
+
+    response = @ec2.attach_volume( :volume_id => "vol-4d826724", :instance_id => "i-6058a509", :device => "/dev/sdh" )
+    response.volumeId.should.equal "vol-4d826724"
+    response.instanceId.should.equal "i-6058a509"
+    response.device.should.equal "/dev/sdh"
+    response.status.should.equal "attaching"
+  end
+
+  specify "should be able to be detached with a volume_id with an instance_id" do
+    @ec2.stubs(:make_request).with('DetachVolume', {"VolumeId" => "vol-4d826724", "InstanceId"=>"i-6058a509", "Device"=>"", "Force"=>""}).
+      returns stub(:body => @detach_volume_response_body, :is_a? => true)
+
+    @ec2.detach_volume( :volume_id => "vol-4d826724", :instance_id => "i-6058a509" ).should.be.an.instance_of Hash
+
+    response = @ec2.detach_volume( :volume_id => "vol-4d826724", :instance_id => "i-6058a509" )
+    response.volumeId.should.equal "vol-4d826724"
+    response.instanceId.should.equal "i-6058a509"
+    response.device.should.equal "/dev/sdh"
+    response.status.should.equal "detaching"
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: grempe-amazon-ec2
 version: !ruby/object:Gem::Version 
-  version: 0.2.15
+  version: 0.3.0
 platform: ruby
 authors: 
 - Glenn Rempe
@@ -21,33 +21,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.0.11
     version: 
-- !ruby/object:Gem::Dependency 
-  name: mocha
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.9.0
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: test-spec
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.9.0
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: rcov
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.8.1.2.0
-    version: 
 description: An interface library that allows Ruby applications to easily connect to the HTTP 'Query API' for the Amazon Web Services Elastic Compute Cloud (EC2) and manipulate cloud servers.
 email: glenn.rempe@gmail.com
 executables: 
@@ -77,6 +50,8 @@ files:
 - lib/EC2/products.rb
 - lib/EC2/responses.rb
 - lib/EC2/security_groups.rb
+- lib/EC2/snapshots.rb
+- lib/EC2/volumes.rb
 - lib/EC2.rb
 - test/test_EC2.rb
 - test/test_EC2_availability_zones.rb
@@ -89,6 +64,8 @@ files:
 - test/test_EC2_products.rb
 - test/test_EC2_responses.rb
 - test/test_EC2_security_groups.rb
+- test/test_EC2_snapshots.rb
+- test/test_EC2_volumes.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/grempe/amazon-ec2/
@@ -126,6 +103,7 @@ specification_version: 2
 summary: An interface library that allows Ruby applications to easily connect to the HTTP 'Query API' for the Amazon Web Services Elastic Compute Cloud (EC2) and manipulate cloud servers.
 test_files: 
 - test/test_EC2.rb
+- test/test_EC2_availability_zones.rb
 - test/test_EC2_console.rb
 - test/test_EC2_elastic_ips.rb
 - test/test_EC2_image_attributes.rb
@@ -135,4 +113,6 @@ test_files:
 - test/test_EC2_products.rb
 - test/test_EC2_responses.rb
 - test/test_EC2_security_groups.rb
+- test/test_EC2_snapshots.rb
+- test/test_EC2_volumes.rb
 - test/test_helper.rb