heirloom 0.12.1 → 0.12.2

data/spec/cli/rotate_spec.rb

@@ -14,19 +14,19 @@ describe Heirloom do
                 :aws_secret_key => 'secret' }
     Trollop.stub(:options).and_return options
 
-    catalog_stub = stub :regions => ['us-east-1', 'us-west-1']
-    Heirloom::Catalog.stub(:new).and_return catalog_stub
+    catalog_double = double :regions => ['us-east-1', 'us-west-1']
+    Heirloom::Catalog.stub(:new).and_return catalog_double
 
-    @archive_mock = mock 'archive'
-    @logger_mock = mock_log
-    Heirloom::HeirloomLogger.stub :new => @logger_mock
-    Heirloom::Archive.stub(:new).and_return @archive_mock
+    @archive_double = double 'archive'
+    @logger_double  = double_log
+    Heirloom::HeirloomLogger.stub :new => @logger_double
+    Heirloom::Archive.stub(:new).and_return @archive_double
 
   end
 
   it "should delegate to archive object" do
 
-    @archive_mock.should_receive :rotate
+    @archive_double.should_receive :rotate
 
     Heirloom::CLI::Rotate.new.rotate
 
@@ -34,9 +34,9 @@ describe Heirloom do
 
   it "should log and do a SystemExit when a rotate fails" do
     
-    @archive_mock.stub(:rotate).and_raise Heirloom::Exceptions::RotateFailed.new("failed")
+    @archive_double.stub(:rotate).and_raise Heirloom::Exceptions::RotateFailed.new("failed")
 
-    @logger_mock.should_receive(:error).with "failed"
+    @logger_double.should_receive(:error).with "failed"
     expect {
       Heirloom::CLI::Rotate.new.rotate
     }.to raise_error SystemExit

data/spec/cli/setup_spec.rb

@@ -11,48 +11,48 @@ describe Heirloom do
                 :name            => 'archive_name',
                 :metadata_region => 'us-west-1' }
 
-    @logger_stub = stub 'logger', :error => true, :info => true
-    @config_mock = mock_config :logger => @logger_stub
-    @archive_mock = mock 'archive'
-    @catalog_mock = mock 'catalog'
-    @checker_mock = mock 'checker'
+    @logger_double  = double 'logger', :error => true, :info => true
+    @config_double  = double_config :logger => @logger_double
+    @archive_double = double 'archive'
+    @catalog_double = double 'catalog'
+    @checker_double = double 'checker'
     Trollop.stub(:options).and_return options
     Heirloom::HeirloomLogger.should_receive(:new).with(:log_level => 'info').
-                             and_return @logger_stub
+                             and_return @logger_double
     Heirloom::CLI::Setup.any_instance.should_receive(:load_config).
-                         with(:logger => @logger_stub,
+                         with(:logger => @logger_double,
                                :opts   => options).
-                          and_return @config_mock
+                         and_return @config_double
     Heirloom::Archive.should_receive(:new).
                       with(:name => 'archive_name',
-                           :config => @config_mock).
-                      and_return @archive_mock
+                           :config => @config_double).
+                      and_return @archive_double
     Heirloom::Catalog.should_receive(:new).
                       with(:name => 'archive_name',
-                           :config => @config_mock).
-                      and_return @catalog_mock
+                           :config => @config_double).
+                      and_return @catalog_double
     Heirloom::Checker.should_receive(:new).
-                      with(:config => @config_mock).
-                      and_return @checker_mock
+                      with(:config => @config_double).
+                      and_return @checker_double
     @setup = Heirloom::CLI::Setup.new
   end
 
   it "should setup s3 buckets, catalog and simpledb domain" do
