heirloom 0.12.1 → 0.12.2

data/spec/archive/authorizer_spec.rb

@@ -3,38 +3,38 @@ require 'spec_helper'
 describe Heirloom do
 
     before do
-      @config_mock = mock 'config'
-      @logger_mock = mock 'logger'
-      @logger_mock.stub :info => true, :debug => true
-      @config_mock.should_receive(:logger).and_return(@logger_mock)
-      @authorizer = Heirloom::Authorizer.new :config => @config_mock,
+      @config_double = double 'config'
+      @logger_double = double 'logger'
+      @logger_double.stub :info => true, :debug => true
+      @config_double.should_receive(:logger).and_return(@logger_double)
+      @authorizer = Heirloom::Authorizer.new :config => @config_double,
                                              :name   => 'tim',
                                              :id     => '123.tar.gz'
     end
 
     it "should authorize access to an archive in all regions for email or longid" do
-      s3_acl_mock = mock 's3 acl'
-      reader_mock = mock 'reader mock'
-      reader_mock.stub :key_name => '123.tar.gz'
-      reader_mock.should_receive(:get_bucket).exactly(2).times.
+      s3_acl_double = double 's3 acl'
+      reader_double = double 'reader mock'
+      reader_double.stub :key_name => '123.tar.gz'
+      reader_double.should_receive(:get_bucket).exactly(2).times.
                       and_return('the-bucket')
 
       accounts = [ "test@a.com", "a@test.com", "test@test.co", "test@test.co.uk","08b21b085ca99e70859487d685191f40d951daa0fbcb5bec51bf5ea6023e445d" ]
 
       Heirloom::Reader.should_receive(:new).
