heirloom 0.12.1 → 0.12.2

data/spec/aws/s3_spec.rb

@@ -5,8 +5,8 @@ describe Heirloom do
 
     it "should use the access and secret keys by default" do
 
-      config = mock_config :aws_access_key_id => 'key',
-                           :aws_secret_access_key => 'secret'
+      config = double_config :aws_access_key_id => 'key',
+                             :aws_secret_access_key => 'secret'
 
       Fog::Storage.should_receive(:new).
                    with :provider => 'AWS',
@@ -19,8 +19,8 @@ describe Heirloom do
 
     it "should use the iam role if asked to" do
 
-      config = mock_config :use_iam_profile => true
-      
+      config = double_config :use_iam_profile => true
+
       Fog::Storage.should_receive(:new).
                    with :provider => 'AWS',
                         :use_iam_profile => true,
@@ -33,121 +33,121 @@ describe Heirloom do
   context "s3 / bucket operations" do
 
     before do
-      @directories_mock = mock 'directories'
-      @bucket_mock = mock 'bucket'
-      @fog_mock = mock 'fog'
-      @fog_mock.stub :directories => @directories_mock
-      Fog::Storage.stub :new => @fog_mock
-      @s3 = Heirloom::AWS::S3.new :config => mock_config, :region => 'us-west-1'
+      @directories_double = double 'directories'
+      @bucket_double = double 'bucket'
+      @fog_double = double 'fog'
+      @fog_double.stub :directories => @directories_double
+      Fog::Storage.stub :new => @fog_double
+      @s3 = Heirloom::AWS::S3.new :config => double_config, :region => 'us-west-1'
     end
 
     context "bucket_exists?" do
       it "should return true if the bucket exists" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').and_return @bucket_mock
+        @directories_double.should_receive(:get).
+                            with('bucket').and_return @bucket_double
         @s3.bucket_exists?('bucket').should be_true
       end
 
       it "should return false if the bucket does not exist" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').and_return nil
+        @directories_double.should_receive(:get).
+                            with('bucket').and_return nil
         @s3.bucket_exists?('bucket').should be_false
       end
 
       it "should return false if bucket owned by another account" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').
-                          and_raise Excon::Errors::Forbidden.new('msg')
+        @directories_double.should_receive(:get).
+                            with('bucket').
+                            and_raise Excon::Errors::Forbidden.new('msg')
         @s3.bucket_exists?('bucket').should be_false
       end
     end
 
     context "bucket_exists_in_another_region?" do
       it "should return true if the bucket exists in another region" do
-        @bucket_mock.stub :location => 'us-east-1'
-        @directories_mock.should_receive(:get).
-                          with('bucket').at_least(:once).
-                          and_return @bucket_mock
+        @bucket_double.stub :location => 'us-east-1'
+        @directories_double.should_receive(:get).
+                            with('bucket').at_least(:once).
+                            and_return @bucket_double
         @s3.bucket_exists_in_another_region?('bucket').should be_true
       end
 
       it "should return false if the bucket exists in the curren region" do
-        @bucket_mock.stub :location => 'us-west-1'
-        @directories_mock.should_receive(:get).
-                          with('bucket').at_least(:once).
-                          and_return @bucket_mock
+        @bucket_double.stub :location => 'us-west-1'
+        @directories_double.should_receive(:get).
+                            with('bucket').at_least(:once).
+                            and_return @bucket_double
         @s3.bucket_exists_in_another_region?('bucket').should be_false
       end
 
       it "should return false if bucket owned by another account" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').
-                          and_raise Excon::Errors::Forbidden.new('msg')
+        @directories_double.should_receive(:get).
+                            with('bucket').
+                            and_raise Excon::Errors::Forbidden.new('msg')
         @s3.bucket_exists_in_another_region?('bucket').should be_false
       end
     end
 
     context "bucket_owned_by_another_account?" do
       it "should return false if bucket owned by this account" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').
