fog 0.1.2 → 0.1.3

data/Gemfile.lock

@@ -62,13 +62,13 @@ specs:
 - net-ssh: 
     version: 2.0.22
 - nokogiri: 
-    version: 1.4.1
+    version: 1.4.2
 - rspec: 
     version: 1.3.0
 - ruby-hmac: 
     version: 0.4.0
 - shindo: 
-    version: 0.1.2
+    version: 0.1.3
 hash: 4e55927c1be02ee00fc3353e71caecdebd9d4817
 sources: 
 - Rubygems: 

data/fog.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'fog'
-  s.version           = '0.1.2'
-  s.date              = '2010-05-24'
+  s.version           = '0.1.3'
+  s.date              = '2010-05-26'
   s.rubyforge_project = 'fog'
 
   ## Make sure your summary is short. The description may be as long

data/lib/fog.rb

@@ -25,6 +25,10 @@ require 'fog/model'
 require 'fog/parser'
 require 'fog/ssh'
 
+module Fog
+  class Error < StandardError; end
+end
+
 require 'fog/aws'
 require 'fog/local'
 require 'fog/rackspace'
@@ -34,8 +38,10 @@ require 'fog/vcloud'
 
 module Fog
 
+  class MockNotImplemented < Fog::Error; end
+
   unless const_defined?(:VERSION)
-    VERSION = '0.1.2'
+    VERSION = '0.1.3'
   end
 
   module Mock
@@ -50,8 +56,6 @@ module Fog
     end
   end
 
-  class MockNotImplemented < StandardError; end
-
   def self.mock!
     @mocking = true
   end

data/lib/fog/aws/ec2.rb

@@ -2,6 +2,8 @@ module Fog
   module AWS
     module EC2
 
+      class Error < Fog::Error; end
+
       def self.new(options={})
 
         unless @required
@@ -96,40 +98,42 @@ module Fog
 
         def self.data
           @data ||= Hash.new do |hash, key|
+            owner_id = Fog::AWS::Mock.owner_id
             hash[key] = {
               :deleted_at => {},
-              :addresses => {},
-              :instances => {},
-              :key_pairs => {},
-              :limits => { :addresses => 5 },
+              :addresses  => {},
+              :instances  => {},
+              :key_pairs  => {},
+              :limits     => { :addresses => 5 },
+              :owner_id   => owner_id,
               :security_groups => {
                 'default' => {
                   'groupDescription'  => 'default group',
                   'groupName'         => 'default',
                   'ipPermissions'     => [
                     {
-                      'groups'      => [{'groupName' => 'default', 'userId' => @owner_id}],
+                      'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
                       'fromPort'    => -1,
                       'toPort'      => -1,
                       'ipProtocol'  => 'icmp',
                       'ipRanges'    => []
                     },
                     {
-                      'groups'      => [{'groupName' => 'default', 'userId' => @owner_id}],
+                      'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
                       'fromPort'    => 0,
                       'toPort'      => 65535,
                       'ipProtocol'  => 'tcp',
                       'ipRanges'    => []
                     },
                     {
-                      'groups'      => [{'groupName' => 'default', 'userId' => @owner_id}],
+                      'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
                       'fromPort'    => 0,
                       'toPort'      => 65535,
                       'ipProtocol'  => 'udp',
                       'ipRanges'    => []
                     }
                   ],
-                  'ownerId'           => @owner_id
+                  'ownerId'           => owner_id
                 }
               },
               :snapshots => {},
@@ -146,8 +150,8 @@ module Fog
 
         def initialize(options={})
           @aws_access_key_id = options[:aws_access_key_id]
-          @owner_id = Fog::AWS::Mock.owner_id
           @data = self.class.data[@aws_access_key_id]
+          @owner_id = @data[:owner_id]
         end
 
       end
@@ -210,15 +214,23 @@ module Fog
             }
           )
 
-          response = @connection.request({
-            :body       => body,
-            :expects    => 200,
-            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
-            :idempotent => idempotent,
-            :host       => @host,
-            :method     => 'POST',
-            :parser     => parser
-          })
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :idempotent => idempotent,
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+          rescue Excon::Errors::Error => error
+            if match = error.message.match(/<Code>(.*)<\/Code><Message>(.*)<\/Message>/)
+              raise Fog::AWS::EC2::Error.new("#{match[1]} => #{match[2]}")
+            else
+              raise error
+            end
+          end
 
           response
         end

