heirloom 0.12.1 → 0.12.2

data/spec/cli/show_spec.rb

@@ -9,26 +9,26 @@ describe Heirloom do
                  :id              => '1.0.0',
                  :level           => 'info',
                  :metadata_region => 'us-west-1' }
-    @logger_stub = stub :debug => true
-    @config_mock = mock_config(:logger => @logger_stub)
-    @archive_mock = mock 'archive'
+    @logger_double = double :debug => true
+    @config_double = double_config(:logger => @logger_double)
+    @archive_double = double 'archive'
     Heirloom::HeirloomLogger.should_receive(:new).with(:log_level => 'info').
-                             and_return @logger_stub
+                             and_return @logger_double
     Heirloom::CLI::Show.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::Archive.should_receive(:new).
                       with(:name   => 'archive_name',
                            :id     => '1.0.0',
-                           :config => @config_mock).
-                      and_return @archive_mock
-    @archive_mock.stub :exists? => true
-    @archive_mock.stub :domain_exists? => true
+                           :config => @config_double).
+                      and_return @archive_double
+    @archive_double.stub :exists? => true
+    @archive_double.stub :domain_exists? => true
   end
 
   context "returning base attributes" do
@@ -44,7 +44,7 @@ describe Heirloom do
 
       it "should show a given id as json" do
         @cli_show = Heirloom::CLI::Show.new
-        @archive_mock.stub :show => @attributes
+        @archive_double.stub :show => @attributes
         @cli_show.should_receive(:jj).with @attributes
         @cli_show.show
       end
@@ -59,13 +59,13 @@ describe Heirloom do
 
       it "should show a given id using the show formatter" do
         @cli_show = Heirloom::CLI::Show.new
-        @archive_mock.stub :show => @attributes
-        formatter_mock = mock 'format'
-        Heirloom::CLI::Formatter::Show.stub :new => formatter_mock
-        formatter_mock.should_receive(:format).
-                       with(:attributes => @attributes,
-                            :all        => true).
-                       and_return 'the attribs'
+        @archive_double.stub :show => @attributes
+        formatter_double = double 'format'
+        Heirloom::CLI::Formatter::Show.stub :new => formatter_double
+        formatter_double.should_receive(:format).
+                         with(:attributes => @attributes,
+                              :all        => true).
+                         and_return 'the attribs'
         @cli_show.should_receive(:puts).with 'the attribs'
         @cli_show.show
       end

data/spec/cli/tag_spec.rb

@@ -10,41 +10,41 @@ describe Heirloom do
                 :attribute       => 'att',
                 :value           => 'val',
                 :metadata_region => 'us-west-1' }
-    @logger_stub = stub :debug => true, :error => true
-    @config_mock = mock_config(:logger => @logger_stub)
-    @archive_mock = mock 'archive'
-    
+    @logger_double = double :debug => true, :error => true
+    @config_double = double_config(:logger => @logger_double)
+    @archive_double = double 'archive'
+
     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::Tag.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::Archive.should_receive(:new).
                       with(:name   => 'archive_name',
                            :id     => '1.0.0',
-                           :config => @config_mock).
-                      and_return @archive_mock
-    @archive_mock.stub :exists? => true
-    @archive_mock.should_receive(:domain_exists?).and_return true
+                           :config => @config_double).
+                      and_return @archive_double
+    @archive_double.stub :exists? => true
+    @archive_double.should_receive(:domain_exists?).and_return true
     @cli_tag = Heirloom::CLI::Tag.new
   end
 
   it "should tag an archive attribute with a given id" do
-    @archive_mock.stub :exists? => true
-    @archive_mock.should_receive(:update).
-                  with(:attribute => 'att',
-                       :value     => 'val')
+    @archive_double.stub :exists? => true
+    @archive_double.should_receive(:update).
+                    with(:attribute => 'att',
+                         :value     => 'val')
     @cli_tag.tag
   end
 
   it "should exit if the archive does not exist" do
-    @archive_mock.stub :exists? => false
+    @archive_double.stub :exists? => false
     lambda { @cli_tag.tag }.should raise_error SystemExit
   end
 