-                          and_return @bucket_mock
+        @directories_double.should_receive(:get).
+                            with('bucket').
+                            and_return @bucket_double
         @s3.bucket_owned_by_another_account?('bucket').should be_false
       end
 
       it "should return false if bucket does not exist" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').
-                          and_return nil
+        @directories_double.should_receive(:get).
+                            with('bucket').
+                            and_return nil
         @s3.bucket_owned_by_another_account?('bucket').should be_false
       end
 
       it "should return true if bucket is not owned by another account" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').
-                          and_raise Excon::Errors::Forbidden.new('msg')
+        @directories_double.should_receive(:get).
+                            with('bucket').
+                            and_raise Excon::Errors::Forbidden.new('msg')
         @s3.bucket_owned_by_another_account?('bucket').should be_true
       end
     end
 
     it "should delete an object from s3" do
-      @fog_mock.should_receive(:delete_object).
-                with('bucket', 'object', { :option => 'test' })
+      @fog_double.should_receive(:delete_object).
+                  with('bucket', 'object', { :option => 'test' })
       @s3.delete_object('bucket', 'object', { :option => 'test' })
     end
 
     it "should get a bucket from s3" do
-      @directories_mock.should_receive(:get).with 'bucket'
+      @directories_double.should_receive(:get).with 'bucket'
       @s3.get_bucket 'bucket'
     end
 
     context "testing bucket availability" do
 
       it "should return false if the bucket is forbidden" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').
-                          and_raise Excon::Errors::Forbidden.new('msg')
+        @directories_double.should_receive(:get).
+                            with('bucket').
+                            and_raise Excon::Errors::Forbidden.new('msg')
         @s3.bucket_name_available?('bucket').should be_false
       end
 
       it "should return false if bucket in different region" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').at_least(:once).
-                          and_return @bucket_mock
-        @bucket_mock.stub :location => 'us-east-1'
+        @directories_double.should_receive(:get).
+                            with('bucket').at_least(:once).
+                            and_return @bucket_double
+        @bucket_double.stub :location => 'us-east-1'
         @s3.bucket_name_available?('bucket').should be_false
       end
 
       it "should return true if the bucket is in this account / region" do
-        @directories_mock.should_receive(:get).
-                          with('bucket').at_least(:once).
-                          and_return @bucket_mock
-        @bucket_mock.stub :location => 'us-west-1'
+        @directories_double.should_receive(:get).
+                            with('bucket').at_least(:once).
+                            and_return @bucket_double
+        @bucket_double.stub :location => 'us-west-1'
         @s3.bucket_name_available?('bucket').should be_true
       end
 
       it "should return true if the bucket is not found" do
-        @directories_mock.should_receive(:get).
+        @directories_double.should_receive(:get).
                           with('bucket').at_least(:once).
                           and_return nil
         @s3.bucket_name_available?('bucket').should be_true
@@ -156,110 +156,110 @@ describe Heirloom do
     end
 
     it "should return object versions for a given bucket" do
-      body_mock = mock 'body'
-      @fog_mock.should_receive(:get_bucket_object_versions).
-                with('bucket').
-                and_return body_mock
-      body_mock.stub :body => 'body_hash'
+      body_double = double 'body'
+      @fog_double.should_receive(:get_bucket_object_versions).
+                  with('bucket').
+                  and_return body_double
+      body_double.stub :body => 'body_hash'
       @s3.get_bucket_object_versions('bucket').should == 'body_hash'
     end
 
     context "testing bucket deletion" do
       it "should return true if the bucket has 0 objects" do
-        body_mock = mock 'body'
-        @fog_mock.should_receive(:get_bucket_object_versions).
-                  with('bucket').
-                  and_return body_mock
-        body_mock.stub :body => { "Versions" => [ ] }
+        body_double = double 'body'
+        @fog_double.should_receive(:get_bucket_object_versions).
+                    with('bucket').
+                    and_return body_double
+        body_double.stub :body => { "Versions" => [ ] }
         @s3.bucket_empty?('bucket').should be_true
       end
 
       it "should return false if the bucket has any objects" do