data/lib/fog/aws/models/ec2/flavors.rb

@@ -30,8 +30,9 @@ module Fog
             { :bits => 32, :cores =>  5, :disk => 350,  :id => 'c1.medium', :name => 'High-CPU Medium',      :ram => 1740.8},
             { :bits => 64, :cores => 20, :disk => 1690, :id => 'c1.xlarge', :name => 'High-CPU Extra Large', :ram => 7168},
 
-            { :bits => 64, :cores => 13, :disk => 850,  :id => 'm2.2xlarge', :name => 'High Memory Double Extra Large',    :ram => 35020.8},
-            { :bits => 64, :cores => 26, :disk => 1690, :id => 'm2.4xlarge', :name => 'High Memory Quadruple Extra Large', :ram => 70041.6},
+            { :bits => 64, :cores => 6.5, :disk => 420,  :id => 'm2.xlarge',  :name => 'High-Memory Extra Large',           :ram => 17510.4},
+            { :bits => 64, :cores =>  13, :disk => 850,  :id => 'm2.2xlarge', :name => 'High Memory Double Extra Large',    :ram => 35020.8},
+            { :bits => 64, :cores =>  26, :disk => 1690, :id => 'm2.4xlarge', :name => 'High Memory Quadruple Extra Large', :ram => 70041.6},
           ]
           load(data)
           self

data/lib/fog/aws/models/ec2/server.rb

