fog 0.0.4 → 0.0.5

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/fog.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{fog}
-  s.version = "0.0.4"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Wesley Beary"]
-  s.date = %q{2009-09-04}
+  s.date = %q{2009-09-08}
   s.description = %q{brings clouds to you}
   s.email = %q{me@geemus.com}
   s.extra_rdoc_files = [
@@ -36,6 +36,8 @@ Gem::Specification.new do |s|
      "lib/fog/aws/models/ec2/addresses.rb",
      "lib/fog/aws/models/ec2/key_pair.rb",
      "lib/fog/aws/models/ec2/key_pairs.rb",
+     "lib/fog/aws/models/ec2/snapshot.rb",
+     "lib/fog/aws/models/ec2/snapshots.rb",
      "lib/fog/aws/models/ec2/volume.rb",
      "lib/fog/aws/models/ec2/volumes.rb",
      "lib/fog/aws/models/s3/bucket.rb",

data/lib/fog/aws.rb

@@ -25,6 +25,10 @@ module Fog
           "us-east-1" << random_selection('abcd', 1)
         end
 
+        def self.box_usage
+          sprintf("%0.10f", rand / 100).to_f
+        end
+
         def self.etag
           hex(32)
         end

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

@@ -4,24 +4,18 @@ module Fog
 
       class Address < Fog::Model
 
-        attr_accessor :instance_id,
-                      :public_ip
-
-        def initialize(attributes = {})
-          remap_attributes(attributes, {
-            'instanceId'  => :instance_id,
-            'publicIp'    => :public_ip
-          })
-          super
-        end
+        attribute :instance_id, 'instanceId'
+        attribute :public_ip,   'publicIp'
 
         def delete
           connection.release_address(@public_ip)
+          true
         end
 
         def save
           data = connection.allocate_address
           @public_ip = data.body['publicIp']
+          true
         end
 
       end

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

@@ -10,7 +10,7 @@ module Fog
 
         def all(public_ip = [])
           data = connection.describe_addresses(public_ip).body
-          addresses = []
+          addresses = Fog::AWS::EC2::Addresses.new(:connection => connection)
           data['addressesSet'].each do |address|
             addresses << Fog::AWS::EC2::Address.new({
               :connection => connection

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

@@ -4,28 +4,20 @@ module Fog
 
       class KeyPair < Fog::Model
 
-        attr_accessor :fingerprint,
-                      :material,
-                      :name
-
-        def initialize(attributes = {})
-          remap_attributes(attributes, {
-            'keyFingerprint'  => :fingerprint,
-            'keyMaterial'     => :material,
-            'keyName'         => :name
-          })
-          super
-        end
+        attribute :fingerprint, 'keyFingerprint'
+        attribute :material,    'keyMaterial'
+        attribute :name,        'keyName'
 
         def delete
           connection.delete_key_pair(@name)
+          true
         end
 
         def save
           data = connection.create_key_pair(@name).body
           new_attributes = data.reject {|key,value| !['keyFingerprint', 'keyMaterial', 'keyName'].include?(key)}
           update_attributes(new_attributes)
-          data
+          true
         end
 
       end

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

@@ -10,7 +10,7 @@ module Fog
 
         def all(key_name = [])
           data = connection.describe_key_pairs(key_name).body
-          key_pairs = []
+          key_pairs = Fog::AWS::EC2::KeyPairs.new(:connection => connection)
           data['keySet'].each do |key|
             key_pairs << Fog::AWS::EC2::KeyPair.new({
               :connection => connection

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

@@ -0,0 +1,52 @@
+module Fog
+  module AWS
+    class EC2
+
+      class Snapshot < Fog::Model
+
+        attribute :progress
+        attribute :snapshot_id, 'snapshotId'
+        attribute :start_time,  'startTime'
+        attribute :status
+        attribute :volumeId,    'volumeId'
+
+        def delete
+          connection.delete_snapshot(@snapshot_id)
+          true
+        end
+
+        def save
+          data = connection.create_snapshot(@volume.volume_id).body
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          update_attributes(new_attributes)
+          true
+        end
+
+        def snapshots
+          @snapshots ||= begin
+            Fog::AWS::S3::Snapshots.new(
+              :connection => connection,
+              :volume     => self
+            )
+          end
+        end
+
+        def volume
+          @volume
+        end
+
+        private
+
+        def snapshots=(new_snapshots)
+          @snapshots = new_snapshots
+        end
+
+        def volume=(new_volume)
+          @volume = new_volume
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Fog
+  module AWS
+    class EC2
+
+      def snapshots
+        Fog::AWS::EC2::Snapshots.new(:connection => self)
+      end
+
+      class Snapshots < Fog::Collection
+
+        def all(snapshot_id = [])
+          data = connection.describe_snapshots(snapshot_id)
+          snapshots = Fog::AWS::EC2::Snapshots.new(:connection => connection)
+          data['snapshotSet'].each do |volume|
+            snapshots << Fog::AWS::EC2::Snapshot.new({
+              :connection => connection
+            }.merge!(snapshot))
+          end
+          snapshots
+        end
+
+        def create(attributes = {})
+          volume = new(attributes)
+          volume.save
+          volume
+        end
+
+        def new(attributes = {})
+          Fog::AWS::S3::Snapshot.new({
+            :connection => connection,
+            :volume     => @volume,
+            :snapshots  => self
+          }.merge!(attributes))
+        end
+
+        def volume
+          @volume
+        end
+
+        private
+
+        def volume=(new_volume)
+          @volume = new_volume
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -4,40 +4,41 @@ module Fog
 
       class Volume < Fog::Model
 
-        attr_accessor :attachment_time,
-                      :availability_zone,
-                      :device,
-                      :instance_id
-                      :size,
-                      :snapshot_id,
-                      :status,
-                      :volume_id
+        attribute :attachment_time,   'attachmentTime'
+        attribute :availability_zone, 'availabilityZone'
+        attribute :device,            'createTime'
+        attribute :instance_id,       'instanceId'
+        attribute :size
+        attribute :snapshot_id,       'snapshotId'
+        attribute :status,            'status'
+        attribute :volume_id,         'volumeId'
         
         def initialize(attributes = {})
           if attributes['attachmentSet']
             attributes.merge!(attributes.delete('attachmentSet'))
           end
-          remap_attributes(attributes, {
-            'attachmentTime'    => :attachment_time,
-            'availabilityZone'  => :availability_zone,
-            'createTime'        => :create_time,
-            'instanceId'        => :instance_id,
-            'snapshotId'        => :snapshot_id,
-            'status'            => :status
-            'volumeId'          => :volume_id
-          })
           super
         end
 
         def delete
           connection.delete_volume(@volume_id)
+          true
         end
 
         def save
           data = connection.create_volume(@availability_zone, @size, @snapshot_id).body
           new_attributes = data.reject {|key,value| key == 'requestId'}
           update_attributes(new_attributes)
-          data
+          true
+        end
+
+        def snapshots
+          @snapshots ||= begin
+            Fog::AWS::S3::Snapshots.new(
+              :connection => connection,
+              :volume     => self
+            )
+          end
         end
 
       end

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

@@ -10,7 +10,7 @@ module Fog
 
         def all(volume_id = [])
           data = connection.describe_volumes(volume_id)
-          volumes = []
+          volumes = Fog::AWS::EC2::Volumes.new(:connection => connection)
           data['volumeSet'].each do |volume|
             volumes << Fog::AWS::EC2::Volume.new({
               :connection => connection

data/lib/fog/aws/models/s3/bucket.rb

@@ -9,10 +9,6 @@ module Fog
         attribute :name,          'Name'
         attribute :owner
 
-        def initialize(attributes = {})
-          super
-        end
-
         def buckets
           @buckets
         end

data/lib/fog/aws/models/s3/object.rb

@@ -14,10 +14,6 @@ module Fog
         attribute :size,            'Size'
         attribute :storage_class,   'StorageClass'
 
-        def initialize(attributes = {})
-          super
-        end
-
         def bucket
           @bucket
         end

data/lib/fog/aws/models/s3/objects.rb

@@ -9,10 +9,6 @@ module Fog
         attribute :max_keys,      'MaxKeys'
         attribute :prefix,        'Prefix'
 
-        def initialize(attributes = {})
-          super
-        end
-
         def all(options = {})
           merge_attributes(options)
           bucket.buckets.get(bucket.name, attributes).objects

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

@@ -58,7 +58,9 @@ else
           else
             bucket['LocationConstraint'] = ''
           end
-          Fog::AWS::S3.data[:buckets][bucket_name] = bucket
+          unless Fog::AWS::S3.data[:buckets][bucket_name]
+            Fog::AWS::S3.data[:buckets][bucket_name] = bucket
+          end
           response
         end
 

data/lib/fog/aws/requests/simpledb/batch_put_attributes.rb

@@ -1,31 +1,70 @@
-module Fog
-  module AWS
-    class SimpleDB
-
-      # Put items attributes into a SimpleDB domain
-      #
-      # ==== Parameters
-      # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
-      #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
-      # * items<~Hash> - Keys are the items names and may use any UTF-8
-      #   characters valid in xml.  Control characters and sequences not allowed
-      #   in xml are not valid.  Can be up to 1024 bytes long.  Values are the
-      #   attributes to add to the given item and may use any UTF-8 characters
-      #   valid in xml. Control characters and sequences not allowed in xml are
-      #   not valid.  Each name and value can be up to 1024 bytes long.
-      #
-      # ==== Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'BoxUsage'
-      #     * 'RequestId'
-      def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([]))
-        request({
-          'Action' => 'BatchPutAttributes',
-          'DomainName' => domain_name
-        }.merge!(encode_batch_attributes(items, replace_attributes)), Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string))
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        # Put items attributes into a SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        #   following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # * items<~Hash> - Keys are the items names and may use any UTF-8
+        #   characters valid in xml.  Control characters and sequences not allowed
+        #   in xml are not valid.  Can be up to 1024 bytes long.  Values are the
+        #   attributes to add to the given item and may use any UTF-8 characters
+        #   valid in xml. Control characters and sequences not allowed in xml are
+        #   not valid.  Each name and value can be up to 1024 bytes long.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([]))
+          request({
+            'Action' => 'BatchPutAttributes',
+            'DomainName' => domain_name
+          }.merge!(encode_batch_attributes(items, replace_attributes)), Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string))
+        end
+
       end
+    end
+  end
 
+else
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([]))
+          response = Fog::Response.new
+          if Fog::AWS::SimpleDB.data[:domains][domain_name]
+            for key, value in items do
+              for item in value do
+                if replace_attributes[key] && replace_attributes[key].include?(value)
+                  Fog::AWS::SimpleDB.data[:domains][domain_name][key] = []
+                else
+                  Fog::AWS::SimpleDB.data[:domains][domain_name][key] ||= []
+                end
+                Fog::AWS::SimpleDB.data[:domains][domain_name][key] << value.to_s
+              end
+            end
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
     end
   end
+
 end

data/lib/fog/aws/requests/simpledb/create_domain.rb

@@ -1,25 +1,50 @@
-module Fog
-  module AWS
-    class SimpleDB
-
-      # Create a SimpleDB domain
-      #
-      # ==== Parameters
-      # * domain_name<~String>:: Name of domain. Must be between 3 and 255 of the
-      # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
-      # 
-      # ==== Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'BoxUsage'
-      #     * 'RequestId'
-      def create_domain(domain_name)
-        request({
-          'Action' => 'CreateDomain',
-          'DomainName' => domain_name
-        }, Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string))
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        # Create a SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String>:: Name of domain. Must be between 3 and 255 of the
+        # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # 
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def create_domain(domain_name)
+          request({
+            'Action' => 'CreateDomain',
+            'DomainName' => domain_name
+          }, Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string))
+        end
+
       end
+    end
+  end
 
+else
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        def create_domain(domain_name)
+          response = Fog::Response.new
+          Fog::AWS::SimpleDB.data[:domains][domain_name] = { :attributes => {} }
+          response.status = 200
+          response.body = {
+            'BoxUsage'  => Fog::AWS::Mock.box_usage,
+            'RequestId' => Fog::AWS::Mock.request_id
+          }
+          response
+        end
+
+      end
     end
   end
+
 end

data/lib/fog/aws/requests/simpledb/delete_domain.rb

@@ -1,25 +1,51 @@
-module Fog
-  module AWS
-    class SimpleDB
-
-      # Delete a SimpleDB domain
-      #
-      # ==== Parameters
-      # * domain_name<~String>:: Name of domain. Must be between 3 and 255 of the
-      # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
-      # 
-      # ==== Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'BoxUsage'
-      #     * 'RequestId'
-      def delete_domain(domain_name)
-        request({
-          'Action' => 'DeleteDomain',
-          'DomainName' => domain_name
-        }, Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string))
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        # Delete a SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String>:: Name of domain. Must be between 3 and 255 of the
+        # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # 
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def delete_domain(domain_name)
+          request({
+            'Action' => 'DeleteDomain',
+            'DomainName' => domain_name
+          }, Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string))
+        end
+
       end