-    @checker_mock.should_receive(:bucket_name_available?).
-                  with(:bucket_prefix => "bp", 
-                       :regions       => @regions, 
-                       :config        => @config_mock).
-                  and_return true
-    @catalog_mock.should_receive(:create_catalog_domain)
-    @catalog_mock.stub :entry_exists_in_catalog? => false
-    @catalog_mock.should_receive(:add_to_catalog).
-                  with(:regions       => @regions, 
-                       :bucket_prefix => 'bp').
-                  and_return true
-    @archive_mock.should_receive(:setup).
-                  with(:regions       => @regions,
-                       :bucket_prefix => 'bp')
-    @setup.setup 
+    @checker_double.should_receive(:bucket_name_available?).
+                    with(:bucket_prefix => "bp",
+                         :regions       => @regions,
+                         :config        => @config_double).
+                    and_return true
+    @catalog_double.should_receive(:create_catalog_domain)
+    @catalog_double.stub :entry_exists_in_catalog? => false
+    @catalog_double.should_receive(:add_to_catalog).
+                    with(:regions       => @regions,
+                         :bucket_prefix => 'bp').
+                    and_return true
+    @archive_double.should_receive(:setup).
+                    with(:regions       => @regions,
+                         :bucket_prefix => 'bp')
+    @setup.setup
   end
 
 end

data/spec/cli/shared_spec.rb

@@ -7,104 +7,104 @@ describe Heirloom do
   context "testing ensure_valid_options" do
 
     before do
-      @logger_mock = mock 'logger'
-      @config_mock = mock_config(:logger => @logger_mock)
+      @logger_double = double 'logger'
+      @config_double = double_config(:logger => @logger_double)
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should exit if the secret is given and under 8 characters" do
-      @logger_mock.should_receive(:error)
-      @logger_mock.stub :info => true
+      @logger_double.should_receive(:error)
+      @logger_double.stub :info => true
       lambda { @object.ensure_valid_secret(:secret => 'shorty',
-                                           :config => @config_mock) }.
+                                           :config => @config_double) }.
                        should raise_error SystemExit
     end
 
     it "should return false if a required array is emtpy" do
-      @logger_mock.should_receive(:error)
+      @logger_double.should_receive(:error)
       lambda { @object.ensure_valid_options(:provided => {
                                               :array  => [],
                                               :string => 'present'
                                             },
                                             :required => [:array, :string],
-                                            :config   => @config_mock) }.
+                                            :config   => @config_double) }.
                        should raise_error SystemExit
     end
 
     it "should return false if a required string is nil" do
-      @logger_mock.should_receive(:error)
+      @logger_double.should_receive(:error)
       lambda { @object.ensure_valid_options(:provided => {
                                               :array  => ['present'],
                                               :string => nil
                                             },
                                             :required => [:array, :string],
-                                            :config   => @config_mock) }.
+                                            :config   => @config_double) }.
                        should raise_error SystemExit
     end
 
     it "should return false if a require string is nil & array is empty" do
-      @logger_mock.should_receive(:error).exactly(2).times
+      @logger_double.should_receive(:error).exactly(2).times
       lambda { @object.ensure_valid_options(:provided => {
                                               :array  => [],
                                               :string => nil
                                             },
                                             :required => [:array, :string],
-                                            :config   => @config_mock) }.
+                                            :config   => @config_double) }.
                        should raise_error SystemExit
     end
 
     it "should return true if all options are present" do
-      @logger_mock.should_receive(:error).exactly(0).times
+      @logger_double.should_receive(:error).exactly(0).times
       @object.ensure_valid_options(:provided => { :array  => ['present'],
-                                            :string => 'present' },
-                             :required => [:array, :string],
-                             :config   => @config_mock)
+                                                  :string => 'present' },
+                                   :required => [:array, :string],
+                                   :config   => @config_double)
     end
   end
 
   context "testing load_config" do
 
     before do