@@ -117,7 +117,7 @@ module Fog
 
           options = {
             'BlockDeviceMapping'          => @block_device_mapping,
-            'InstanceType'                => flavor.id,
+            'InstanceType'                => flavor_id,
             'KernelId'                    => @kernel_id,
             'KeyName'                     => @key_name,
             'Monitoring.Enabled'          => @monitoring,

data/lib/fog/aws/requests/ec2/associate_address.rb

@@ -43,11 +43,12 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
-          else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            response
+          elsif !instance
+            raise Fog::AWS::EC2::Error.new("InvalidInstanceID.NotFound => The instance ID '#{instance_id}' does not exist")
+          elsif !address
+            raise Fog::AWS::EC2::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/attach_volume.rb

@@ -54,24 +54,23 @@ module Fog
               response.body = {
                 'requestId' => Fog::AWS::Mock.request_id
               }.merge!(data)
-            else
-              response.status = 400
-              raise(Excon::Errors.status_error({:expects => 200}, response))
+              response
+            elsif !instance
+              raise Fog::AWS::EC2::Error.new("InvalidInstanceID.NotFound => The instance ID '#{instance_id}' does not exist.")
+            elsif !volume
+              raise Fog::AWS::EC2::Error.new("InvalidVolume.NotFound => The volume '#{volume_id}' does not exist.")
             end
           else
-            response.status = 400
-            response.body = {
-              'Code' => 'MissingParameter'
-            }
+            message = 'MissingParameter => '
             if !instance_id
-              response['Message'] = 'The request must contain the parameter instance_id'
+              message << 'The request must contain the parameter instance_id'
             elsif !volume_id
-              response['Message'] = 'The request must contain the parameter volume_id'
+              message << 'The request must contain the parameter volume_id'
             else
-              response['Message'] = 'The request must contain the parameter device'
+              message << 'The request must contain the parameter device'
             end
+            raise Fog::AWS::EC2::Error.new(message)
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/authorize_security_group_ingress.rb

@@ -37,33 +37,47 @@ module Fog
         def authorize_security_group_ingress(options = {})
           response = Excon::Response.new
           group = @data[:security_groups][options['GroupName']]
-          group['ipPermissions'] ||= []
 
-          if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
-            ['icmp', 'tcp', 'udp'].each do |protocol|
+          if group
+            group['ipPermissions'] ||= []
+            if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
+              ['tcp', 'udp'].each do |protocol|
+                group['ipPermissions'] << {
+                  'groups'      => [{'groupName' => options['GroupName'], 'userId' => @owner_id}],
+                  'fromPort'    => 1,
+                  'ipRanges'    => [],
+                  'ipProtocol'  => protocol,
+                  'toPort'      => 65535
+                }
+              end
               group['ipPermissions'] << {
                 'groups'      => [{'groupName' => options['GroupName'], 'userId' => @owner_id}],
-                'fromPort'    => 1,
+                'fromPort'    => -1,
                 'ipRanges'    => [],
-                'ipProtocol'  => protocol,
-                'toPort'      => 65535
+                'ipProtocol'  => 'icmp',
+                'toPort'      => -1
               }
+            else
+              group['ipPermissions'] << {
+                'groups'      => [],
+                'fromPort'    => options['FromPort'],
+                'ipRanges'    => [],
+                'ipProtocol'  => options['IpProtocol'],
+                'toPort'      => options['ToPort']
+              }
+              if options['CidrIp']
+                group['ipPermissions'].last['ipRanges'] << { 'cidrIp' => options['CidrIp'] }
+              end
             end
-          else
-            group['ipPermissions'] << {
-              'groups'      => [],
-              'fromPort'    => options['FromPort'],
-              'ipRanges'    => [{ 'cidrIp' => options['CidrIp'] }],
-              'ipProtocol'  => options['IpProtocol'],
-              'toPort'      => options['ToPort']
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
             }
+            response
+          else
+            raise Fog::AWS::EC2::Error.new("InvalidGroup.NotFound => The security group '#{options['GroupName']}' does not exist")
           end
-          response.status = 200
-          response.body = {
-            'requestId' => Fog::AWS::Mock.request_id,
-            'return'    => true
-          }
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/create_key_pair.rb

@@ -40,11 +40,10 @@ module Fog
             response.body = {
               'requestId' => Fog::AWS::Mock.request_id
             }.merge!(data)
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/create_security_group.rb

@@ -31,8 +31,8 @@ module Fog
           response = Excon::Response.new
           unless @data[:security_groups][name]
             data = {
-              'groupDescription'  => description,
-              'groupName'         => name,
+              'groupDescription'  => CGI.escape(description).gsub('%20', '+'),
+              'groupName'         => CGI.escape(name).gsub('%20', '+'),
               'ipPermissions'     => [],
               'ownerId'           => @owner_id
             }
@@ -41,11 +41,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidGroup.Duplicate => The security group '#{name}' already exists")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/delete_security_group.rb

@@ -34,11 +34,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidGroup.NotFound => The security group '#{name}' does not exist")
           end
-          response
         end
       end
     end

data/lib/fog/aws/requests/ec2/delete_snapshot.rb

@@ -34,11 +34,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidSnapshot.NotFound => The snapshot '#{snapshot_id}' does not exist.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/delete_volume.rb

@@ -36,11 +36,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidVolume.NotFound => The volume '#{volume_id}' does not exist.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/describe_addresses.rb

@@ -42,11 +42,10 @@ module Fog
               'requestId'     => Fog::AWS::Mock.request_id,
               'addressesSet'  => addresses_set
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidAddress.NotFound => Address #{public_ip.inspect} not found.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/describe_availability_zones.rb

@@ -44,12 +44,16 @@ module Fog
             availability_zone_info = zones.values
           end
 
-          response.status = 200
-          response.body = {
-            'requestId'             => Fog::AWS::Mock.request_id,
-            'availabilityZoneInfo'  => availability_zone_info
-          }
-          response
+          if zone_name.length == 0 || zone_name.length == availability_zone_info.length
+            response.status = 200
+            response.body = {
+              'requestId'             => Fog::AWS::Mock.request_id,
+              'availabilityZoneInfo'  => availability_zone_info
+            }
+            response
+          else
+            raise Fog::AWS::EC2::Error.new("InvalidParameterValue => Invalid availability zone: #{zone_name.inspect}")
+          end
         end
 
       end

data/lib/fog/aws/requests/ec2/describe_instances.rb

@@ -115,11 +115,10 @@ module Fog
               'requestId'       => Fog::AWS::Mock.request_id,
               'reservationSet' => reservation_set.values
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidInstanceID.NotFound => The instance ID #{instance_id.inspect} does not exist")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/describe_key_pairs.rb

@@ -44,11 +44,10 @@ module Fog
                 key.reject {|key,value| !['keyFingerprint', 'keyName'].include?(key)}
               end
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidKeyPair.NotFound => The key pair #{key_name.inspect} does not exist")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/describe_regions.rb

@@ -41,12 +41,16 @@ module Fog
             region_info = regions.values
           end
 
-          response.status = 200
-          response.body = {
-            'requestId'   => Fog::AWS::Mock.request_id,
-            'regionInfo'  => region_info
-          }
-          response
+          if region_name.length == 0 || region_name.length == region_info.length
+            response.status = 200
+            response.body = {
+              'requestId'   => Fog::AWS::Mock.request_id,
+              'regionInfo'  => region_info
+            }
+            response
+          else
+            raise Fog::AWS::EC2::Error.new("InvalidParameterValue => Invalid region: #{region_name.inspect}")
+          end
         end
 
       end

data/lib/fog/aws/requests/ec2/describe_security_groups.rb

@@ -52,11 +52,10 @@ module Fog
               'requestId'         => Fog::AWS::Mock.request_id,
               'securityGroupInfo' => security_group_info
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidGroup.NotFound => The security group #{group_name.inspect} does not exist")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/describe_snapshots.rb

@@ -66,11 +66,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'snapshotSet' => snapshot_set
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidSnapshot.NotFound => The snapshot #{snapshot_id.inspect} does not exist.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/describe_volumes.rb

@@ -72,11 +72,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'volumeSet' => volume_set
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidVolume.NotFound => The volume #{volume_id.inspect} does not exist.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/detach_volume.rb

@@ -44,11 +44,10 @@ module Fog
             response.body = {
               'requestId' => Fog::AWS::Mock.request_id
             }.merge!(data)
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidVolume.NotFound => The volume '#{volume_id}' does not exist.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/disassociate_address.rb

@@ -40,11 +40,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/get_console_output.rb

@@ -38,11 +38,10 @@ module Fog
               'requestId'     => Fog::AWS::Mock.request_id,
               'timestamp'     => Time.now
             }