-        body_mock = mock 'body'
-        @fog_mock.should_receive(:get_bucket_object_versions).
-                  with('bucket').
-                  and_return body_mock
-        body_mock.stub :body => { "Versions" => [ 'obj1', 'obj2' ] }
+        body_double = double 'body'
+        @fog_double.should_receive(:get_bucket_object_versions).
+                    with('bucket').
+                    and_return body_double
+        body_double.stub :body => { "Versions" => [ 'obj1', 'obj2' ] }
         @s3.bucket_empty?('bucket').should be_false
       end
 
       it "should delete a bucket from s3 if empty" do
-        body_mock = mock 'body'
-        @fog_mock.should_receive(:get_bucket_object_versions).
+        body_double = double 'body'
+        @fog_double.should_receive(:get_bucket_object_versions).
                   with('bucket').
-                  and_return body_mock
-        body_mock.stub :body => { "Versions" => [ ] }
-        @fog_mock.should_receive(:delete_bucket).
+                  and_return body_double
+        body_double.stub :body => { "Versions" => [ ] }
+        @fog_double.should_receive(:delete_bucket).
           with('bucket').and_return true
         @s3.delete_bucket('bucket').should be_true
       end
 
       it "should return false and not attempt to delete a non empty s3 bucket" do
-        body_mock = mock 'body'
-        @fog_mock.should_receive(:get_bucket_object_versions).
-                  with('bucket').
-                  and_return body_mock
-        body_mock.stub :body => { "Versions" => [ 'obj1', 'obj2' ] }
-        @fog_mock.should_receive(:delete_bucket).never
+        body_double = double 'body'
+        @fog_double.should_receive(:get_bucket_object_versions).
+                    with('bucket').
+                    and_return body_double
+        body_double.stub :body => { "Versions" => [ 'obj1', 'obj2' ] }
+        @fog_double.should_receive(:delete_bucket).never
         @s3.delete_bucket('bucket').should be_false
       end
 
       it "should return true if Excon::Errors::NotFound raised when deleting bucket" do
-        @fog_mock.should_receive(:get_bucket_object_versions).
-                  with('bucket').
-                  and_raise Excon::Errors::NotFound.new 'Bucket does not exist.'
-        @fog_mock.should_receive(:delete_bucket).never
+        @fog_double.should_receive(:get_bucket_object_versions).
+                    with('bucket').
+                    and_raise Excon::Errors::NotFound.new 'Bucket does not exist.'
+        @fog_double.should_receive(:delete_bucket).never
         @s3.delete_bucket('bucket').should be_true
       end
     end
 
     it "should get an object from s3" do
-      body_mock = mock 'body'
-      @fog_mock.should_receive(:get_object).
-                with('bucket', 'object').
-                and_return body_mock
-      body_mock.stub :body => 'body_hash'
+      body_double = double 'body'
+      @fog_double.should_receive(:get_object).
+                  with('bucket', 'object').
+                  and_return body_double
+      body_double.stub :body => 'body_hash'
       @s3.get_object('bucket', 'object').should == 'body_hash'
     end
 
     it "should get a buckets acl from s3" do
-      body_mock = mock 'body'
-      @fog_mock.should_receive(:get_object).
-                with('bucket', 'object').
-                and_return body_mock
-      body_mock.should_receive(:body)
+      body_double = double 'body'
+      @fog_double.should_receive(:get_object).
+                  with('bucket', 'object').
+                  and_return body_double
+      body_double.should_receive(:body)
       @s3.get_object('bucket', 'object')
     end
 
     it "should get an objects acl from s3" do
-      body_mock = mock 'body'
-      @fog_mock.should_receive(:get_object_acl).
-                with('bucket', 'object').and_return(body_mock)
-      body_mock.stub :body => 'data'
+      body_double = double 'body'
+      @fog_double.should_receive(:get_object_acl).
+                  with('bucket', 'object').and_return(body_double)
+      body_double.stub :body => 'data'
       @s3.get_object_acl({ :bucket => 'bucket', :object_name => 'object'}).
           should == 'data'
     end
 
 
     it "should set object acls" do