data/spec/cli/teardown_spec.rb

@@ -3,7 +3,7 @@ require 'heirloom/cli'
 
 describe Heirloom::CLI::Teardown do
 
-  def stubbed_teardown
+  def doublebed_teardown
     teardown = Heirloom::CLI::Teardown.new
     teardown.stub(
       :ensure_domain_exists => true,
@@ -13,46 +13,46 @@ describe Heirloom::CLI::Teardown do
   end
 
   before do
-    Heirloom.stub :log => mock_log
-    @config_mock = mock_config
+    Heirloom.stub :log => double_log
+    @config_double = double_config
 
-    @defaults = { 
+    @defaults = {
       :level           => 'info',
       :name            => 'archive_name',
       :metadata_region => 'us-west-1'
     }
 
 
-    @archive_mock = mock 'archive'
-    @archive_mock.stub(
+    @archive_double = double 'archive'
+    @archive_double.stub(
       :delete_buckets => true,
       :delete_domain  => true
     )
 
-    @catalog_mock = mock 'catalog'
-    @catalog_mock.stub(
+    @catalog_double = double 'catalog'
+    @catalog_double.stub(
       :regions                  => ['us-west-1', 'us-west-2'],
-      :bucket_prefix            => 'bp', 
+      :bucket_prefix            => 'bp',
       :catalog_domain_exists?   => true,
       :delete_from_catalog      => true,
       :entry_exists_in_catalog? => true
     )
-    
+
     Trollop.stub :options => @defaults
-    Heirloom::HeirloomLogger.stub :new => @logger_stub
+    Heirloom::HeirloomLogger.stub :new => @logger_double
     Heirloom::CLI::Teardown.any_instance.stub(:load_config)
-      .and_return @config_mock
-    Heirloom::Archive.stub :new => @archive_mock
-    Heirloom::Catalog.stub :new => @catalog_mock
-    @teardown = stubbed_teardown
+      .and_return @config_double
+    Heirloom::Archive.stub :new => @archive_double
+    Heirloom::Catalog.stub :new => @catalog_double
+    @teardown = doublebed_teardown
   end
 
   context "delete existing archives force option" do
-    
+
     it "should ask archive to delete when passed the 'force' option" do
       Trollop.stub :options => @defaults.merge(:force => true)
-      @teardown = stubbed_teardown
-      @catalog_mock.should_receive(:cleanup).with(
+      @teardown = doublebed_teardown
+      @catalog_double.should_receive(:cleanup).with(
         :num_to_keep => 0,
         :remove_preserved => true
       )
@@ -61,24 +61,24 @@ describe Heirloom::CLI::Teardown do
 
     it "should not ask archive to delete when not passed the 'force' option" do
       Trollop.stub :options => @defaults.merge(:force => nil)
-      @teardown = stubbed_teardown
-      @catalog_mock.should_not_receive(:cleanup)
+      @teardown = doublebed_teardown
+      @catalog_double.should_not_receive(:cleanup)
       @teardown.teardown
     end
-    
+
   end
 
   it "should delete s3 buckets, catalog and simpledb domain" do
     @teardown.should_receive(:ensure_domain_exists).
               with(:name   => 'archive_name',
-                   :config => @config_mock)
+                   :config => @config_double)
     @teardown.should_receive(:ensure_archive_domain_empty).
-              with(:archive => @archive_mock,
-                   :config  => @config_mock)
-    @archive_mock.should_receive(:delete_buckets)
-    @archive_mock.should_receive(:delete_domain)
-    @catalog_mock.should_receive(:delete_from_catalog)
-    @teardown.teardown 
+              with(:archive => @archive_double,
+                   :config  => @config_double)
+    @archive_double.should_receive(:delete_buckets)
+    @archive_double.should_receive(:delete_domain)
+    @catalog_double.should_receive(:delete_from_catalog)
+    @teardown.teardown
   end
 
 end

data/spec/cli/upload_spec.rb

@@ -11,71 +11,71 @@ describe Heirloom do
                 :public          => false,
                 :secret          => 'secret12',
                 :name            => 'archive_name',
-                :id              => '1.0.0', 
+                :id              => '1.0.0',
                 :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'
-    @catalog_mock.stub :regions                => @regions,
+    @logger_double = double 'logger', :error => true, :info => true
+    @config_double = double_config(:logger => @logger_double)
+    @archive_double = double 'archive'
+    @catalog_double = double 'catalog'
+    @catalog_double.stub :regions                => @regions,
                        :bucket_prefix          => 'bp',
                        :catalog_domain_exists? => true
     Trollop.stub(:options).and_return options
-    tempfile_stub = stub 'tempfile', :path   => '/tmp/file.tar.gz',
-                                     :close! => true
-    Tempfile.stub :new => tempfile_stub
-    
+    tempfile_double = double 'tempfile', :path   => '/tmp/file.tar.gz',
+                                         :close! => true
+    Tempfile.stub :new => tempfile_double
+
     Heirloom::HeirloomLogger.should_receive(:new).with(:log_level => 'info').
-                             and_return @logger_stub
+                             and_return @logger_double
     Heirloom::CLI::Upload.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(:id   => '1.0.0',
                            :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
-    @catalog_mock.should_receive(:entry_exists_in_catalog?).
-                  with('archive_name').
-                  and_return true
+                           :config => @config_double).
+                      and_return @catalog_double
+    @catalog_double.should_receive(:entry_exists_in_catalog?).
+                    with('archive_name').
+                    and_return true
     @upload = Heirloom::CLI::Upload.new
   end
 
   it "should upload an archive" do
     @upload.should_receive(:ensure_domain_exists).
             with(:name   => 'archive_name',
-                 :config => @config_mock)
+                 :config => @config_double)
     @upload.should_receive(:ensure_buckets_exist).
             with(:bucket_prefix => 'bp',
                  :name          => 'archive_name',
                  :regions       => @regions,
-                 :config        => @config_mock)
+                 :config        => @config_double)
     @upload.should_receive(:ensure_path_is_directory).
             with(:path   => '/buildme',
-                 :config => @config_mock)
+                 :config => @config_double)
     @upload.should_receive(:ensure_valid_secret).
             with(:secret => 'secret12',
-                 :config => @config_mock)
-    @archive_mock.stub :exists? => false
-    @archive_mock.should_receive(:build).
-                  with(:bucket_prefix => 'bp',
-                       :directory     => '/buildme',
-                       :exclude       => ["exclude1", "exclude2"],
-                       :secret        => 'secret12',
-                       :file          => '/tmp/file.tar.gz').
-                  and_return true
-    @archive_mock.should_receive(:upload).
-                  with(:bucket_prefix   => 'bp',
-                       :regions         => @regions,
-                       :public_readable => false,
-                       :secret          => 'secret12',
-                       :file            => '/tmp/file.tar.gz')
+                 :config => @config_double)
+    @archive_double.stub :exists? => false
+    @archive_double.should_receive(:build).
+                    with(:bucket_prefix => 'bp',
+                         :directory     => '/buildme',
+                         :exclude       => ["exclude1", "exclude2"],
+                         :secret        => 'secret12',
+                         :file          => '/tmp/file.tar.gz').
+                    and_return true
+    @archive_double.should_receive(:upload).
+                    with(:bucket_prefix   => 'bp',
+                         :regions         => @regions,
+                         :public_readable => false,
+                         :secret          => 'secret12',
+                         :file            => '/tmp/file.tar.gz')
     @upload.upload
   end
 