-          else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            response
+          else;
+            raise Fog::AWS::EC2::Error.new("InvalidInstanceID.NotFound => The instance ID '#{instance_id}' does not exist")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/reboot_instances.rb

@@ -38,11 +38,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidInstanceID.NotFound => The instance ID #{instance_id.inspect} does not exist")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/release_address.rb

@@ -31,11 +31,10 @@ module Fog
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/ec2/revoke_security_group_ingress.rb

@@ -35,27 +35,36 @@ module Fog
       class Mock
 
         def revoke_security_group_ingress(options = {})
-          if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
-            raise MockNotImplemented.new("Contributions welcome!")
-          else
-            response = Excon::Response.new
-            group = @data[:security_groups][options['GroupName']]
-
-            ingress = group['ipPermissions'].select {|permission|
-              permission['fromPort']    == options['FromPort'] &&
-              permission['ipProtocol']  == options['IpProtocol'] &&
-              permission['toPort']      == options['ToPort'] &&
-              permission['ipRanges'].first['cidrIp'] == options['CidrIp']
-            }.first
-
-            group['ipPermissions'].delete(ingress)
-
+          response = Excon::Response.new
+          group = @data[:security_groups][options['GroupName']]
+          if group
+            if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
+              group['ipPermissions'].delete_if {|permission|
+                permission['groups'].first['groupName'] == options['GroupName']
+              }
+            else
+              ingress = group['ipPermissions'].select {|permission|
+                permission['fromPort']    == options['FromPort'] &&
+                permission['ipProtocol']  == options['IpProtocol'] &&
+                permission['toPort']      == options['ToPort'] &&
+                (
+                  permission['ipRanges'].empty? ||
+                  (
+                    permission['ipRanges'].first &&
+                    permission['ipRanges'].first['cidrIp'] == options['CidrIp']
+                  )
+                )
+              }.first
+              group['ipPermissions'].delete(ingress)
+            end
             response.status = 200
             response.body = {
               'requestId' => Fog::AWS::Mock.request_id,
               'return'    => true
             }
             response
+          else
+            raise Fog::AWS::EC2::Error.new("InvalidGroup.NotFound => The security group '#{options['GroupName']}' does not exist")
           end
         end
 

