heirloom 0.12.1 → 0.12.2

data/spec/archive/setup_spec.rb

@@ -3,37 +3,37 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @logger_stub = stub 'logger', :debug => true, :info => true
-    @config_mock = mock 'config'
-    @config_mock.stub :logger => @logger_stub, :metadata_region => 'us-west-1'
-    @verifier_mock = mock 'verifier'
+    @logger_double = double 'logger', :debug => true, :info => true
+    @config_double = double 'config'
+    @config_double.stub :logger => @logger_double, :metadata_region => 'us-west-1'
+    @verifier_double = double 'verifier'
     Heirloom::Verifier.should_receive(:new).
-                       with(:config => @config_mock,
+                       with(:config => @config_double,
                             :name   => 'archive').
-                       and_return @verifier_mock
-    @setuper = Heirloom::Setuper.new :config => @config_mock,
+                       and_return @verifier_double
+    @setuper = Heirloom::Setuper.new :config => @config_double,
                                      :name   => 'archive'
   end
 
   context "creating domains" do
     before do
-      @verifier_mock.stub :bucket_exists? => true
+      @verifier_double.stub :bucket_exists? => true
     end
 
     it "should create the domain if it does not exist" do
-      @sdb_mock = mock 'sdb'
+      @sdb_double = double 'sdb'
       Heirloom::AWS::SimpleDB.should_receive(:new).
-                              with(:config => @config_mock).
-                              and_return @sdb_mock
-      @verifier_mock.stub :domain_exists? => false
-      @sdb_mock.should_receive(:create_domain).with 'heirloom_archive'
+                              with(:config => @config_double).
+                              and_return @sdb_double
+      @verifier_double.stub :domain_exists? => false
+      @sdb_double.should_receive(:create_domain).with 'heirloom_archive'
       @setuper.setup :regions       => ['us-west-1'],
                      :bucket_prefix => 'bp'
-                     
+
     end
 
     it "should not create the domain if alrady exists" do
-      @verifier_mock.stub :domain_exists? => true
+      @verifier_double.stub :domain_exists? => true
       @setuper.setup :regions       => ['us-west-1'],
                      :bucket_prefix => 'bp'
     end
@@ -41,23 +41,23 @@ describe Heirloom do
 
   context "creating buckets" do
     before do
-      @verifier_mock.stub :domain_exists? => true
+      @verifier_double.stub :domain_exists? => true
     end
 
     it "should create required buckets that don't exist" do
-      @verifier_mock.should_receive(:bucket_exists?).
-                     with(:region => "us-west-1", :bucket_prefix => "bp").
-                     and_return true
-      @verifier_mock.should_receive(:bucket_exists?).
-                     with(:region => "us-east-1", :bucket_prefix => "bp").
-                     and_return false
-      @s3_mock = mock 's3'
+      @verifier_double.should_receive(:bucket_exists?).
+                       with(:region => "us-west-1", :bucket_prefix => "bp").
+                       and_return true
+      @verifier_double.should_receive(:bucket_exists?).
+                       with(:region => "us-east-1", :bucket_prefix => "bp").
+                       and_return false
+      @s3_double = double 's3'
       Heirloom::AWS::S3.should_receive(:new).
-                        with(:config => @config_mock,
+                        with(:config => @config_double,
                              :region => 'us-east-1').
-                        and_return @s3_mock
-      @s3_mock.should_receive(:put_bucket).
-               with 'bp-us-east-1', 'us-east-1'
+                        and_return @s3_double
+      @s3_double.should_receive(:put_bucket).
+                 with 'bp-us-east-1', 'us-east-1'
       @setuper.setup :regions       => ['us-west-1', 'us-east-1'],
                      :bucket_prefix => 'bp'
     end

data/spec/archive/teardowner_spec.rb

@@ -3,39 +3,39 @@ require 'spec_helper'
 describe Heirloom::Teardowner do
   before do
     @regions = ['us-west-1', 'us-west-2']
-    @logger_stub = stub 'logger', :info => true, :debug => true
-    @config_stub = stub 'config', :logger          => @logger_stub,
-                                  :metadata_region => 'us-west-1'
-    @verifier_stub = stub :bucket_exists? => true,
-                          :domain_exists? => true 
-    @teardowner = Heirloom::Teardowner.new :config => @config_stub,
+    @logger_double = double 'logger', :info => true, :debug => true
+    @config_double = double 'config', :logger          => @logger_double,
+                                      :metadata_region => 'us-west-1'
+    @verifier_double = double :bucket_exists? => true,
+                              :domain_exists? => true
+    @teardowner = Heirloom::Teardowner.new :config => @config_double,
                                            :name   => 'archive'
-    Heirloom::Verifier.stub :new => @verifier_stub
+    Heirloom::Verifier.stub :new => @verifier_double
   end
 
   it "should delete the buckets" do
-    @s3_mock1 = mock 's31'
-    @s3_mock2 = mock 's32'
+    @s3_double1 = double 's31'
+    @s3_double2 = double 's32'
     Heirloom::AWS::S3.should_receive(:new).
-                      with(:config => @config_stub,
+                      with(:config => @config_double,
                            :region => 'us-west-1').
-                      and_return @s3_mock1
+                      and_return @s3_double1
     Heirloom::AWS::S3.should_receive(:new).
-                      with(:config => @config_stub,
+                      with(:config => @config_double,
                            :region => 'us-west-2').
-                      and_return @s3_mock2
-    @s3_mock1.should_receive(:delete_bucket).with('bp-us-west-1')
-    @s3_mock2.should_receive(:delete_bucket).with('bp-us-west-2')
+                      and_return @s3_double2
+    @s3_double1.should_receive(:delete_bucket).with('bp-us-west-1')
+    @s3_double2.should_receive(:delete_bucket).with('bp-us-west-2')
     @teardowner.delete_buckets :regions       => @regions,
                                :bucket_prefix => 'bp'
   end
 
   it "should delete the domain" do
-    @sdb_mock = mock 'sdb'
+    @sdb_double = double 'sdb'
     Heirloom::AWS::SimpleDB.should_receive(:new).
-                            with(:config => @config_stub).
-                            and_return @sdb_mock
-    @sdb_mock.should_receive(:delete_domain).
+                            with(:config => @config_double).
+                            and_return @sdb_double
+    @sdb_double.should_receive(:delete_domain).
               with 'heirloom_archive'
     @teardowner.delete_domain
   end

data/spec/archive/updater_spec.rb

@@ -3,22 +3,22 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @config_mock = double 'config'
-    @logger_mock = double 'logger'
-    @config_mock.should_receive(:logger).and_return(@logger_mock)
-    @updater = Heirloom::Updater.new :config => @config_mock,
+    @config_double = double 'config'
+    @logger_double = double 'logger'
+    @config_double.should_receive(:logger).and_return(@logger_double)
+    @updater = Heirloom::Updater.new :config => @config_double,
                                      :name   => 'tim',
                                      :id     => '123'
   end
 
   it "should test an attribute is updated" do
-    sdb_mock = mock 'sdb mock'
-    @logger_mock.should_receive(:info)
+    sdb_double = double 'sdb mock'
+    @logger_double.should_receive(:info)
     Heirloom::AWS::SimpleDB.should_receive(:new).
-                            with(:config => @config_mock).
-                            and_return sdb_mock
-    sdb_mock.should_receive(:put_attributes).
-             with('heirloom_tim', '123', { 'attr' => 'val' }, { :replace => 'attr' })
+                            with(:config => @config_double).
+                            and_return sdb_double
+    sdb_double.should_receive(:put_attributes).
+               with('heirloom_tim', '123', { 'attr' => 'val' }, { :replace => 'attr' })
     @updater.update :attribute => 'attr',
                     :value     => 'val'
   end

data/spec/archive/uploader_spec.rb

@@ -3,22 +3,22 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @config_mock = mock 'config'
-    @logger_stub = stub 'logger', :info => true
-    @config_mock.stub :logger => @logger_stub
-    @uploader = Heirloom::Uploader.new :config => @config_mock,
+    @config_double = double 'config'
+    @logger_double = double 'logger', :info => true
+    @config_double.stub :logger => @logger_double
+    @uploader = Heirloom::Uploader.new :config => @config_double,
                                        :name   => 'tim',
                                        :id     => '123'
-    @s3_mock = mock 's3'
+    @s3_double = double 's3'
   end
 
   it "should upload a new archive" do
     Heirloom::Uploader::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_mock
-    @s3_mock.should_receive(:upload_file).
+                           and_return @s3_double
+    @s3_double.should_receive(:upload_file).
              with(:bucket          => 'prefix-us-west-1',
                   :file            => '/tmp/file',
                   :id              => '123',
@@ -26,7 +26,7 @@ describe Heirloom do
                   :key_name        => "123.tar.gz",
                   :name            => 'tim',
                   :public_readable => true)
-    @s3_mock.should_receive(:add_endpoint_attributes).
+    @s3_double.should_receive(:add_endpoint_attributes).
              with(:bucket   => 'prefix-us-west-1',
                   :id       => '123',
                   :key_name => '123.tar.gz',
@@ -40,23 +40,23 @@ describe Heirloom do
 
   it "should upload a new archive with .gpg if secret provided" do
     Heirloom::Uploader::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_mock
-    @s3_mock.should_receive(:upload_file).
-             with(:bucket          => 'prefix-us-west-1',
-                  :file            => '/tmp/file',
-                  :id              => '123',
-                  :key_folder      => 'tim',
-                  :key_name        => "123.tar.gz.gpg",
-                  :name            => 'tim',
-                  :public_readable => true)
-    @s3_mock.should_receive(:add_endpoint_attributes).
-             with(:bucket   => 'prefix-us-west-1',
-                  :id       => '123',
-                  :key_name => '123.tar.gz.gpg',
-                  :name     => 'tim')
+                           and_return @s3_double
+    @s3_double.should_receive(:upload_file).
+               with(:bucket          => 'prefix-us-west-1',
+                    :file            => '/tmp/file',
+                    :id              => '123',
+                    :key_folder      => 'tim',
+                    :key_name        => "123.tar.gz.gpg",
+                    :name            => 'tim',
+                    :public_readable => true)
+    @s3_double.should_receive(:add_endpoint_attributes).
+               with(:bucket   => 'prefix-us-west-1',
+                    :id       => '123',
+                    :key_name => '123.tar.gz.gpg',
+                    :name     => 'tim')
     @uploader.upload :file            => '/tmp/file',
                      :bucket_prefix   => 'prefix',
                      :regions         => ['us-west-1'],

data/spec/archive/verifier_spec.rb

@@ -3,41 +3,41 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @config_mock = double 'config'
-    @logger_stub = stub 'logger', :debug => true, :info => true
-    @s3_mock = double 's3_mock'
-    @config_mock.stub :logger => @logger_stub
-    @verifier = Heirloom::Verifier.new :config => @config_mock,
+    @config_double = double 'config'
+    @logger_double = double 'logger', :debug => true, :info => true
+    @s3_double = double 's3_double'
+    @config_double.stub :logger => @logger_double
+    @verifier = Heirloom::Verifier.new :config => @config_double,
                                        :name   => 'heirloom-name'
   end
 
   context "verifying all buckets exist" do
     before do
       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-east-1').
-                        and_return @s3_mock
+                        and_return @s3_double
     end
 
     it "should return false if a bucket does not exist in a region" do
-      @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
-               and_return nil
-      @s3_mock.should_receive(:get_bucket).with('bucket123-us-east-1').
-               and_return 'an s3 bucket'
+      @s3_double.should_receive(:get_bucket).with('bucket123-us-west-1').
+                 and_return nil
+      @s3_double.should_receive(:get_bucket).with('bucket123-us-east-1').
+                 and_return 'an s3 bucket'
       @verifier.buckets_exist?(:bucket_prefix => 'bucket123',
                                :regions       => ['us-west-1', 'us-east-1']).
                 should be_false
     end
 
     it "should true if all buckets exist" do
-      @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
-               and_return 'an s3 bucket'
-      @s3_mock.should_receive(:get_bucket).with('bucket123-us-east-1').
-               and_return 'an s3 bucket'
+      @s3_double.should_receive(:get_bucket).with('bucket123-us-west-1').
+                 and_return 'an s3 bucket'
+      @s3_double.should_receive(:get_bucket).with('bucket123-us-east-1').
+                 and_return 'an s3 bucket'
       @verifier.buckets_exist?(:bucket_prefix => 'bucket123',
                                :regions       => ['us-west-1', 'us-east-1']).
                 should be_true
@@ -47,22 +47,22 @@ describe Heirloom do
   context "verifying a single bucket exist" do
     it "should return true if the given bucket does not exist in the region" do
       Heirloom::AWS::S3.should_receive(:new).
-                        with(:config => @config_mock,
+                        with(:config => @config_double,
                              :region => 'us-west-1').
-                        and_return @s3_mock
-      @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
-               and_return 'an s3 bucket'
+                        and_return @s3_double
+      @s3_double.should_receive(:get_bucket).with('bucket123-us-west-1').
+                 and_return 'an s3 bucket'
       @verifier.bucket_exists?(:bucket_prefix => 'bucket123',
                                :region        => 'us-west-1').should be_true
     end
 
     it "should return false if the given bucket does not exist in the region" do
       Heirloom::AWS::S3.should_receive(:new).
-                        with(:config => @config_mock,
+                        with(:config => @config_double,
                              :region => 'us-west-1').
-                        and_return @s3_mock
-      @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
-               and_return 'an s3 bucket'
+                        and_return @s3_double
+      @s3_double.should_receive(:get_bucket).with('bucket123-us-west-1').
+                 and_return 'an s3 bucket'
       @verifier.bucket_exists?(:bucket_prefix => 'bucket123',
                                :region        => 'us-west-1').should be_true
     end

data/spec/archive/writer_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @logger_mock = mock 'logger'
-    @logger_mock.stub :info => true, :debug => true
-    @config_mock = mock 'config'
-    @config_mock.stub :logger => @logger_mock
-    @tempfile_stub = stub 'tempfile', :path => '/tmp/tempfile'
-    Tempfile.stub :new => @tempfile_stub
-    @writer = Heirloom::Writer.new :config => @config_mock
+    @logger_double = double 'logger'
+    @logger_double.stub :info => true, :debug => true
+    @config_double = double 'config'
+    @config_double.stub :logger => @logger_double
+    @tempfile_double = double 'tempfile', :path => '/tmp/tempfile'
+    Tempfile.stub :new => @tempfile_double
+    @writer = Heirloom::Writer.new :config => @config_double
   end
 
   context "extract is set to true" do
@@ -18,7 +18,7 @@ describe Heirloom do
       Heirloom::Writer.any_instance.should_receive(:`).
                        with('tar xzf /tmp/tempfile -C /output')
       $?.stub :success? => true
-      @writer.save_archive(:archive => 'archive_data', 
+      @writer.save_archive(:archive => 'archive_data',
                            :output  => '/output',
                            :file    => 'id.tar.gz',
                            :extract => true).should be_true
@@ -29,8 +29,8 @@ describe Heirloom do
       Heirloom::Writer.any_instance.should_receive(:`).
                        with('tar xzf /tmp/tempfile -C /output')
       $?.stub :success? => false
-      @logger_mock.should_receive(:error)
-      @writer.save_archive(:archive => 'archive_data', 
+      @logger_double.should_receive(:error)
+      @writer.save_archive(:archive => 'archive_data',
                            :output  => '/output',
                            :file    => 'id.tar.gz',
                            :extract => true).should be_false
@@ -41,7 +41,7 @@ describe Heirloom do
     it "should save the given archive object into the output directory" do
       File.should_receive(:open).with('/output/id.tar.gz', 'w').
            and_return true
-      @writer.save_archive :archive => 'archive_data', 
+      @writer.save_archive :archive => 'archive_data',
                            :output  => '/output',
                            :file    => 'id.tar.gz',
                            :extract => false

data/spec/archive_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Heirloom do
 
   before do
-    @logger_mock = mock 'logger', :info => true, :debug => true, :error => true
-    @config_mock = mock 'config', :logger => @logger_mock
-    @archive = Heirloom::Archive.new :config => @config_mock,
+    @logger_double = double 'logger', :info => true, :debug => true, :error => true
+    @config_double = double 'config', :logger => @logger_mock
+    @archive = Heirloom::Archive.new :config => @config_double,
                                      :name   => 'chef',
                                      :id     => '123'
   end
@@ -14,212 +14,210 @@ describe Heirloom do
   context "test public methods" do
 
     it "should call build with given args" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Builder.should_receive(:new).
-                        with(:config => @config_mock,
+                        with(:config => @config_double,
                              :name   => 'chef',
                              :id     => '123').
-                        and_return mock
-      mock.should_receive(:build).with('args')
+                        and_return double
+      double.should_receive(:build).with('args')
       @archive.build('args')
     end
 
     it "should call download method with given args" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Downloader.should_receive(:new).
-                           with(:config => @config_mock,
+                           with(:config => @config_double,
                                 :name   => 'chef',
                                 :id     => '123').
-                           and_return mock
-      mock.should_receive(:download).with('args')
+                           and_return double
+      double.should_receive(:download).with('args')
       @archive.download('args')
     end
 
     it "should call update archive method with given args" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Updater.should_receive(:new).
-                        with(:config => @config_mock,
+                        with(:config => @config_double,
                              :name   => 'chef',
                              :id     => '123').
-                        and_return mock
-      mock.should_receive(:update).with('args')
+                        and_return double
+      double.should_receive(:update).with('args')
       @archive.update('args')
     end
 
     it "should call upload archive method with given args" do
-      mock = double('Mock')
-      reader_mock = double('reader mock')
+      double = double('Mock')
+      reader_double = double('reader double')
       Heirloom::Reader.should_receive(:new).
-                          with(:config => @config_mock,
+                          with(:config => @config_double,
                                :name   => 'chef',
                                :id     => '123').
-                          and_return reader_mock
-      reader_mock.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
+                          and_return reader_double
+      reader_double.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
       Heirloom::Uploader.should_receive(:new).
-                         with(:config => @config_mock,
+                         with(:config => @config_double,
                               :name   => 'chef',
                               :id     => '123').
-                         and_return mock
-      mock.should_receive(:upload).with('arg' => 'val', :regions => ['us-west-1', 'us-west-2'])
+                         and_return double
+      double.should_receive(:upload).with('arg' => 'val', :regions => ['us-west-1', 'us-west-2'])
       @archive.upload('arg' => 'val')
     end
 
     it "should call authorize method" do
-      mock = double('Mock')
-      reader_mock = double('reader mock')
+      double = double('Mock')
+      reader_double = double('reader double')
       Heirloom::Reader.should_receive(:new).
-                          with(:config => @config_mock,
+                          with(:config => @config_double,
                                :name   => 'chef',
                                :id     => '123').
-                          and_return reader_mock
-      reader_mock.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
+                          and_return reader_double
+      reader_double.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
       Heirloom::Authorizer.should_receive(:new).
-                           with(:config => @config_mock,
+                           with(:config => @config_double,
                                 :name   => 'chef',
                                 :id     => '123').
-                           and_return mock
-      mock.should_receive(:authorize).with :regions  => ['us-west-1', 'us-west-2'],
-                                           :accounts => ['acct1', 'acct2']
+                           and_return double
+      double.should_receive(:authorize).with :regions  => ['us-west-1', 'us-west-2'],
+                                             :accounts => ['acct1', 'acct2']
       @archive.authorize ['acct1', 'acct2']
     end
 
     it "should call archive exists method and return true if archive exists" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Reader.should_receive(:new).
-                       with(:config => @config_mock,
+                       with(:config => @config_double,
                             :name   => 'chef',
                             :id     => '123').
-                       and_return mock
-      mock.should_receive(:exists?).and_return true
+                       and_return double
+      double.should_receive(:exists?).and_return true
       @archive.exists?.should be_true
     end
 
     it "should call archive exists method and return fasle if archive doesnt exists" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Reader.should_receive(:new).
-                       with(:config => @config_mock,
+                       with(:config => @config_double,
                             :name   => 'chef',
                             :id     => '123').
-                       and_return mock
-      mock.should_receive(:exists?).and_return false
+                       and_return double
+      double.should_receive(:exists?).and_return false
       @archive.exists?.should be_false
     end
 
     it "should call show method"  do
-      reader_mock = mock 'reader' 
+      reader_double = double 'reader'
       show_data = { 'id'               => '0.0.7',
                     'encrypted'        => 'true',
                     'bucket_prefix'    => 'rickybobby',
-                    'us-west-2-s3-url' => 's3://rickybobby-us-west-2/demo2/0.0.7.tar.gz.gpg'
-                  }
+                    'us-west-2-s3-url' => 's3://rickybobby-us-west-2/demo2/0.0.7.tar.gz.gpg' }
       object_acls_data = { 'us-west-2-perms' => 'rickybobby:read, lc:full_control',
-                           'us-west-1-perms' => 'rickybobby:read, lc:full_control'
-                         }
+                           'us-west-1-perms' => 'rickybobby:read, lc:full_control' }
       merge_data = show_data.merge object_acls_data
- 
+
       Heirloom::Reader.should_receive(:new).
-                        with(:config => @config_mock,
+                        with(:config => @config_double,
                              :name   => 'chef',
                              :id     => '123').
-                        and_return reader_mock
- 
-      reader_mock.stub(:show).and_return(show_data)
-      reader_mock.stub(:object_acls).and_return(object_acls_data)
+                        and_return reader_double
+
+      reader_double.stub(:show).and_return(show_data)
+      reader_double.stub(:object_acls).and_return(object_acls_data)
       @archive.show.should == merge_data
     end
 
     it "should call list method" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Lister.should_receive(:new).
-                       with(:config => @config_mock,
+                       with(:config => @config_double,
                             :name   => 'chef').
-                       and_return mock
-      mock.should_receive(:list)
+                       and_return double
+      double.should_receive(:list)
       @archive.list
     end
 
     it "should return true if the required buckets exist" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Verifier.should_receive(:new).
-                         with(:config => @config_mock,
+                         with(:config => @config_double,
                               :name   => 'chef').
-                         and_return mock
-      mock.should_receive(:buckets_exist?).
-           with(:bucket_prefix => 'test-123').and_return true
+                         and_return double
+      double.should_receive(:buckets_exist?).
+             with(:bucket_prefix => 'test-123').and_return true
       @archive.buckets_exist?(:bucket_prefix => 'test-123').
                should be_true
     end
 
     it "should return false if the required buckets don't exist" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Verifier.should_receive(:new).
-                         with(:config => @config_mock,
+                         with(:config => @config_double,
                               :name   => 'chef').
-                         and_return mock
-      mock.should_receive(:buckets_exist?).
-           with(:bucket_prefix => 'test-123').and_return false
+                         and_return double
+      double.should_receive(:buckets_exist?).
+             with(:bucket_prefix => 'test-123').and_return false
       @archive.buckets_exist?(:bucket_prefix => 'test-123').
                should be_false
     end
 
     it "should call the destroy method" do
-      destroyer_mock = double('destroyer mock')
-      reader_mock = double('reader mock')
+      destroyer_double = double('destroyer double')
+      reader_double = double('reader double')
       Heirloom::Reader.should_receive(:new).
-                          with(:config => @config_mock,
+                          with(:config => @config_double,
                                :name   => 'chef',
                                :id     => '123').
-                          and_return reader_mock
-      reader_mock.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
+                          and_return reader_double
+      reader_double.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
       Heirloom::Destroyer.should_receive(:new).
-                          with(:config  => @config_mock,
+                          with(:config  => @config_double,
                                :name    => 'chef',
                                :id      => '123').
-                          and_return destroyer_mock
-      destroyer_mock.should_receive(:destroy).
-                     with :regions => ['us-west-1', 'us-west-2']
+                          and_return destroyer_double
+      destroyer_double.should_receive(:destroy).
+                       with :regions => ['us-west-1', 'us-west-2']
       @archive.destroy
     end
 
     it "should call the regions method for an archive" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Reader.should_receive(:new).
-                          with(:config => @config_mock,
+                          with(:config => @config_double,
                                :name   => 'chef',
                                :id     => '123').
-                          and_return mock
-      mock.should_receive(:regions)
+                          and_return double
+      double.should_receive(:regions)
       @archive.regions
     end
 
     it "should call the count method for an archive" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Reader.should_receive(:new).
-                          with(:config => @config_mock,
+                          with(:config => @config_double,
                                :name   => 'chef',
                                :id     => '123').
-                          and_return mock
-      mock.should_receive(:count)
+                          and_return double
+      double.should_receive(:count)
       @archive.count
     end
 
     it "should call the delete_buckets on teardowner" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Teardowner.should_receive(:new).
-                            with(:config => @config_mock,
+                            with(:config => @config_double,
                                  :name   => 'chef').
-                          and_return mock
-      mock.should_receive(:delete_buckets).with :regions => ['us-west-1']
+                          and_return double
+      double.should_receive(:delete_buckets).with :regions => ['us-west-1']
       @archive.delete_buckets :regions => ['us-west-1']
     end
     
     it "should call the delete_domain on teardowner" do
-      mock = double('Mock')
+      double = double('Mock')
       Heirloom::Teardowner.should_receive(:new).
-                            with(:config => @config_mock,
+                            with(:config => @config_double,
                                  :name   => 'chef').
-                          and_return mock
-      mock.should_receive(:delete_domain)
+                          and_return double
+      double.should_receive(:delete_domain)
       @archive.delete_domain
     end
 
@@ -231,7 +229,7 @@ describe Heirloom do
       @tmp_dir = '/path/to/temp/dir'
       Dir.stub(:mktmpdir).and_return @tmp_dir
 
-      @tmp_file = mock 'file'
+      @tmp_file = double 'file'
       @tmp_file.stub :path => '/path/to/tmp/file', :close! => true
       Tempfile.stub :new => @tmp_file
       FileUtils.stub :remove_entry => true
@@ -263,7 +261,7 @@ describe Heirloom do
       before do
         @archive.stub :download => false, :build => true, :destroy => nil, :upload => true
       end
-      
+
       it "should raise an exception when download fails" do
         expect {
           @archive.rotate({ :new_secret => "new", :old_secret => "old" }) 
@@ -285,7 +283,7 @@ describe Heirloom do
       before do
         @archive.stub :download => true, :build => false, :destroy => nil, :upload => true
       end
-      
+
       it "should raise an exception when build fails" do
         expect {
           @archive.rotate({ :new_secret => "new", :old_secret => "old" })