data/spec/config_spec.rb

@@ -23,9 +23,9 @@ describe Heirloom do
     it "should open the HEIRLOOM_CONFIG_FILE if set" do
       File.stub :exists? => true
       File.should_receive(:open).with('~/.special_config.yml').and_return(@config_file.to_yaml)
-      env_mock = mock 'env'
-      env_mock.should_receive(:load).with('HEIRLOOM_CONFIG_FILE').and_return('~/.special_config.yml')
-      Heirloom::Env.stub(:new).and_return(env_mock)
+      env_double = double 'env'
+      env_double.should_receive(:load).with('HEIRLOOM_CONFIG_FILE').and_return('~/.special_config.yml')
+      Heirloom::Env.stub(:new).and_return(env_double)
       config = Heirloom::Config.new :opts   => @opts,
                                     :logger => 'da-logger'
     end
@@ -33,10 +33,10 @@ describe Heirloom do
     it "should open the default config file if HEIRLOOM_CONFIG_FILE is not set" do
       File.stub :exists? => true
       File.should_receive(:open).with('~/.heirloom.yml').and_return(@config_file.to_yaml)
-      env_mock = mock 'env'
-      env_mock.should_receive(:load).with('HEIRLOOM_CONFIG_FILE').and_return(nil)
-      env_mock.should_receive(:load).with('HOME').and_return('~')
-      Heirloom::Env.stub(:new).and_return(env_mock)
+      env_double = double 'env'
+      env_double.should_receive(:load).with('HEIRLOOM_CONFIG_FILE').and_return(nil)
+      env_double.should_receive(:load).with('HOME').and_return('~')
+      Heirloom::Env.stub(:new).and_return(env_double)
       config = Heirloom::Config.new :opts   => @opts,
                                     :logger => 'da-logger'
     end