-      @config_mock = mock 'config'
-      @logger_stub = stub 'logger', :debug => true
+      @config_double = double 'config'
+      @logger_double = double 'logger', :debug => true
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
-      Heirloom::Config.should_receive(:new).with(:logger => @logger_stub, :environment => nil).
-                       and_return @config_mock
-      @config_mock.stub :proxy => nil
+      Heirloom::Config.should_receive(:new).with(:logger => @logger_double, :environment => nil).
+                       and_return @config_double
+      @config_double.stub :proxy => nil
     end
 
     it "should return the configuration" do
-      @object.load_config(:logger => @logger_stub,
-                          :opts => {}).should == @config_mock
+      @object.load_config(:logger => @logger_double,
+                          :opts => {}).should == @config_double
     end
 
     it "should set the metadata region if specified" do
       opts = { :metadata_region => 'us-west-1' }
-      @config_mock.should_receive(:metadata_region=).with 'us-west-1'
-      @object.load_config :logger => @logger_stub, :opts => opts
+      @config_double.should_receive(:metadata_region=).with 'us-west-1'
+      @object.load_config :logger => @logger_double, :opts => opts
     end
 
     it "should set the access key if specified" do
       opts = { :aws_access_key => 'the_key' }
-      @config_mock.should_receive(:access_key=).with 'the_key'
-      @object.load_config :logger => @logger_stub, :opts => opts
+      @config_double.should_receive(:access_key=).with 'the_key'
+      @object.load_config :logger => @logger_double, :opts => opts
     end
 
     it "should set the secret key if specified" do
       opts = { :aws_secret_key => 'the_secret' }
-      @config_mock.should_receive(:secret_key=).with 'the_secret'
-      @object.load_config :logger => @logger_stub, :opts => opts
+      @config_double.should_receive(:secret_key=).with 'the_secret'
+      @object.load_config :logger => @logger_double, :opts => opts
     end
 
   end
 
   context "test ensure directory" do
     before do
-      @logger_stub = stub 'logger', :error => true
-      @config_mock = mock 'config'
-      @config_mock.stub :logger => @logger_stub
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config'
+      @config_double.stub :logger => @logger_double
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
@@ -113,48 +113,48 @@ describe Heirloom do
       File.should_receive(:directory?).with('/tmp/test').
                                        and_return false
       lambda { @object.ensure_path_is_directory(:path => '/tmp/test',
-                                                :config => @config_mock) }.
+                                                :config => @config_double) }.
                        should raise_error SystemExit
     end
 
     it "should not exit when path is a directory" do
       File.should_receive(:directory?).with('/tmp/test').
                                        and_return true
-      @object.ensure_path_is_directory :path => '/tmp/test', :config => @config_mock
+      @object.ensure_path_is_directory :path => '/tmp/test', :config => @config_double
     end
 
     it "should exit when directory is not writable" do
       File.should_receive(:writable?).with('/tmp/test').
                                        and_return false
       lambda { @object.ensure_directory_is_writable(:path => '/tmp/test',
-                                                    :config => @config_mock) }.
+                                                    :config => @config_double) }.
                        should raise_error SystemExit
     end
 
     it "should not exit when directory is writable" do
       File.should_receive(:writable?).with('/tmp/test').
-                                       and_return true
-      @object.ensure_directory_is_writable :path => '/tmp/test', :config => @config_mock
+                                      and_return true
+      @object.ensure_directory_is_writable :path => '/tmp/test', :config => @config_double
     end
 
   end
 
   context "testing ensure domain" do
     before do
-      @archive_mock = mock 'archive'
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @archive_double = double 'archive'
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
       Heirloom::Archive.should_receive(:new).
-                        with(:name => 'test', :config => @config_stub).
-                        and_return @archive_mock
+                        with(:name => 'test', :config => @config_double).
+                        and_return @archive_double
     end
 
     it "should exit if the domain does not exist" do