data/lib/fog/aws/requests/ec2/terminate_instances.rb

@@ -77,11 +77,11 @@ module Fog
                 detach_volume(volume['volumeId'])
               end
             end
+
+            response
           else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 200}, response))
+            raise Fog::AWS::EC2::Error.new("InvalidInstanceID.NotFound => The instance ID '#{instance_id}' does not exist")
           end
-          response
         end
 
       end

data/lib/fog/aws/requests/s3/put_object.rb

@@ -43,6 +43,9 @@ module Fog
 
         def put_object(bucket_name, object_name, data, options = {})
           data = Fog::AWS::S3.parse_data(data)
+          unless data[:body].is_a?(String)
+            data[:body] = data[:body].read
+          end
           response = Excon::Response.new
           if (bucket = @data[:buckets][bucket_name])
             response.status = 200

data/spec/aws/requests/ec2/describe_instances_spec.rb

@@ -94,10 +94,10 @@ describe 'EC2.describe_instances' do
   end
   describe 'failure' do
 
-    it 'should raise a BadRequest error if the instance does not exist' do
+    it 'should raise a Fog::AWS::EC2::Error if the instance does not exist' do
       lambda {
         AWS[:ec2].describe_instances('i-00000000')
-      }.should raise_error(Excon::Errors::BadRequest)
+      }.should raise_error(Fog::AWS::EC2::Error)
     end
 
   end

data/spec/aws/requests/ec2/get_console_output_spec.rb

@@ -25,10 +25,10 @@ describe 'EC2.get_console_output' do
   end
   describe 'failure' do
 
-    it "should raise a BadRequest error if the instance does not exist" do
+    it "should raise a Fog::AWS::EC2::Error if the instance does not exist" do
       lambda {
         AWS[:ec2].get_console_output('i-00000000')
-      }.should raise_error(Excon::Errors::BadRequest)
+      }.should raise_error(Fog::AWS::EC2::Error)
     end
 
   end

data/spec/aws/requests/ec2/reboot_instances_spec.rb

@@ -20,10 +20,10 @@ describe 'EC2.reboot_instances' do
   end
   describe 'failure' do
 
-    it "should raise a BadRequest error if the instance does not exist" do
+    it "should raise a Fog::AWS::EC2::Error if the instance does not exist" do
       lambda {
         AWS[:ec2].reboot_instances('i-00000000')
-      }.should raise_error(Excon::Errors::BadRequest)
+      }.should raise_error(Fog::AWS::EC2::Error)
     end
 
   end

data/spec/aws/requests/ec2/terminate_instances_spec.rb

@@ -25,10 +25,10 @@ describe 'EC2.terminate_instances' do
   end
   describe 'failure' do
 
-    it 'should raise a BadRequest error if the instance does not exist' do
+    it 'should raise a Fog::AWS::EC2::Error if the instance does not exist' do
       lambda {
         AWS[:ec2].terminate_instances('i-00000000')
-      }.should raise_error(Excon::Errors::BadRequest)
+      }.should raise_error(Fog::AWS::EC2::Error)
     end
 
   end

data/tests/aws/requests/ec2/address_tests.rb

@@ -22,28 +22,12 @@ Shindo.tests('AWS::EC2 | address requests', ['aws']) do
       AWS[:ec2].describe_addresses(@public_ip).body
     end
 