-      @fog_mock.should_receive(:put_object_acl).
-                with 'bucket', 'object', 'grants'
+      @fog_double.should_receive(:put_object_acl).
+                  with 'bucket', 'object', 'grants'
       @s3.put_object_acl 'bucket', 'object', 'grants'
     end
 
     it "should call put bucket with location_constraint us-west-1" do
       options = { 'LocationConstraint' => 'us-west-1',
                   'x-amz-acl'          => 'private' }
-      @fog_mock.should_receive(:put_bucket).
-                with('name', options)
+      @fog_double.should_receive(:put_bucket).
+                  with('name', options)
       @s3.put_bucket 'name', 'us-west-1'
     end
 
     it "should call put bucket with location_constraint nil when region us-west-1" do
       options = { 'LocationConstraint' => nil,
                   'x-amz-acl'          => 'private' }
-      @fog_mock.should_receive(:put_bucket).
-                with('name', options)
+      @fog_double.should_receive(:put_bucket).
+                  with('name', options)
       @s3.put_bucket 'name', 'us-east-1'
     end
 

data/spec/aws/simpledb_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Heirloom::AWS::SimpleDB do
 
-  let(:sdb) { Heirloom::AWS::SimpleDB.new :config => mock_config }
+  let(:sdb) { Heirloom::AWS::SimpleDB.new :config => double_config }
 
   context "credential management" do
     it "should use the access and secret keys by default" do
-      config = mock_config :aws_access_key_id => 'key',
-                           :aws_secret_access_key => 'secret'
+      config = double_config :aws_access_key_id => 'key',
+                             :aws_secret_access_key => 'secret'
 
       Fog::AWS::SimpleDB.should_receive(:new).
                          with :aws_access_key_id => 'key',
@@ -18,7 +18,7 @@ describe Heirloom::AWS::SimpleDB do
     end
 
     it "should use the iam role if asked to" do
-      config = mock_config :use_iam_profile => true
+      config = double_config :use_iam_profile => true
 
       Fog::AWS::SimpleDB.should_receive(:new).
                          with :use_iam_profile => true,
@@ -28,117 +28,87 @@ describe Heirloom::AWS::SimpleDB do
 
   end
 
-  # Data recorded with VCR after running ./spec/fixtures/create_test_data.sh
-  context "select", :vcr => true do
-    let(:sdb) { Heirloom::AWS::SimpleDB.new :config => integration_or_mock_config }
-
-    before do
-      @q = "select * from `heirloom_test_data` where built_at > '2000-01-01T00:00:00.000Z' order by built_at desc"
-    end
-
-    it "should get results" do
-      keys = sdb.select(@q).keys
-      keys.size.should == 10
-      keys.first.should == "v10"
-    end
-
-    it "should be able to offset results" do
-      keys = sdb.select(@q, :offset => 2).keys
-      keys.size.should == 8
-      keys.first.should == "v8"
-    end
-
-    it "should yield when requested" do
-      num_yields = 0
-      sdb.select(@q, :offset => 2) do |k, v|
-        num_yields += 1
-      end
-      num_yields.should == 8
-    end
-
-  end
-
   context "sdb operations" do
     before do
-      @fog_mock = mock 'fog'
-      Fog::AWS::SimpleDB.stub :new => @fog_mock
+      @fog_double = double 'fog'
+      Fog::AWS::SimpleDB.stub :new => @fog_double
     end
 
     it "should list the domains in simples db" do
-      body_mock = mock 'body'
-      @fog_mock.should_receive(:list_domains).
-                and_return body_mock
-      body_mock.should_receive(:body).
-                and_return 'Domains' => ['domain1']
+      body_double = double 'body'
+      @fog_double.should_receive(:list_domains).
+                  and_return body_double
+      body_double.should_receive(:body).
+                  and_return 'Domains' => ['domain1']
       sdb.domains.should == ['domain1']
     end
 
     it "should create a new domain when it does not exist" do
       sdb.should_receive(:domains).and_return([])