+    end
+  end
 
+else
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        def delete_domain(domain_name)
+          response = Fog::Response.new
+          if Fog::AWS::SimpleDB.data[:domains].delete(domain_name)
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          end
+          response
+        end
+
+      end
     end
   end
+
 end

data/lib/fog/aws/requests/simpledb/list_domains.rb

@@ -1,30 +1,63 @@
-module Fog
-  module AWS
-    class SimpleDB
-
-      # List SimpleDB domains
-      #
-      # ==== Parameters
-      # * options<~Hash> - options, defaults to {}
-      #   * 'MaxNumberOfDomains'<~Integer> - number of domains to return
-      #     between 1 and 100, defaults to 100
-      #   * 'NextToken'<~String> - Offset token to start listing, defaults to nil
-      #
-      # ==== Returns
-      # * response<~Fog::AWS::Response>:
-      #   * body<~Hash>:
-      #     * 'BoxUsage'
-      #     * 'Domains' - array of domain names.
-      #     * 'NextToken' - offset to start with if there are are more domains to list
-      #     * 'RequestId'
-      def list_domains(options = {})
-        request({
-          'Action' => 'ListDomains',
-          'MaxNumberOfDomains' => options['MaxNumberOfDomains'],
-          'NextToken' => options['NextToken']
-        }, Fog::Parsers::AWS::SimpleDB::ListDomains.new(@nil_string))
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        # List SimpleDB domains
+        #
+        # ==== Parameters
+        # * options<~Hash> - options, defaults to {}
+        #   * 'MaxNumberOfDomains'<~Integer> - number of domains to return
+        #     between 1 and 100, defaults to 100
+        #   * 'NextToken'<~String> - Offset token to start listing, defaults to nil
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'Domains' - array of domain names.
+        #     * 'NextToken' - offset to start with if there are are more domains to list
+        #     * 'RequestId'
+        def list_domains(options = {})
+          request({
+            'Action' => 'ListDomains'
+          }.merge!(options), Fog::Parsers::AWS::SimpleDB::ListDomains.new(@nil_string))
+        end
+
       end