-    tests("#associate_addresses('#{@server.identity}', '#{@public_Ip}')") do
-
-      formats(AWS::EC2::Formats::BASIC) do
-        AWS[:ec2].associate_address(@server.identity, @public_ip).body
-      end
-
-      tests('server.ip_address').returns(@public_ip) do
-        @server.reload.ip_address
-      end
-
+    tests("#associate_addresses('#{@server.identity}', '#{@public_Ip}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].associate_address(@server.identity, @public_ip).body
     end
 
-    tests("#dissassociate_address('#{@public_ip}')") do
-
-      formats(AWS::EC2::Formats::BASIC) do
-        AWS[:ec2].disassociate_address(@public_ip).body
-      end
-
-      test("server.ip_address is not #{@public_ip}") do
-        @server.reload.ip_address != @public_ip
-      end
-
+    tests("#dissassociate_address('#{@public_ip}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].disassociate_address(@public_ip).body
     end
 
     tests("#release_address('#{@public_ip}')").formats(AWS::EC2::Formats::BASIC) do
@@ -55,23 +39,27 @@ Shindo.tests('AWS::EC2 | address requests', ['aws']) do
 
     @address = AWS[:ec2].addresses.create
 
-    tests("#describe_addresses('127.0.0.1')").raises(Excon::Errors::BadRequest) do
+    tests("#describe_addresses('127.0.0.1')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].describe_addresses('127.0.0.1')
     end
 
-    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Excon::Errors::BadRequest) do
+    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].associate_address('i-00000000', @address.identity)
     end
 
-    tests("#associate_addresses('#{@server.identity}', '127.0.0.1')").raises(Excon::Errors::BadRequest) do
+    tests("#associate_addresses('#{@server.identity}', '127.0.0.1')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].associate_address(@server.identity, '127.0.0.1')
     end
 
-    tests("#disassociate_addresses('127.0.0.1') raises BadRequest error").raises(Excon::Errors::BadRequest) do
+    tests("#associate_addresses('i-00000000', '127.0.0.1')").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].associate_address('i-00000000', '127.0.0.1')
+    end
+
+    tests("#disassociate_addresses('127.0.0.1') raises BadRequest error").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].disassociate_address('127.0.0.1')
     end
 