-      @archive_mock.stub :domain_exists? => false
-      lambda { @object.ensure_domain_exists :config => @config_stub,
+      @archive_double.stub :domain_exists? => false
+      lambda { @object.ensure_domain_exists :config => @config_double,
                                             :name   => 'test'}.
                        should raise_error SystemExit
     end
@@ -162,16 +162,16 @@ describe Heirloom do
 
   context "testing ensure metadata domain" do
     before do
-      @archive_mock = mock 'archive'
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @archive_double = double 'archive'
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should exit if the metadata region is not in an upload region" do
-      options = { :config => @config_stub, :regions => ['us-west-2', 'us-east-1'] }
+      options = { :config => @config_double, :regions => ['us-west-2', 'us-east-1'] }
       lambda { @object.ensure_metadata_in_upload_region options }.
                        should raise_error SystemExit
     end
@@ -179,15 +179,15 @@ describe Heirloom do
 
   context "testing ensure valid regions" do
     before do
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should exit if the region is not valid" do
-      options = { :config => @config_stub, :regions => ['us-west-2', 'us-bad-1'] }
+      options = { :config => @config_double, :regions => ['us-west-2', 'us-bad-1'] }
       lambda { @object.ensure_valid_regions options }.
                        should raise_error SystemExit
     end
@@ -196,17 +196,17 @@ describe Heirloom do
 
   context "testing ensure archive exists" do
     before do
-      @archive_mock = mock 'archive'
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @archive_double = double 'archive'
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should exit if the archive does not exist" do
-      @archive_mock.should_receive(:exists?).and_return false
-      options = { :config => @config_stub, :archive => @archive_mock }
+      @archive_double.should_receive(:exists?).and_return false
+      options = { :config => @config_double, :archive => @archive_double }
       lambda { @object.ensure_archive_exists options }.
                        should raise_error SystemExit
     end
@@ -214,17 +214,17 @@ describe Heirloom do
 
   context "testing ensure archive domain empty" do
     before do
-      @archive_stub = stub 'archive'
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @archive_double = double 'archive'
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
-      @options = { :config => @config_stub, :archive => @archive_stub }
+      @options = { :config => @config_double, :archive => @archive_double }
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should exit if the domain is not empty" do
-      @archive_stub.stub :count => 200
+      @archive_double.stub :count => 200
       lambda { @object.ensure_archive_domain_empty @options }.
                        should raise_error SystemExit
     end
@@ -232,17 +232,17 @@ describe Heirloom do
 
   context "testing ensure catalog domain exists" do
     before do
-      @catalog_mock = mock 'catalog'
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @catalog_double = double 'catalog'
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
-      @options = { :config => @config_stub, :catalog => @catalog_mock }
+      @options = { :config => @config_double, :catalog => @catalog_double }
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should exit if the catlog domain does not exist" do
-      @catalog_mock.stub :catalog_domain_exists? => false
+      @catalog_double.stub :catalog_domain_exists? => false
       lambda { @object.ensure_catalog_domain_exists @options }.
                        should raise_error SystemExit
     end
@@ -250,21 +250,21 @@ describe Heirloom do
 
   context "testing ensure entry (does not) exists in catalog" do
     before do
-      @catalog_mock = mock 'catalog'
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @catalog_double = double 'catalog'
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
-      @options = { :config  => @config_stub,
-                   :catalog => @catalog_mock,
+      @options = { :config  => @config_double,
+                   :catalog => @catalog_double,
                    :entry   => 'entry' }
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should exit if the entry does not exist in catalog" do
-      @catalog_mock.should_receive(:entry_exists_in_catalog?).
-                    with('entry').
-                    and_return false
+      @catalog_double.should_receive(:entry_exists_in_catalog?).
+                      with('entry').
+                      and_return false
       lambda { @object.ensure_entry_exists_in_catalog @options }.
                        should raise_error SystemExit
     end
@@ -273,9 +273,9 @@ describe Heirloom do
 
   context "testing latest id" do
     before do
-      @archive_mock = mock 'archive'
-      @config_stub = stub 'config'
-      @options = { :config => @config_stub, :archive => @archive_stub }
+      @archive_double = double 'archive'
+      @config_double = double 'config'
+      @options = { :config => @config_double, :archive => @archive_double }
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
@@ -283,13 +283,13 @@ describe Heirloom do
     it "should return the latest id" do
       Heirloom::Archive.should_receive(:new).
                         with(:name => 'test',
-                             :config => @config_stub).
-                        and_return @archive_mock
-      @archive_mock.should_receive(:list).
+                             :config => @config_double).
+                        and_return @archive_double
+      @archive_double.should_receive(:list).
                     with(1).
                     and_return ['id']
       @object.latest_id(:name   => 'test',
-                        :config => @config_stub).
+                        :config => @config_double).
               should == 'id'
     end
 