+    end
+  end
 
+else
+
+  module Fog
+    module AWS
+      class SimpleDB
+
+        def list_domains(options = {})
+          response = Fog::Response.new
+          keys = Fog::AWS::SimpleDB.data[:domains].keys
+          max = options['MaxNumberOfDomains'] || keys.size
+          offset = options['NextToken'] || 0
+          domains = []
+          for key, value in Fog::AWS::SimpleDB.data[:domains].keys[offset...max]
+            domains << key
+          end
+          response.status = 200
+          response.body = {
+            'BoxUsage'  => Fog::AWS::Mock.box_usage,
+            'Domains'   => domains,
+            'RequestId' => Fog::AWS::Mock.request_id
+          }
+          if max < keys.size
+            response.body['NextToken'] = max + 1
+          end
+          response
+        end
+
+      end
     end
   end
+
 end

data/lib/fog/aws/simpledb.rb

@@ -2,6 +2,15 @@ module Fog
   module AWS
     class SimpleDB
 
+      if Fog.mocking?
+        def self.reset_data
+          @data = { :domains => {} }
+        end
+        def self.data
+          @data
+        end
+      end
+
       def self.reload
         current_directory = File.dirname(__FILE__)
         load "#{current_directory}/../connection.rb"
@@ -25,6 +34,10 @@ module Fog
         load "#{requests_directory}/list_domains.rb"
         load "#{requests_directory}/put_attributes.rb"
         load "#{requests_directory}/select.rb"