-    tests("#release_address('127.0.0.1')").raises(Excon::Errors::BadRequest) do
+    tests("#release_address('127.0.0.1')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].release_address('127.0.0.1')
     end
 

data/tests/aws/requests/ec2/availability_zone_tests.rb

@@ -14,7 +14,7 @@ Shindo.tests('AWS::EC2 | availability zone requests', ['aws']) do
 
   tests('failure') do
 
-    tests("#describe_availability_zones('not-a-zone')").raises(Excon::Errors::BadRequest) do
+    tests("#describe_availability_zones('not-a-zone')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].describe_availability_zones('not-a-zone')
     end
 

data/tests/aws/requests/ec2/key_pair_tests.rb

@@ -29,11 +29,11 @@ Shindo.tests('AWS::EC2 | key pair requests', ['aws']) do
 
     @key_pair = AWS[:ec2].key_pairs.create(:name => 'fog_key_pair')
 
-    tests("duplicate #create_key_pair('#{@key_pair.name}')").raises(Excon::Errors::BadRequest) do
+    tests("duplicate #create_key_pair('#{@key_pair.name}')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].create_key_pair(@key_pair.name)
     end
 
-    tests("#describe_key_pair('not_a_key_name')").raises(Excon::Errors::BadRequest) do
+    tests("#describe_key_pair('not_a_key_name')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].describe_key_pairs('not_a_key_name').body
     end
 

data/tests/aws/requests/ec2/region_tests.rb

@@ -14,7 +14,7 @@ Shindo.tests('AWS::EC2 | region requests', ['aws']) do
 
   tests('failure') do
 
-    tests("#describe_regions('not-a-region')").raises(Excon::Errors::BadRequest) do
+    tests("#describe_regions('not-a-region')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].describe_regions('not-a-region')
     end
   end

data/tests/aws/requests/ec2/security_group_tests.rb

@@ -59,11 +59,11 @@ Shindo.tests('AWS::EC2 | security group requests', ['aws']) do
 
     @security_group = AWS[:ec2].security_groups.create(:description => 'tests group', :name => 'fog_security_group')
 
-    tests("duplicate #create_security_group(#{@security_group.name}, #{@security_group.description})").raises(Excon::Errors::BadRequest) do
+    tests("duplicate #create_security_group(#{@security_group.name}, #{@security_group.description})").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].create_security_group(@security_group.name, @security_group.description)
     end
 
-    tests("#authorize_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Excon::Errors::BadRequest) do
+    tests("#authorize_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].authorize_security_group_ingress({
         'FromPort' => 80,
         'GroupName' => 'not_a_group_name',
@@ -72,7 +72,7 @@ Shindo.tests('AWS::EC2 | security group requests', ['aws']) do
       })
     end
 
-    tests("#authorize_security_group_ingress({'GroupName' => 'not_a_group_name', 'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Excon::Errors::BadRequest) do
+    tests("#authorize_security_group_ingress({'GroupName' => 'not_a_group_name', 'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].authorize_security_group_ingress({
         'GroupName'                   => 'not_a_group_name',
         'SourceSecurityGroupName'     => 'not_a_group_name',
@@ -80,11 +80,11 @@ Shindo.tests('AWS::EC2 | security group requests', ['aws']) do
       })
     end
 
-    tests("#describe_security_group('not_a_group_name)").raises(Excon::Errors::BadRequest) do
+    tests("#describe_security_group('not_a_group_name)").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].describe_security_groups('not_a_group_name')
     end
 
-    tests("#revoke_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Excon::Errors::BadRequest) do
+    tests("#revoke_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].revoke_security_group_ingress({
         'FromPort' => 80,
         'GroupName' => 'not_a_group_name',
@@ -93,7 +93,7 @@ Shindo.tests('AWS::EC2 | security group requests', ['aws']) do
       })
     end
 
-    tests("#revoke_security_group_ingress({'GroupName' => 'not_a_group_name', 'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Excon::Errors::BadRequest) do
+    tests("#revoke_security_group_ingress({'GroupName' => 'not_a_group_name', 'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].revoke_security_group_ingress({
         'GroupName'                   => 'not_a_group_name',
         'SourceSecurityGroupName'     => 'not_a_group_name',
@@ -101,7 +101,7 @@ Shindo.tests('AWS::EC2 | security group requests', ['aws']) do
       })
     end
 
-    tests("#delete_security_group('not_a_group_name')").raises(Excon::Errors::BadRequest) do
+    tests("#delete_security_group('not_a_group_name')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].delete_security_group('not_a_group_name')
     end
 

data/tests/aws/requests/ec2/snapshot_tests.rb

@@ -28,11 +28,11 @@ Shindo.tests('AWS::EC2 | snapshot requests', ['aws']) do
   end
   tests ('failure') do
 
-    tests("#describe_snapshot('snap-00000000')").raises(Excon::Errors::BadRequest) do
+    tests("#describe_snapshot('snap-00000000')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].describe_snapshots('snap-00000000')
     end
 
-    tests("#delete_snapshot('snap-00000000')").raises(Excon::Errors::BadRequest) do
+    tests("#delete_snapshot('snap-00000000')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].delete_snapshot('snap-00000000')
     end
 

data/tests/aws/requests/ec2/volume_tests.rb

@@ -41,23 +41,23 @@ Shindo.tests('AWS::EC2 | volume requests', ['aws']) do
 
     @volume = AWS[:ec2].volumes.create(:availability_zone => @server.availability_zone, :size => 1)
 
-    tests("#describe_volume('vol-00000000')").raises(Excon::Errors::BadRequest) do
+    tests("#describe_volume('vol-00000000')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].describe_volumes('vol-00000000')
     end
 
-    tests("#attach_volume('i-00000000', '#{@volume.identity}', '/dev/sdh')").raises(Excon::Errors::BadRequest) do
+    tests("#attach_volume('i-00000000', '#{@volume.identity}', '/dev/sdh')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].attach_volume('i-00000000', @volume.identity, '/dev/sdh')
     end
 
-    tests("#attach_volume('#{@server.identity}', 'vol-00000000', '/dev/sdh')").raises(Excon::Errors::BadRequest) do
+    tests("#attach_volume('#{@server.identity}', 'vol-00000000', '/dev/sdh')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].attach_volume(@server.identity, 'vol-00000000', '/dev/sdh')
     end
 
-    tests("#detach_volume('vol-00000000')").raises(Excon::Errors::BadRequest) do
+    tests("#detach_volume('vol-00000000')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].detach_volume('vol-00000000')
     end
 
-    tests("#delete_volume('vol-00000000')").raises(Excon::Errors::BadRequest) do
+    tests("#delete_volume('vol-00000000')").raises(Fog::AWS::EC2::Error) do
       AWS[:ec2].delete_volume('vol-00000000')
     end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - geemus (Wesley Beary)
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-24 00:00:00 -07:00
+date: 2010-05-26 00:00:00 -07:00
 default_executable: fog
 dependencies: 
 - !ruby/object:Gem::Dependency