-                       with(:config => @config_mock,
+                       with(:config => @config_double,
                             :name   => 'tim',
                             :id     => '123.tar.gz').
-                       and_return reader_mock
+                       and_return reader_double
       Heirloom::ACL::S3.should_receive(:new).
-                        with(:config => @config_mock,
+                        with(:config => @config_double,
                              :region   => 'us-west-1').
-                        and_return s3_acl_mock
+                        and_return s3_acl_double
       Heirloom::ACL::S3.should_receive(:new).
-                        with(:config => @config_mock,
+                        with(:config => @config_double,
                              :region   => 'us-west-2').
-                        and_return s3_acl_mock
-      s3_acl_mock.should_receive(:allow_read_access_from_accounts).
+                        and_return s3_acl_double
+      s3_acl_double.should_receive(:allow_read_access_from_accounts).
              exactly(2).times.
              with(:key_name   => '123.tar.gz',
                   :key_folder => 'tim',
@@ -46,28 +46,28 @@ describe Heirloom do
     end
 
     it "should exit when an account is a shortid" do
-      @logger_mock.should_receive(:error)
+      @logger_double.should_receive(:error)
       @authorizer.authorize(:accounts => [ '123456789_1234', 'good@good.com'],
                             :regions  => ['us-west-1', 'us-west-2']).
                   should be_false
     end
 
     it "should exit when a bad email is given" do
-      @logger_mock.should_receive(:error)
+      @logger_double.should_receive(:error)
       @authorizer.authorize(:accounts => ['bad@bad', 'good@good.com'],
                             :regions  => ['us-west-1', 'us-west-2']).
                   should be_false
     end
 
     it "should exit when an id which is not long(64) or short(16)" do
-      @logger_mock.should_receive(:error)
+      @logger_double.should_receive(:error)
       @authorizer.authorize(:accounts => ['123456789_123456789_1', 'good@good.com'],
                             :regions  => ['us-west-1', 'us-west-2']).
                   should be_false
     end
 
     it "should exit even when the first value is valid" do
-      @logger_mock.should_receive(:error)
+      @logger_double.should_receive(:error)
       @authorizer.authorize(:accounts => ['good@good.com', '123456789_123456789_1'],
                             :regions  => ['us-west-1', 'us-west-2']).
                   should be_false

data/spec/archive/builder_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe Heirloom::Builder do
   before do
-    @config_mock   = double 'config'
-    @logger_stub   = stub :debug => 'true', :info => 'true', :warn => 'true'
-    @config_mock.stub(:logger).and_return(@logger_stub)
-    @simpledb_mock = double 'simple db'
-    @builder       = Heirloom::Builder.new :config => @config_mock,
+    @config_double   = double 'config'
+    @logger_double   = double :debug => 'true', :info => 'true', :warn => 'true'
+    @config_double.stub(:logger).and_return(@logger_double)
+    @simpledb_double = double 'simple db'
+    @builder         = Heirloom::Builder.new :config => @config_double,
                                            :name   => 'tim',
                                            :id     => '123'
   end
@@ -14,28 +14,28 @@ describe Heirloom::Builder do
   describe 'build' do
     context 'when successful' do
       before do
-          @author_stub    = stub :name => 'weaver'
-          @directory_stub = stub :build_artifact_from_directory => '/tmp/build_dir',
-                                 :local_build                   => '/var/tmp/file.tar.gz'
+          @author_double    = double :name => 'weaver'
+          @directory_double = double :build_artifact_from_directory => '/tmp/build_dir',
+                                     :local_build                   => '/var/tmp/file.tar.gz'
 
           Heirloom::Directory.should_receive(:new).
                               with(:path    => 'path_to_build',
                                    :exclude => ['.dir_to_exclude'],
                                    :file    => '/tmp/file.tar.gz',
-                                   :config  => @config_mock).
-                              and_return @directory_stub
+                                   :config  => @config_double).
+                              and_return @directory_double
           @builder.should_receive(:create_artifact_record)
       end
 
     end
 
     it "should return false if the build fails" do
-      directory_stub = stub :build_artifact_from_directory => false
+      directory_double = double :build_artifact_from_directory => false
       Heirloom::Directory.should_receive(:new).with(:path    => 'path_to_build',
                                                     :exclude => ['.dir_to_exclude'],
                                                     :file    => '/tmp/file.tar.gz',
-                                                    :config  => @config_mock).
-                                               and_return directory_stub
+                                                    :config  => @config_double).
+                                               and_return directory_double
       @builder.build(:exclude   => ['.dir_to_exclude'],
                      :directory => 'path_to_build',
                      :file      => '/tmp/file.tar.gz').should be_false

data/spec/archive/checker_spec.rb

@@ -3,50 +3,50 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @config_mock = double 'config'
-    @logger_stub = stub 'logger', :debug => true, 
-                                  :info  => true,
-                                  :warn  => true
-    @config_mock.stub :logger => @logger_stub
-    @checker = Heirloom::Checker.new :config => @config_mock
+    @config_double = double 'config'
+    @logger_double = double 'logger', :debug => true,
+                                      :info  => true,
+                                      :warn  => true
+    @config_double.stub :logger => @logger_double
+    @checker = Heirloom::Checker.new :config => @config_double
     @regions = ['us-west-1', 'us-west-2']
   end
 
   it "should return true if all bucket names are available" do
-    s3_mock = mock 's3'
+    s3_double = double 's3'
     Heirloom::AWS::S3.should_receive(:new).
-                      with(:config => @config_mock,
+                      with(:config => @config_double,
                            :region => 'us-west-1').
-                      and_return s3_mock
+                      and_return s3_double
     Heirloom::AWS::S3.should_receive(:new).
-                      with(:config => @config_mock,
+                      with(:config => @config_double,
                            :region => 'us-west-2').
-                      and_return s3_mock
-    s3_mock.should_receive(:bucket_name_available?).
-            with('bp-us-west-1').
-            and_return true
-    s3_mock.should_receive(:bucket_name_available?).
-            with('bp-us-west-2').
-            and_return true
+                      and_return s3_double
+    s3_double.should_receive(:bucket_name_available?).
+              with('bp-us-west-1').
+              and_return true
+    s3_double.should_receive(:bucket_name_available?).
+              with('bp-us-west-2').
+              and_return true
     @checker.bucket_name_available?(:bucket_prefix => 'bp',
                                     :regions       => @regions).
                                    should be_true
   end
 
   it "should return false if any buckets are unavailable" do
-    s3_mock = mock 's3'
+    s3_double = double 's3'
     Heirloom::AWS::S3.should_receive(:new).
-                      with(:config => @config_mock,
+                      with(:config => @config_double,
                            :region => 'us-west-1').
-                      and_return s3_mock
+                      and_return s3_double
     Heirloom::AWS::S3.should_receive(:new).
-                      with(:config => @config_mock,
+                      with(:config => @config_double,
                            :region => 'us-west-2').
-                      and_return s3_mock
-    s3_mock.should_receive(:bucket_name_available?).
+                      and_return s3_double
+    s3_double.should_receive(:bucket_name_available?).
             with('bp-us-west-1').
             and_return false
-    s3_mock.should_receive(:bucket_name_available?).
+    s3_double.should_receive(:bucket_name_available?).
             with('bp-us-west-2').
             and_return true
     @checker.bucket_name_available?(:bucket_prefix => 'bp',

data/spec/archive/destroyer_spec.rb

@@ -3,37 +3,37 @@ require 'spec_helper'
 describe Heirloom do
 
     before do
-      @config_mock = double 'config'
-      @logger_stub = stub 'logger', :info => true, :debug => true
-      @config_mock.stub :logger => @logger_stub
-      @destroyer = Heirloom::Destroyer.new :config => @config_mock,
+      @config_double = double 'config'
+      @logger_double = double 'logger', :info => true, :debug => true
+      @config_double.stub :logger => @logger_double
+      @destroyer = Heirloom::Destroyer.new :config => @config_double,
                                            :name   => 'tim',
                                            :id     => '123'
     end
 
     before do
-      @reader_mock = mock 'archive reader'
-      @destroyer.stub :reader => @reader_mock
-      @reader_mock.should_receive(:get_bucket).
-                  with(:region => 'us-west-1').
-                  and_return 'bucket-us-west-1'
-      @reader_mock.stub :key_name => '123.tar.gz'
+      @reader_double = double 'archive reader'
+      @destroyer.stub :reader => @reader_double
+      @reader_double.should_receive(:get_bucket).
+                     with(:region => 'us-west-1').
+                     and_return 'bucket-us-west-1'
+      @reader_double.stub :key_name => '123.tar.gz'
 
-      @s3_destroyer_mock = mock 's3 destroyer'
+      @s3_destroyer_double = double 's3 destroyer'
       Heirloom::Destroyer::S3.should_receive(:new).
-                              with(:config => @config_mock,
+                              with(:config => @config_double,
                                    :region => 'us-west-1').
-                              and_return @s3_destroyer_mock
-      @s3_destroyer_mock.should_receive(:destroy_file).
-                        with :key_name   => '123.tar.gz',
-                             :key_folder => 'tim',
-                             :bucket     => 'bucket-us-west-1'
-      @sdb_mock = mock 'sdb'
-      @destroyer.stub :sdb => @sdb_mock
+                              and_return @s3_destroyer_double
+      @s3_destroyer_double.should_receive(:destroy_file).
+                           with :key_name   => '123.tar.gz',
+                                :key_folder => 'tim',
+                                :bucket     => 'bucket-us-west-1'
+      @sdb_double = double 'sdb'
+      @destroyer.stub :sdb => @sdb_double
     end
 
     it "should destroy the given archive" do
-      @sdb_mock.should_receive(:delete).with 'heirloom_tim', '123'
+      @sdb_double.should_receive(:delete).with 'heirloom_tim', '123'
       @destroyer.destroy :regions => ['us-west-1']
     end
 

data/spec/archive/downloader_spec.rb

@@ -3,42 +3,42 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @config_mock = mock 'config'
-    @logger_stub = mock 'logger', :info => true, :debug => true
-    @config_mock.stub :logger => @logger_stub
-    @downloader = Heirloom::Downloader.new :config => @config_mock,
+    @config_double = double 'config'
+    @logger_double = double 'logger', :info => true, :debug => true
+    @config_double.stub :logger => @logger_double
+    @downloader = Heirloom::Downloader.new :config => @config_double,
                                            :name   => 'tim',
                                            :id     => '123'
-    @s3_downloader_mock = mock 's3 downloader'
+    @s3_downloader_double = double 's3 downloader'
     Heirloom::Downloader::S3.should_receive(:new).
-                             with(:config => @config_mock,
-                                  :logger => @logger_stub,
+                             with(:config => @config_double,
+                                  :logger => @logger_double,
                                   :region => 'us-west-1').
-                             and_return @s3_downloader_mock
-    @cipher_mock = mock 'cipher'
+                             and_return @s3_downloader_double
+    @cipher_double = double 'cipher'
   end
 
   context "no secret given" do
     context "when succesful" do
       before do
-        @writer_mock = mock 'writer'
+        @writer_double = double 'writer'
         Heirloom::Writer.should_receive(:new).
-                         with(:config => @config_mock).
-                         and_return @writer_mock
-        @s3_downloader_mock.should_receive(:download_file).
+                         with(:config => @config_double).
+                         and_return @writer_double
+        @s3_downloader_double.should_receive(:download_file).
                             with(:bucket => 'bucket-us-west-1',
                                  :key    => 'tim/123.tar.gz').
                             and_return 'plaintext'
-        @cipher_mock.should_receive(:decrypt_data).
+        @cipher_double.should_receive(:decrypt_data).
                      with(:secret => nil,
                           :data   => 'plaintext').and_return 'plaintext'
         Heirloom::Cipher::Data.should_receive(:new).
-                               with(:config => @config_mock).
-                               and_return @cipher_mock
+                               with(:config => @config_double).
+                               and_return @cipher_double
       end
 
       it "should download to the current path if output is not specified" do
-        @writer_mock.should_receive(:save_archive).
+        @writer_double.should_receive(:save_archive).
                      with(:archive => 'plaintext',
                           :file    => "123.tar.gz",
                           :output  => './',
@@ -50,7 +50,7 @@ describe Heirloom do
       end
 
       it "should download arhcive to specified output" do
-        @writer_mock.should_receive(:save_archive).
+        @writer_double.should_receive(:save_archive).
                      with(:archive => 'plaintext',
                           :file    => "123.tar.gz",
                           :output  => '/tmp/dir',
@@ -65,7 +65,7 @@ describe Heirloom do
 
     context "when unsuccesful" do
       before do
-        @s3_downloader_mock.should_receive(:download_file).
+        @s3_downloader_double.should_receive(:download_file).
                             with(:bucket => 'bucket-us-west-1',
                                  :key    => 'tim/123.tar.gz').
                             and_return false
@@ -83,28 +83,28 @@ describe Heirloom do
 
   context "secret given" do
     before do
-      @s3_downloader_mock.should_receive(:download_file).
+      @s3_downloader_double.should_receive(:download_file).
                           with(:bucket => 'bucket-us-west-1',
                                :key    => 'tim/123.tar.gz.gpg').
                           and_return 'encrypted_data'
       Heirloom::Cipher::Data.should_receive(:new).
-                             with(:config => @config_mock).
-                             and_return @cipher_mock
+                             with(:config => @config_double).
+                             and_return @cipher_double
     end
 
     context "valid secret" do
       before do
-        @writer_mock = mock 'writer'
+        @writer_double = double 'writer'
         Heirloom::Writer.should_receive(:new).
-                         with(:config => @config_mock).
-                         and_return @writer_mock
-        @cipher_mock.should_receive(:decrypt_data).
+                         with(:config => @config_double).
+                         and_return @writer_double
+        @cipher_double.should_receive(:decrypt_data).
                      with(:secret => 'supersecret',
                           :data   => 'encrypted_data').and_return 'plaintext'
       end
 
       it "should decrypt and save the downloaded file with secret" do
-        @writer_mock.should_receive(:save_archive).
+        @writer_double.should_receive(:save_archive).
                      with(:archive => 'plaintext',
                           :file    => "123.tar.gz",
                           :output  => './',
@@ -116,7 +116,7 @@ describe Heirloom do
       end
 
       it "should decrypt and extract the downloaded file with secret" do
-        @writer_mock.should_receive(:save_archive).
+        @writer_double.should_receive(:save_archive).
                      with(:archive => 'plaintext',
                           :file    => "123.tar.gz",
                           :output  => './',
@@ -130,7 +130,7 @@ describe Heirloom do
 
     context "invalid secret" do
       before do
-        @cipher_mock.should_receive(:decrypt_data).
+        @cipher_double.should_receive(:decrypt_data).
                      with(:secret => 'badsecret',
                           :data   => 'encrypted_data').and_return false
       end
@@ -140,7 +140,7 @@ describe Heirloom do
                              :bucket_prefix => 'bucket',
                              :extract       => false,
                              :secret        => 'badsecret').should be_false
-      end 
+      end
 
     end
   end

data/spec/archive/lister_spec.rb

@@ -3,18 +3,18 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @config_mock = double 'config'
-    @lister = Heirloom::Lister.new :config => @config_mock,
+    @config_double = double 'config'
+    @lister = Heirloom::Lister.new :config => @config_double,
                                    :name     => 'test123'
   end
 
   it "should list the known archive" do
-    sdb_mock = mock 'sdb'
-    @lister.should_receive(:sdb).and_return sdb_mock
-    sdb_mock.should_receive(:select).
-             with("select * from `heirloom_test123` where built_at > '2000-01-01T00:00:00.000Z' \
+    sdb_double = double 'sdb'
+    @lister.should_receive(:sdb).and_return sdb_double
+    sdb_double.should_receive(:select).
+               with("select * from `heirloom_test123` where built_at > '2000-01-01T00:00:00.000Z' \
                  order by built_at desc limit 10").
-             and_return( {'1' => 'one', '2' => 'two', '3' => 'three'} )
+               and_return( {'1' => 'one', '2' => 'two', '3' => 'three'} )
     @lister.list.should == ['1', '2', '3']
   end
 

data/spec/archive/reader_spec.rb

@@ -3,113 +3,113 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @sdb_mock = mock 'sdb'
-    @config_mock = mock 'config'
-    @logger_stub = stub :debug => true
-    @config_mock.stub :logger => @logger_stub
-    @reader = Heirloom::Reader.new :config => @config_mock,
+    @sdb_double = double 'sdb'
+    @config_double = double 'config'
+    @logger_double = double :debug => true
+    @config_double.stub :logger => @logger_double
+    @reader = Heirloom::Reader.new :config => @config_double,
                                    :name   => 'tim',
                                    :id     => '123'
   end
 
   context "domain does exist" do
     before do
-      Heirloom::AWS::SimpleDB.stub :new => @sdb_mock
-      @sdb_mock.stub :domain_exists? => true
+      Heirloom::AWS::SimpleDB.stub :new => @sdb_double
+      @sdb_double.stub :domain_exists? => true
     end
 
     it "should show the item record" do
-      @sdb_mock.should_receive(:select).
-               with("select * from `heirloom_tim` where itemName() = '123'").
-               and_return( { '123' => { 'value' => [ 'details' ] } } )
+      @sdb_double.should_receive(:select).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return( { '123' => { 'value' => [ 'details' ] } } )
       @reader.show.should == { 'value' => 'details' }
     end
 
     it "should return an empty hash if item does not exist" do
-      @sdb_mock.should_receive(:select).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return({})
+      @sdb_double.should_receive(:select).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return({})
       @reader.show.should == {}
     end
 
     it "should return true if the record exists" do
-      @sdb_mock.should_receive(:select).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return( { '123' => { 'value' => [ 'details' ] } } )
+      @sdb_double.should_receive(:select).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return( { '123' => { 'value' => [ 'details' ] } } )
       @reader.exists?.should == true
     end
 
     it "should return false if the record does not exist" do
-      @sdb_mock.should_receive(:select).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return({})
+      @sdb_double.should_receive(:select).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return({})
       @reader.exists?.should == false
     end
 
     it "should return the bucket if it exists" do
-      @sdb_mock.should_receive(:select).
-                at_least(:once).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return( { '123' =>
-                              { 'us-west-1-s3-url' =>
-                                [ 's3://the-bucket/the-name/123.tar.gz' ]
-                              }
-                            } )
+      @sdb_double.should_receive(:select).
+                  at_least(:once).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return( { '123' =>
+                                { 'us-west-1-s3-url' =>
+                                  [ 's3://the-bucket/the-name/123.tar.gz' ]
+                                }
+                              } )
       @reader.get_bucket(:region => 'us-west-1').should == 'the-bucket'
     end
 
     it "should return nil if the key does not exist" do
-      @sdb_mock.should_receive(:select).
+      @sdb_double.should_receive(:select).
                 with("select * from `heirloom_tim` where itemName() = '123'").
                 and_return( { } )
       @reader.get_key(:region => 'us-west-1').should == nil
     end
 
     it "should return nil if the bucket does not exist" do
-      @sdb_mock.should_receive(:select).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return( { } )
+      @sdb_double.should_receive(:select).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return( { } )
       @reader.get_bucket(:region => 'us-west-1').should == nil
     end
 
     it "should return the key if it exists" do
-      @sdb_mock.should_receive(:select).
-                at_least(:once).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return( { '123' =>
-                              { 'us-west-1-s3-url' =>
-                                ['s3://the-url/the-bucket/123.tar.gz']
-                              }
-                            } )
+      @sdb_double.should_receive(:select).
+                  at_least(:once).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return( { '123' =>
+                                { 'us-west-1-s3-url' =>
+                                  ['s3://the-url/the-bucket/123.tar.gz']
+                                }
+                              } )
       @reader.get_key(:region => 'us-west-1').should == 'the-bucket/123.tar.gz'
     end
 
     it "should return the encrypted key name" do
-      @sdb_mock.should_receive(:select).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return( { '123' => { 'encrypted' => [ 'true' ] } } )
+      @sdb_double.should_receive(:select).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return( { '123' => { 'encrypted' => [ 'true' ] } } )
       @reader.key_name.should == '123.tar.gz.gpg'
     end
 
     it "should return the unencrypted key name" do
-      @sdb_mock.should_receive(:select).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return( { '123' => { 'encrypted' => [ 'false' ] } } )
+      @sdb_double.should_receive(:select).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return( { '123' => { 'encrypted' => [ 'false' ] } } )
       @reader.key_name.should == '123.tar.gz'
     end
 
     it "should return the regions the archive has been uploaded to" do
-      @sdb_mock.should_receive(:select).
-                with("select * from `heirloom_tim` where itemName() = '123'").
-                and_return( { '123' =>
-                              { 'us-west-1-s3-url' =>
-                                ['s3://the-url-us-west-1/the-bucket/123.tar.gz'],
-                                'build_by' =>
-                                ['user'],
-                                'us-east-1-s3-url' =>
-                                ['s3://the-url-us-east-1/the-bucket/123.tar.gz']
-                              }
-                            } )
+      @sdb_double.should_receive(:select).
+                  with("select * from `heirloom_tim` where itemName() = '123'").
+                  and_return( { '123' =>
+                                { 'us-west-1-s3-url' =>
+                                  ['s3://the-url-us-west-1/the-bucket/123.tar.gz'],
+                                  'build_by' =>
+                                  ['user'],
+                                  'us-east-1-s3-url' =>
+                                  ['s3://the-url-us-east-1/the-bucket/123.tar.gz']
+                                }
+                              } )
       @reader.regions.should == ['us-west-1', 'us-east-1']
     end
 
@@ -117,8 +117,8 @@ describe Heirloom do
 
   context "domain does not exist" do
     before do
-      Heirloom::AWS::SimpleDB.stub :new => @sdb_mock
-      @sdb_mock.stub :domain_exists? => false
+      Heirloom::AWS::SimpleDB.stub :new => @sdb_double
+      @sdb_double.stub :domain_exists? => false
     end
 
     it "should return false if the simpledb domain does not exist" do
@@ -129,11 +129,11 @@ describe Heirloom do
   context "object_acl verify" do
     it "should get object_acls" do
       regions = ['us-west-1', 'us-west-2']
-      @config_mock.stub :access_key => 'the-key',
-                        :secret_key => 'the-secret'
+      @config_double.stub :access_key => 'the-key',
+                          :secret_key => 'the-secret'
       @reader.stub :regions    => regions,
-                   :key_name   => 'mockvalue',
-                   :get_bucket => 'mockvalue'
+                   :key_name   => 'doublevalue',
+                   :get_bucket => 'doublevalue'
       data = { "Owner" => { "ID" => "123", "DisplayName" => "lc" },
                "AccessControlList" => [
                 { "Grantee" => { "ID" => "321", "DisplayName" => "rickybobby" },
@@ -141,13 +141,13 @@ describe Heirloom do
                 { "Grantee" => { "ID" => "123", "DisplayName" => "lc" },
                                  "Permission" => "FULL_CONTROL" }]
              }
-      s3_stub = stub 's3', :get_object_acl => data
+      s3_double = double 's3', :get_object_acl => data
 
       regions.each do |region|
         Heirloom::AWS::S3.should_receive(:new).
-                          with(:config => @config_mock,
+                          with(:config => @config_double,
                                :region => region).
-                          and_return s3_stub
+                          and_return s3_double
       end
 
       @reader.object_acls.should == { 'us-west-1-permissions' => 'rickybobby:read, lc:full_control',