+
+        if Fog.mocking?
+          reset_data
+        end
       end
 
       # Initialize connection to SimpleDB

data/spec/aws/requests/simpledb/batch_put_attributes_spec.rb

@@ -19,4 +19,13 @@ describe 'SimpleDB.batch_put_attributes' do
     end
 
   end
+  describe 'failure' do
+
+    it 'should raise a BadRequest error if the domain does not exist' do
+      lambda {
+        sdb.batch_put_attributes('notadomain', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } })
+      }.should raise_error(Fog::Errors::BadRequest)
+    end
+
+  end
 end

data/spec/aws/requests/simpledb/create_domain_spec.rb

@@ -1,15 +1,15 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe 'SimpleDB.create_domain' do
-  describe 'success' do
+  before(:each) do
+    @domain_name = "fog_domain_#{Time.now.to_i}"
+  end
 
-    before(:each) do
-      @domain_name = "fog_domain_#{Time.now.to_i}"
-    end
+  after(:each) do
+    sdb.delete_domain(@domain_name)
+  end
 
-    after(:each) do
-      sdb.delete_domain(@domain_name)
-    end
+  describe 'success' do
 
     it 'should return proper attributes' do
       actual = sdb.create_domain(@domain_name)
@@ -18,4 +18,12 @@ describe 'SimpleDB.create_domain' do
     end
 
   end