-      @fog_mock.should_receive(:create_domain).with('new_domain')
+      @fog_double.should_receive(:create_domain).with('new_domain')
       sdb.create_domain('new_domain')
     end
 
     it "should destroy the specified domain" do
-      @fog_mock.should_receive(:delete_domain).with('new_domain')
+      @fog_double.should_receive(:delete_domain).with('new_domain')
       sdb.delete_domain('new_domain')
     end
 
     it "should not create a new domain when already exists" do
       sdb.should_receive(:domains).and_return(['new_domain'])
-      @fog_mock.should_receive(:create_domain).exactly(0).times
+      @fog_double.should_receive(:create_domain).exactly(0).times
       sdb.create_domain('new_domain')
     end
 
     it "should update the attributes for an entry" do
-      @fog_mock.should_receive(:put_attributes).
+      @fog_double.should_receive(:put_attributes).
         with('domain', 'key', {'key' => 'value'}, { "option" => "123" })
       sdb.put_attributes('domain', 'key', {'key' => 'value'}, { "option" => "123" })
     end
 
     it "should delete the given entry from sdb" do
-      @fog_mock.should_receive(:delete_attributes).with('domain', 'key')
+      @fog_double.should_receive(:delete_attributes).with('domain', 'key')
       sdb.delete('domain', 'key')
     end
 
     context "testing counts" do
       before do
-        @body_stub = stub 'body'
+        @body_double = double 'body'
       end
 
       it "should count the number of entries in the domain" do
         data = { 'Items' => { 'Domain' => { 'Count' => ['1'] } } }
-        @fog_mock.should_receive(:select).
-                  with('SELECT count(*) FROM `heirloom_domain`').
-                  and_return @body_stub
-        @body_stub.stub :body => data
+        @fog_double.should_receive(:select).
+                    with('SELECT count(*) FROM `heirloom_domain`').
+                    and_return @body_double
+        @body_double.stub :body => data
         sdb.count('heirloom_domain').should == 1
       end
 
       it "should return true if no entries for the domain" do
         data = { 'Items' => { 'Domain' => { 'Count' => ['0'] } } }
-        @fog_mock.should_receive(:select).
-                  with('SELECT count(*) FROM `heirloom_domain`').
-                  and_return @body_stub
-        @body_stub.stub :body => data
+        @fog_double.should_receive(:select).
+                    with('SELECT count(*) FROM `heirloom_domain`').
+                    and_return @body_double
+        @body_double.stub :body => data
         sdb.domain_empty?('heirloom_domain').should be_true
       end
 
       it "should return false if entries exist for the domain" do
         data = { 'Items' => { 'Domain' => { 'Count' => ['50'] } } }
-        @fog_mock.should_receive(:select).
-                  with('SELECT count(*) FROM `heirloom_domain`').
-                  and_return @body_stub
-        @body_stub.stub :body => data
+        @fog_double.should_receive(:select).
+                    with('SELECT count(*) FROM `heirloom_domain`').
+                    and_return @body_double
+        @body_double.stub :body => data
         sdb.domain_empty?('heirloom_domain').should be_false
       end
 
       it "should return the count for a specific itemName within a domain" do
         data = { 'Items' => { 'Domain' => { 'Count' => ['1'] } } }
-        @fog_mock.should_receive(:select).
-                  with("SELECT count(*) FROM `heirloom` WHERE itemName() = 'archive'").
-                  and_return @body_stub
-        @body_stub.stub :body => data
+        @fog_double.should_receive(:select).
+                    with("SELECT count(*) FROM `heirloom` WHERE itemName() = 'archive'").
+                    and_return @body_double
+        @body_double.stub :body => data
         sdb.item_count('heirloom', 'archive').should == 1
       end
     end