@@ -44,11 +44,11 @@ describe Heirloom do
 
   context "#reading env variables" do
     it "should return the proxy as set by https_proxy" do
-      env_mock = mock 'env'
-      env_mock.should_receive(:load).with('HEIRLOOM_CONFIG_FILE').and_return(nil)
-      env_mock.should_receive(:load).with('HOME').and_return('~')
-      env_mock.should_receive(:load).with('https_proxy').and_return('https://proxy.example.com:3128')
-      Heirloom::Env.stub(:new).and_return(env_mock)
+      env_double = double 'env'
+      env_double.should_receive(:load).with('HEIRLOOM_CONFIG_FILE').and_return(nil)
+      env_double.should_receive(:load).with('HOME').and_return('~')
+      env_double.should_receive(:load).with('https_proxy').and_return('https://proxy.example.com:3128')
+      Heirloom::Env.stub(:new).and_return(env_double)
       config = Heirloom::Config.new :opts => @opts
       expect(config.proxy).to eq('https://proxy.example.com:3128')
     end
@@ -56,10 +56,10 @@ describe Heirloom do
 
   context "#with config file set" do
     before do
-      env_mock = mock 'env'
-      env_mock.should_receive(:load).with('HEIRLOOM_CONFIG_FILE').and_return(nil)
-      env_mock.should_receive(:load).with('HOME').and_return('~')
-      Heirloom::Env.stub(:new).and_return(env_mock)
+      env_double = double 'env'
+      env_double.should_receive(:load).with('HEIRLOOM_CONFIG_FILE').and_return(nil)
+      env_double.should_receive(:load).with('HOME').and_return('~')
+      Heirloom::Env.stub(:new).and_return(env_double)
     end
 
     it "should create a new config object from the hash passed as config" do
@@ -123,12 +123,12 @@ describe Heirloom do
     it "should log a warning if a non-existing environment is requested from existing config file" do
       File.stub :exists? => true
       File.should_receive(:open).with("~/.heirloom.yml").and_return(@config_file.to_yaml)
-      logger_mock = mock 'logger'
-      logger_mock.should_receive(:warn)
+      logger_double = double 'logger'
+      logger_double.should_receive(:warn)
 
-      lambda {
-        config = Heirloom::Config.new :environment => 'missing', :logger => logger_mock
-      }.should_not raise_error SystemExit
+      expect {
+        config = Heirloom::Config.new :environment => 'missing', :logger => logger_double
+      }.not_to raise_error
     end
   end
 end

data/spec/destroyer/s3_spec.rb

@@ -3,16 +3,16 @@ require 'spec_helper'
 describe Heirloom do
 
     before do
-      @config_mock = double 'config'
-      @s3 = Heirloom::Destroyer::S3.new :config  => @config_mock,
+      @config_double = double 'config'
+      @s3 = Heirloom::Destroyer::S3.new :config  => @config_double,
                                         :region  => 'us-west-1'
     end
 
     it "should delete the specified file from s3" do