+  describe 'failure' do
+
+    it 'should not raise an error if the domain already exists' do
+      sdb.create_domain(@domain_name)
+      sdb.create_domain(@domain_name)
+    end
+
+  end
 end

data/spec/aws/requests/simpledb/delete_attributes_spec.rb

@@ -4,19 +4,36 @@ describe 'SimpleDB.delete_attributes' do
   describe 'success' do
 
     before(:each) do
-      sdb.create_domain('delete_attributes')
-      sdb.put_attributes('delete_attributes', 'foo', { :bar => :baz })
+      @domain_name = "fog_domain_#{Time.now.to_i}"
+      sdb.create_domain(@domain_name)
+      sdb.put_attributes(@domain_name, 'foo', { :bar => :baz })
     end
 
     after(:each) do
-      sdb.delete_domain('delete_attributes')
+      sdb.delete_domain(@domain_name)
     end
 
     it 'should return proper attributes from delete_attributes' do
-      actual = sdb.delete_attributes('delete_attributes', 'foo')
+      actual = sdb.delete_attributes(@domain_name, 'foo')
       actual.body['RequestId'].should be_a(String)
       actual.body['BoxUsage'].should be_a(Float)
     end
 
   end
+  describe 'failure' do
+
+    it 'shouild raise a BadRequest error if the domain does not exist' do
+      lambda {
+        sdb.delete_attributes('notadomain', 'notanattribute')
+      }.should raise_error(Fog::Errors::BadRequest)
+    end
+
+    it 'should not raise an error if the attribute does not exist' do
+      @domain_name = "fog_domain_#{Time.now.to_i}"
+      sdb.create_domain(@domain_name)
+      sdb.delete_attributes(@domain_name, 'notanattribute')
+      sdb.delete_domain(@domain_name)
+    end
+
+  end
 end

data/spec/aws/requests/simpledb/delete_domain_spec.rb

@@ -18,4 +18,11 @@ describe 'SimpleDB.delete_domain' do
     end
 
   end
+  describe 'failure' do
+
+    it 'should not raise an error if the domain does not exist' do
+      sdb.delete_domain('notadomain')
+    end
+
+  end
 end

data/spec/aws/requests/simpledb/domain_metadata_spec.rb

@@ -40,4 +40,13 @@ describe 'SimpleDB.domain_metadata' do
     end
 
   end
+  describe 'failure' do
+
+    it 'should raise a BadRequest error if the domain does not exist' do
+      lambda {
+        sdb.domain_metadata('notadomain')
+      }.should raise_error(Fog::Errors::BadRequest)
+    end
+
+  end
 end

data/spec/aws/requests/simpledb/get_attributes_spec.rb

@@ -28,4 +28,20 @@ describe 'SimpleDB.get_attributes' do
     end
 
   end
+  describe 'failure' do
+
+    it 'should raise a BadRequest error if the domain does not exist' do
+      lambda {
+        sdb.get_attributes('notadomain', 'notanattribute')
+      }.should raise_error(Fog::Errors::BadRequest)
+    end
+
+    it 'should not raise an error if the attribute does not exist' do
+      @domain_name = "fog_domain_#{Time.now.to_i}"
+      sdb.create_domain(@domain_name)
+      sdb.get_attributes(@domain_name, 'notanattribute')
+      sdb.delete_domain(@domain_name)
+    end
+
+  end
 end

data/spec/aws/requests/simpledb/put_attributes_spec.rb

@@ -19,4 +19,13 @@ describe 'SimpleDB.put_attributes' do
     end
 
   end
+  describe 'failure' do
+
+    it 'should raise a BadRequest error if the domain does not exist' do
+      lambda {
+        sdb.put_attributes(@domain_name, 'notadomain', { 'notanattribute' => 'value' })
+      }.should raise_error(Fog::Errors::BadRequest)
+    end
+
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fog
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Wesley Beary
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-04 00:00:00 -07:00
+date: 2009-09-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -71,6 +71,8 @@ files:
 - lib/fog/aws/models/ec2/addresses.rb
 - lib/fog/aws/models/ec2/key_pair.rb
 - lib/fog/aws/models/ec2/key_pairs.rb
+- lib/fog/aws/models/ec2/snapshot.rb
+- lib/fog/aws/models/ec2/snapshots.rb
 - lib/fog/aws/models/ec2/volume.rb
 - lib/fog/aws/models/ec2/volumes.rb
 - lib/fog/aws/models/s3/bucket.rb