@@ -297,10 +297,10 @@ describe Heirloom do
 
   context "read secret from file" do
     before do
-      @archive_mock = mock 'archive'
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger => @logger_stub
-      @options = { :config => @config_stub, :opts => {} }
+      @archive_double = double 'archive'
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger => @logger_double
+      @options = { :config => @config_double, :opts => {} }
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
@@ -313,7 +313,7 @@ describe Heirloom do
     end
 
     it "should return the contents of the file with newline removed" do
-      file_mock = mock 'file'
+      file_double = double 'file'
       @options[:opts][:secret_file] = '/good/file'
       File.stub :exists? => true
       File.should_receive(:read).
@@ -332,33 +332,33 @@ describe Heirloom do
 
   context "ensure buckets are available or owned by account" do
     before do
-      @logger_stub  = stub 'logger', :error => true
-      @config_stub  = stub 'config', :logger => @logger_stub
-      @checker_mock = mock 'checker'
-      @args = { :config        => @config_stub,
+      @logger_double  = double 'logger', :error => true
+      @config_double  = double 'config', :logger => @logger_double
+      @checker_double = double 'checker'
+      @args = { :config        => @config_double,
                 :bucket_prefix => 'intu-lc',
                 :regions       => ['us-west-1', 'us-west-2'] }
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
       Heirloom::Checker.should_receive(:new).
-                        with(:config => @config_stub).
-                        and_return @checker_mock
+                        with(:config => @config_double).
+                        and_return @checker_double
     end
 
     it "should return true if buckets available in all regions" do
-      @checker_mock.should_receive(:bucket_name_available?).
+      @checker_double.should_receive(:bucket_name_available?).
                     with(:bucket_prefix => 'intu-lc',
                          :regions       => ['us-west-1', 'us-west-2'],
-                         :config        => @config_stub).
+                         :config        => @config_double).
                     and_return true
       @object.ensure_buckets_available(@args).should be_true
     end
 
     it "should return raise and error if any bucket un-available in all regions" do
-      @checker_mock.should_receive(:bucket_name_available?).
+      @checker_double.should_receive(:bucket_name_available?).
                     with(:bucket_prefix => 'intu-lc',
                          :regions       => ['us-west-1', 'us-west-2'],
-                         :config        => @config_stub).
+                         :config        => @config_double).
                     and_return false
       lambda { @object.ensure_buckets_available(@args) }.
                should raise_error SystemExit
@@ -367,20 +367,20 @@ describe Heirloom do
 
   context "testing ensure entry does not exist in catalog unless forced" do
     before do