-      s3_mock = mock 's3 mock'
-      @s3.should_receive(:s3).and_return(s3_mock)
-      s3_mock.should_receive(:delete_object).
-              with('bucket', "key_folder/key_name")
+      s3_double = double 's3 mock'
+      @s3.should_receive(:s3).and_return(s3_double)
+      s3_double.should_receive(:delete_object).
+                with('bucket', "key_folder/key_name")
       @s3.destroy_file :key_name   => 'key_name',
                        :key_folder => 'key_folder',
                        :bucket     => 'bucket'

data/spec/directory/directory_spec.rb

@@ -4,13 +4,13 @@ describe Heirloom::Directory do
 
   describe 'build_artifact_from_directory' do
     before do
-      @config_mock = double 'config'
-      @logger_stub = stub :debug => 'true', 
-                          :info  => 'true', 
-                          :warn  => 'true',
-                          :error => 'true'
-      @config_mock.stub(:logger).and_return(@logger_stub)
-      @directory = Heirloom::Directory.new :config  => @config_mock,
+      @config_double = double 'config'
+      @logger_double = double :debug => 'true', 
+                              :info  => 'true', 
+                              :warn  => 'true',
+                              :error => 'true'
+      @config_double.stub(:logger).and_return(@logger_double)
+      @directory = Heirloom::Directory.new :config  => @config_double,
                                            :exclude => ['dont_pack_me', 'dont_pack_me1'],
                                            :path    => '/dir',
                                            :file    => '/tmp/file.tar.gz'
@@ -19,12 +19,12 @@ describe Heirloom::Directory do
     context 'when succesful' do
       before do 
         @directory.should_receive(:which).with('tar').and_return true
-        output_mock = double 'output mock'
+        output_double = double 'output double'
         command = "cd /dir && tar czf /tmp/file.tar.gz --exclude dont_pack_me --exclude dont_pack_me1 ."
         files = ['pack_me', '.hidden', 'with a space', 'dont_pack_me', 'dont_pack_me1']
         Heirloom::Directory.any_instance.should_receive(:`).
                             with(command).
-                            and_return output_mock
+                            and_return output_double
         $?.stub :success? => true
       end
 
@@ -37,17 +37,17 @@ describe Heirloom::Directory do
 
       context 'without secret provided' do
         before do
-          @cipher_mock = mock 'cipher'
+          @cipher_double = double 'cipher'
           Heirloom::Cipher::File.should_receive(:new).
-                                 with(:config => @config_mock).
-                                 and_return @cipher_mock
+                                 with(:config => @config_double).
+                                 and_return @cipher_double
         end
 
         it "should build and encrypt an archive from the path" do
-          @cipher_mock.should_receive(:encrypt_file).
-                       with(:file => '/tmp/file.tar.gz', 
-                            :secret => 'supersecret').
-                       and_return true
+          @cipher_double.should_receive(:encrypt_file).
+                         with(:file => '/tmp/file.tar.gz', 
+                              :secret => 'supersecret').
+                         and_return true
           @directory.build_artifact_from_directory(:secret => 'supersecret').
                      should be_true
        end
@@ -57,12 +57,12 @@ describe Heirloom::Directory do
     context 'when unable to create the tar' do
       before do 
         @directory.should_receive(:which).with('tar').and_return true
-        output_mock = double 'output mock'
+        output_double = double 'output double'
         command = "cd /dir && tar czf /tmp/file.tar.gz --exclude dont_pack_me --exclude dont_pack_me1 ."
         files = ['pack_me', '.hidden', 'with a space', 'dont_pack_me', 'dont_pack_me1']
         Heirloom::Directory.any_instance.should_receive(:`).
                             with(command).
-                            and_return output_mock
+                            and_return output_double
         $?.stub(:success?).and_return(false)
       end
 
@@ -89,7 +89,7 @@ describe Heirloom::Directory do
 
     context "parameter validation" do
       it "should not fail if exclude is nil" do
-        @directory = Heirloom::Directory.new :config  => @config_mock,
+        @directory = Heirloom::Directory.new :config  => @config_double,
                                              :exclude => nil,
                                              :path    => '/dir',
                                              :file    => '/tmp/file.tar.gz'