-      @catalog_mock = mock 'catalog'
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @catalog_double = double 'catalog'
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should exit if the entry exists in catalog and not forced" do
-      options = { :config  => @config_stub,
-                  :catalog => @catalog_mock,
+      options = { :config  => @config_double,
+                  :catalog => @catalog_double,
                   :entry   => 'entry',
                   :force   => false }
-      @catalog_mock.should_receive(:entry_exists_in_catalog?).
+      @catalog_double.should_receive(:entry_exists_in_catalog?).
                     with('entry').
                     and_return true
       lambda { @object.ensure_entry_does_not_exist_in_catalog options }.
@@ -388,22 +388,22 @@ describe Heirloom do
     end
 
     it "should not exit if the entry exists in catalog and forced" do
-      options = { :config  => @config_stub,
-                  :catalog => @catalog_mock,
+      options = { :config  => @config_double,
+                  :catalog => @catalog_double,
                   :entry   => 'entry',
                   :force   => true }
-      @catalog_mock.should_receive(:entry_exists_in_catalog?).
+      @catalog_double.should_receive(:entry_exists_in_catalog?).
                     with('entry').
                     and_return true
       @object.ensure_entry_does_not_exist_in_catalog options
     end
 
     it "should not exit if the does not exists in catalog" do
-      options = { :config  => @config_stub,
-                  :catalog => @catalog_mock,
+      options = { :config  => @config_double,
+                  :catalog => @catalog_double,
                   :entry   => 'entry',
                   :force   => false }
-      @catalog_mock.should_receive(:entry_exists_in_catalog?).
+      @catalog_double.should_receive(:entry_exists_in_catalog?).
                     with('entry').
                     and_return false
       @object.ensure_entry_does_not_exist_in_catalog options
@@ -412,32 +412,32 @@ describe Heirloom do
 
   context "testing ensure valid name" do
     before do
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should not exit if name is valid" do
-      @object.ensure_valid_name :config => @config_stub,
+      @object.ensure_valid_name :config => @config_double,
                                 :name   => 'test-123_test'
     end
 
     it "should exit if name contains a upper case" do
-      lambda { @object.ensure_valid_name :config => @config_stub,
+      lambda { @object.ensure_valid_name :config => @config_double,
                                          :name   => 'TEST-123' }.
                        should raise_error SystemExit
     end
 
     it "should exit if name contains a space" do
-      lambda { @object.ensure_valid_name :config => @config_stub,
+      lambda { @object.ensure_valid_name :config => @config_double,
                                          :name   => 'test 123' }.
                        should raise_error SystemExit
     end
 
     it "should exit if name contains invalid characters" do
-      lambda { @object.ensure_valid_name :config => @config_stub,
+      lambda { @object.ensure_valid_name :config => @config_double,
                                          :name   => 'test,123' }.
                        should raise_error SystemExit
     end
@@ -445,32 +445,32 @@ describe Heirloom do
 
   context "testing ensure valid bucket prefix" do
     before do
-      @logger_stub = stub 'logger', :error => true
-      @config_stub = stub 'config', :logger          => @logger_stub,
+      @logger_double = double 'logger', :error => true
+      @config_double = double 'config', :logger          => @logger_double,
                                     :metadata_region => 'us-west-1'
       @object = Object.new
       @object.extend Heirloom::CLI::Shared
     end
 
     it "should not exit if bucket_prefix is valid" do
-      @object.ensure_valid_bucket_prefix :config        => @config_stub,
+      @object.ensure_valid_bucket_prefix :config        => @config_double,
                                          :bucket_prefix => 'test-123'
     end
 
     it "should exit if bucket_prefix contains uppercase" do
-      lambda { @object.ensure_valid_bucket_prefix :config        => @config_stub,
+      lambda { @object.ensure_valid_bucket_prefix :config        => @config_double,
                                                   :bucket_prefix => 'TEST-123' }.
                        should raise_error SystemExit
     end
 
     it "should exit if bucket_prefix contains a space" do
-      lambda { @object.ensure_valid_bucket_prefix :config        => @config_stub,
+      lambda { @object.ensure_valid_bucket_prefix :config        => @config_double,
                                                   :bucket_prefix => 'test 123' }.
                        should raise_error SystemExit
     end
 
     it "should exit if bucket_prefix contains invalid characters" do
-      lambda { @object.ensure_valid_bucket_prefix :config        => @config_stub,
+      lambda { @object.ensure_valid_bucket_prefix :config        => @config_double,
                                                   :bucket_prefix => 'test,123' }.
                        should raise_error SystemExit
     end