beaker 1.21.0 → 2.0.0

data/spec/beaker/hypervisor/vcloud_spec.rb

@@ -6,14 +6,14 @@ module Beaker
     before :each do
       MockVsphereHelper.set_config( fog_file_contents )
       MockVsphereHelper.set_vms( make_hosts() )
-      stub_const( "VsphereHelper", MockVsphereHelper )
-      stub_const( "Net", MockNet )
-      json = mock( 'json' )
-      json.stub( :parse ) do |arg| 
+     stub_const( "VsphereHelper", MockVsphereHelper )
+     stub_const( "Net", MockNet )
+      json = double( 'json' )
+      allow( json ).to receive( :parse ) do |arg| 
         arg
       end
-      stub_const( "JSON", json )
-      Socket.stub( :getaddrinfo ).and_return( true )
+     stub_const( "JSON", json )
+      allow( Socket ).to receive( :getaddrinfo ).and_return( true )
     end
 
     describe "#provision" do
@@ -25,8 +25,8 @@ module Beaker
         opts[:pooling_api] = nil
 
         vcloud = Beaker::Vcloud.new( make_hosts, opts )
-        vcloud.stub( :require ).and_return( true )
-        vcloud.stub( :sleep ).and_return( true )
+        allow( vcloud ).to receive( :require ).and_return( true )
+        allow( vcloud ).to receive( :sleep ).and_return( true )
         vcloud.provision
 
         hosts = vcloud.instance_variable_get( :@hosts )
@@ -49,8 +49,8 @@ module Beaker
         opts[:pooling_api] = nil
 
         vcloud = Beaker::Vcloud.new( make_hosts, opts )
-        vcloud.stub( :require ).and_return( true )
-        vcloud.stub( :sleep ).and_return( true )
+        allow( vcloud ).to receive( :require ).and_return( true )
+        allow( vcloud ).to receive( :sleep ).and_return( true )
         vcloud.provision
         vcloud.cleanup
 

data/spec/beaker/hypervisor/vsphere_helper_spec.rb

@@ -18,21 +18,21 @@ module Beaker
                                                 
 
     before :each do
-      stub_const( "RbVmomi", MockRbVmomi )
+     stub_const( "RbVmomi", MockRbVmomi )
     end
 
     describe "#load_config" do 
 
       it 'can load a .fog file' do
-        File.stub( :exists? ).and_return( true )
-        YAML.stub( :load_file ).and_return( fog_file_contents )
+        allow( File ).to receive( :exists? ).and_return( true )
+        allow( YAML ).to receive( :load_file ).and_return( fog_file_contents )
 
         expect( VsphereHelper.load_config ).to be === vInfo
 
       end
 
       it 'raises an error when the .fog file is missing' do
-        File.stub( :exists? ).and_return( false )
+        allow( File ).to receive( :exists? ).and_return( false )
 
         expect{ VsphereHelper.load_config }.to raise_error( ArgumentError )
 
@@ -121,7 +121,7 @@ module Beaker
 
    describe "#wait_for_tasks" do
      it "can wait for tasks to error" do
-       vsphere_helper.stub( :sleep ).and_return( true )
+       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
        vms.each do |vm|
          vm.info.state = 'error'
        end
@@ -130,7 +130,7 @@ module Beaker
      end
 
      it "can wait for tasks to succeed" do
-       vsphere_helper.stub( :sleep ).and_return( true )
+       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
        vms.each do |vm|
          vm.info.state = 'success'
        end
@@ -139,7 +139,7 @@ module Beaker
      end
 
      it "errors when tasks fail to error/success before timing out" do
-       vsphere_helper.stub( :sleep ).and_return( true )
+       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
        vms.each do |vm|
          vm.info.state = 'nope'
        end
@@ -152,7 +152,7 @@ module Beaker
    describe "#close" do
      it 'closes the connection' do
        connection = vsphere_helper.instance_variable_get( :@connection )
-       connection.should_receive( :close ).once
+       expect( connection ).to receive( :close ).once
        
        vsphere_helper.close
      end

data/spec/beaker/hypervisor/vsphere_spec.rb

@@ -6,7 +6,7 @@ module Beaker
     before :each do
       MockVsphereHelper.set_config( fog_file_contents )
       MockVsphereHelper.set_vms( make_hosts() )
-      stub_const( "VsphereHelper", MockVsphereHelper )
+     stub_const( "VsphereHelper", MockVsphereHelper )
     end
 
     describe "#provision" do

data/spec/beaker/logger_spec.rb

@@ -2,10 +2,10 @@
 require 'spec_helper'
 
 module Beaker
-  describe Logger, :use_fakefs => true do
-    let(:my_io)  { MockIO.new                         }
-    let(:logger) { Logger.new(my_io, :quiet => true)  }
-
+  describe Logger do
+    let(:my_io)     { MockIO.new                         }
+    let(:logger)    { Logger.new(my_io, :quiet => true)  }
+    let(:test_dir)  { 'tmp/tests' }
 
     context '#convert' do
       let(:valid_utf8)  { "/etc/puppet/modules\n├── jimmy-appleseed (\e[0;36mv1.1.0\e[0m)\n├── jimmy-crakorn (\e[0;36mv0.4.0\e[0m)\n└── jimmy-thelock (\e[0;36mv1.0.0\e[0m)\n" }
@@ -24,10 +24,24 @@ module Beaker
       end
     end
 
+    context '#generate_dated_log_folder' do
+
+      it 'generates path for a given timestamp' do
+        input_time = Time.new(2014, 6, 2, 16, 31, 22, '-07:00')
+        expect( Logger.generate_dated_log_folder(test_dir, input_time) ).to be === File.join(test_dir, '2014-06-02_16_31_22')
+      end
+
+      it 'generates directory for a given timestamp' do
+        input_time = Time.new(2011, 6, 10, 13, 7, 55, '-09:00')
+        expect( File.directory? Logger.generate_dated_log_folder(test_dir, input_time) ).to be_truthy
+      end
+
+    end
+
     context 'new' do
       it 'does not duplicate STDOUT when directly passed to it' do
         stdout_logger = Logger.new STDOUT
-        expect( stdout_logger ).to have(1).destinations
+        expect( stdout_logger.destinations.size ).to be === 1
       end
 
 
@@ -42,7 +56,7 @@ module Beaker
     context 'it can' do
       it 'open/create a file when a string is given to add_destination' do
         logger.add_destination 'my_tmp_file'
-        expect( File.exists?( 'my_tmp_file' ) ).to be_true
+        expect( File.exists?( 'my_tmp_file' ) ).to be_truthy
 
         io = logger.destinations.select {|d| d.respond_to? :path }.first
         expect( io.path ).to match /my_tmp_file/
@@ -65,9 +79,9 @@ module Beaker
       it 'colors strings if @color is set' do
         colorized_logger = Logger.new my_io, :color => true, :quiet => true
 
-        my_io.should_receive( :print ).with "\e[00;30m"
-        my_io.should_receive( :print )
-        my_io.should_receive( :puts ).with 'my string'
+        expect( my_io ).to receive( :print ).with "\e[00;30m"
+        expect( my_io ).to receive( :print )
+        expect( my_io ).to receive( :puts ).with 'my string'
 
         colorized_logger.optionally_color "\e[00;30m", 'my string'
       end
@@ -79,14 +93,14 @@ module Beaker
                                               :color => true )
                                   }
 
-        its( :is_debug? ) { should be_true }
-        its( :is_trace? ) { should be_true }
-        its( :is_warn? )  { should be_true }
+        its( :is_debug? ) { should be_truthy }
+        its( :is_trace? ) { should be_truthy }
+        its( :is_warn? )  { should be_truthy }
 
         context 'but print' do
           before do
-            my_io.stub :puts
-            my_io.should_receive( :print ).at_least :twice
+            allow( my_io ).to receive :puts
+            expect( my_io ).to receive( :print ).at_least :twice
           end
 
           it( 'warnings' )    { trace_logger.warn 'IMA WARNING!'    }
@@ -105,15 +119,15 @@ module Beaker
                                               :color => true )
                                   }
 
-        its( :is_trace? ) { should be_false }
-        its( :is_debug? ) { should be_false }
-        its( :is_verbose? ) { should be_true }
-        its( :is_warn? )  { should be_true }
+        its( :is_trace? ) { should be_falsy }
+        its( :is_debug? ) { should be_falsy }
+        its( :is_verbose? ) { should be_truthy }
+        its( :is_warn? )  { should be_truthy }
 
         context 'but print' do
           before do
-            my_io.stub :puts
-            my_io.should_receive( :print ).at_least :twice
+            allow( my_io ).to receive :puts
+            expect( my_io ).to receive( :print ).at_least :twice
           end
 
           it( 'warnings' )    { verbose_logger.warn 'IMA WARNING!'    }
@@ -131,14 +145,14 @@ module Beaker
                                               :color => true )
                                   }
 
-        its( :is_trace? ) { should be_false }
-        its( :is_debug? ) { should be_true }
-        its( :is_warn? )  { should be_true }
+        its( :is_trace? ) { should be_falsy }
+        its( :is_debug? ) { should be_truthy }
+        its( :is_warn? )  { should be_truthy }
 
         context 'successfully print' do
           before do
-            my_io.stub :puts
-            my_io.should_receive( :print ).at_least :twice
+            allow( my_io ).to receive :puts
+            expect( my_io ).to receive( :print ).at_least :twice
           end
 
           it( 'warnings' )    { debug_logger.warn 'IMA WARNING!'        }
@@ -156,14 +170,14 @@ module Beaker
                                               :color     => true )
                                   }
 
-        its( :is_debug? ) { should be_false }
-        its( :is_trace? ) { should be_false }
+        its( :is_debug? ) { should be_falsy }
+        its( :is_trace? ) { should be_falsy }
 
 
         context 'skip' do
           before do
-            my_io.should_not_receive :puts
-            my_io.should_not_receive :print
+            expect( my_io ).to_not receive :puts
+            expect( my_io ).to_not receive :print
           end
 
           it( 'debugs' )    { info_logger.debug 'NOT DEBUGGING!' }
@@ -173,8 +187,8 @@ module Beaker
 
         context 'but print' do
           before do
-            my_io.should_receive :puts
-            my_io.should_receive( :print ).twice
+            expect( my_io ).to receive :puts
+            expect( my_io ).to receive( :print ).twice
           end
 
           it( 'successes' )     { info_logger.success 'SUCCESS!'  }

data/spec/beaker/options/command_line_parser_spec.rb

@@ -6,14 +6,22 @@ module Beaker
 
       let(:parser) {Beaker::Options::CommandLineParser.new}
       let(:test_opts) {["-h", "vcloud.cfg", "--debug", "--tests", "test.rb", "--help"]}
-      let(:full_opts) {["--hosts", "host.cfg", "--options", "opts_file", "--type", "pe", "--helper", "path_to_helper", "--load-path", "load_path", "--tests", "test1.rb,test2.rb,test3.rb", "--pre-suite", "pre_suite.rb", "--post-suite", "post_suite.rb", "--no-provision", "--preserve-hosts", "always", "--root-keys", "--keyfile", "../.ssh/id_rsa", "--install", "gitrepopath", "-m", "module", "-q", "--dry-run", "--no-ntp", "--repo-proxy", "--add-el-extras", "--config", "anotherfile.cfg", "--fail-mode", "fast", "--no-color", "--version", "--log-level", "info", "--package-proxy", "http://192.168.100.1:3128"]}
+      let(:full_opts) {["--hosts", "host.cfg", "--options", "opts_file", "--type", "pe", "--helper", "path_to_helper", "--load-path", "load_path", "--tests", "test1.rb,test2.rb,test3.rb", "--pre-suite", "pre_suite.rb", "--post-suite", "post_suite.rb", "--no-provision", "--preserve-hosts", "always", "--root-keys", "--keyfile", "../.ssh/id_rsa", "--install", "gitrepopath", "-m", "module", "-q", "--dry-run", "--no-ntp", "--repo-proxy", "--add-el-extras", "--config", "anotherfile.cfg", "--fail-mode", "fast", "--no-color", "--version", "--log-level", "info", "--package-proxy", "http://192.168.100.1:3128", "--collect-perf-data", "--parse-only", "--validate", "--timeout", "40"]}
+      let(:validate_true)  {["--validate"]}
+      let(:validate_false) {["--no-validate"]}
+
 
       it "can correctly read command line input" do
         expect(parser.parse(test_opts)).to be === {:hosts_file=>"vcloud.cfg", :log_level=>"debug", :tests=>"test.rb", :help=>true}
       end
 
       it "supports all our command line options" do
-        expect(parser.parse(full_opts)).to be === {:hosts_file=>"anotherfile.cfg", :options_file=>"opts_file", :type=>"pe", :helper=>"path_to_helper", :load_path=>"load_path", :tests=>"test1.rb,test2.rb,test3.rb", :pre_suite=>"pre_suite.rb", :post_suite=>"post_suite.rb", :provision=>false, :preserve_hosts=>"always", :root_keys=>true, :keyfile=>"../.ssh/id_rsa", :install=>"gitrepopath", :modules=>"module", :quiet=>true, :dry_run=>true, :timesync=>false, :repo_proxy=>true, :add_el_extras=>true, :fail_mode=>"fast", :color=>false, :version=>true, :log_level=>"info", :package_proxy => "http://192.168.100.1:3128"}
+        expect(parser.parse(full_opts)).to be === {:hosts_file=>"anotherfile.cfg", :options_file=>"opts_file", :type=>"pe", :helper=>"path_to_helper", :load_path=>"load_path", :tests=>"test1.rb,test2.rb,test3.rb", :pre_suite=>"pre_suite.rb", :post_suite=>"post_suite.rb", :provision=>false, :preserve_hosts=>"always", :root_keys=>true, :keyfile=>"../.ssh/id_rsa", :install=>"gitrepopath", :modules=>"module", :quiet=>true, :dry_run=>true, :timesync=>false, :repo_proxy=>true, :add_el_extras=>true, :fail_mode=>"fast", :color=>false, :version=>true, :log_level=>"info", :package_proxy => "http://192.168.100.1:3128", :collect_perf_data=>true, :parse_only=>true, :validate=>true, :timeout=>"40"}
+      end
+
+      it "supports both validate options" do
+        expect(parser.parse(validate_true)).to be === {:validate=>true}
+        expect(parser.parse(validate_false)).to be === {:validate=>false}
       end
 
       it "can produce a usage description" do

data/spec/beaker/options/hosts_file_parser_spec.rb

@@ -4,8 +4,8 @@ module Beaker
   module Options
     describe HostsFileParser do
 
-      let(:parser) {HostsFileParser}
-      let(:filepath) {File.join(File.expand_path(File.dirname(__FILE__)), "data", "hosts.cfg")}
+      let(:parser)      {HostsFileParser}
+      let(:filepath)    {File.join(File.expand_path(File.dirname(__FILE__)), "data", "hosts.cfg")}
 
       it "can correctly read a host file" do
         FakeFS.deactivate!
@@ -30,6 +30,13 @@ module Beaker
         expect{parser.parse_hosts_file("not a valid path")}.to raise_error(ArgumentError)
       end
 
+      it "raises an error on bad yaml file" do
+        FakeFS.deactivate!
+        allow( YAML ).to receive(:load_file) { raise Psych::SyntaxError }
+        allow( File ).to receive(:exists?).and_return(true)
+        expect { parser.parse_hosts_file("not a valid path") }.to raise_error(ArgumentError)
+      end
+
     end
   end
 end

data/spec/beaker/options/options_hash_spec.rb

@@ -17,12 +17,12 @@ module Beaker
       end
 
       it "supports is_pe?, defaults to pe" do
-        expect(options.is_pe?).to be_true
+        expect(options.is_pe?).to be_truthy
       end
 
       it "supports is_pe?, respects :type == foss" do
         options[:type] = 'foss'
-        expect(options.is_pe?).to be_false
+        expect(options.is_pe?).to be_falsy
       end
 
       it "can delete by string of symbol key" do

data/spec/beaker/options/parser_spec.rb

@@ -50,7 +50,7 @@ module Beaker
         end
       end
 
-      context 'testing path traversing', :use_fakefs => true do
+      context 'testing path traversing' do
 
         let(:test_dir) { 'tmp/tests' }
         let(:rb_test)  { File.expand_path(test_dir + '/my_ruby_file.rb')    }
@@ -76,7 +76,7 @@ module Beaker
         end
       end
 
-      context 'combining split_arg and file_list maintain test file ordering', :use_fakefs => true do
+      context 'combining split_arg and file_list maintain test file ordering' do
         let(:test_dir) { 'tmp/tests' }
         let(:other_test_dir) {'tmp/tests2' }
 

data/spec/beaker/options/pe_version_scaper_spec.rb

@@ -4,7 +4,12 @@ module Beaker
   module Options
     describe PEVersionScraper do
       it "can pull version from local LATEST file" do
-        expect(PEVersionScraper.load_pe_version(File.expand_path(File.dirname(__FILE__)), "data/LATEST")) === '3.0.0'
+        filename = 'LATEST'
+        latest = File.open(filename, 'w')
+        latest.write('3.7.1-rc0-8-g73f93cb')
+        latest.close
+        expect(PEVersionScraper.load_pe_version('.', filename)) === '3.0.0'
+        File.delete(filename)
       end
       it "raises error when file doesn't exist" do
         expect{PEVersionScraper.load_pe_version("not a valid path", "not a valid filename")}.to raise_error(ArgumentError)

data/spec/beaker/options/presets_spec.rb

@@ -30,8 +30,18 @@ module Beaker
             expect( munged[:type] ).to be == 'pe'
           end
         end
+        describe 'sets type to foss if...' do
+          it 'env var is set to "false"' do
+            munged = presets.format_found_env_vars( {:is_pe => 'true'} )
+            expect( munged[:type] ).to be == 'pe'
+          end
+          it 'env var is set to "no"' do
+            munged = presets.format_found_env_vars( {:is_pe => 'yes'} )
+            expect( munged[:type] ).to be == 'pe'
+          end
+        end
         it 'does not set type otherwise' do
-          munged = presets.format_found_env_vars( {:is_pe => 'false'} )
+          munged = presets.format_found_env_vars( {:is_pe => nil} )
           expect( munged[:type] ).to be == nil
         end
       end

data/spec/beaker/shared/error_handler_spec.rb

@@ -8,8 +8,8 @@ module Beaker
       let( :logger )    { double( 'logger' ) }
 
       before :each do
-        logger.stub( :error ).and_return( true )
-        logger.stub( :pretty_backtrace ).and_return( backtrace )
+        allow( logger ).to receive( :error ).and_return( true )
+        allow( logger ).to receive( :pretty_backtrace ).and_return( backtrace )
 
       end
 
@@ -17,14 +17,14 @@ module Beaker
 
         it "records the backtrace of the exception to the logger" do
           ex = Exception.new("ArgumentError")
-          ex.stub( :backtrace ).and_return(backtrace)
+          allow( ex ).to receive( :backtrace ).and_return(backtrace)
           mesg = "I'm the extra message"
          
           backtrace.each_line do |line|
-            logger.should_receive( :error ).with(line)
+            expect( logger ).to receive( :error ).with(line)
           end
 
-          subject.should_receive( :raise ).once
+          expect( subject ).to receive( :raise ).once
 
           subject.report_and_raise(logger, ex, mesg) 
 

data/spec/beaker/shared/host_manager_spec.rb

@@ -62,7 +62,6 @@ module Beaker
             hosts
           end
           expect( myhosts ).to be  === hosts[0]
-
         end
 
         it "can execute a block against hosts identified by a hostname" do
@@ -70,7 +69,6 @@ module Beaker
             hosts
           end
           expect( myhosts ).to be  === hosts[0]
-
         end
 
         it "can execute a block against an array of hosts" do
@@ -78,7 +76,10 @@ module Beaker
             hosts
           end
           expect( myhosts ).to be  === hosts
+        end
 
+        it "receives an ArgumentError on empty host" do
+          expect { host_handler.run_block_on( [], role0 ) }.to raise_error(ArgumentError)
         end
 
       end

data/spec/beaker/shared/repetition_spec.rb

@@ -6,10 +6,10 @@ module Beaker
 
       context 'repeat_for' do
         it "repeats a block for 5 seconds" do
-          Time.stub( :now ).and_return( 0, 1, 2, 3, 4, 5, 6 )
+          allow( Time ).to receive( :now ).and_return( 0, 1, 2, 3, 4, 5, 6 )
 
           block = double( 'block' )
-          block.should_receive( :exec ).exactly( 5 ).times.and_return( false )
+          expect( block ).to receive( :exec ).exactly( 5 ).times.and_return( false )
           
           subject.repeat_for( 5 ) do
             block.exec
@@ -17,10 +17,10 @@ module Beaker
         end
 
         it "should short circuit if the block is complete" do
-          Time.stub( :now ).and_return( 0, 1, 2, 3, 4, 5 )
+          allow( Time ).to receive( :now ).and_return( 0, 1, 2, 3, 4, 5 )
 
           block = double( 'block' )
-          block.should_receive( :exec ).once.and_return( true )
+          expect( block ).to receive( :exec ).once.and_return( true )
           
           subject.repeat_for( 5 ) do
             block.exec
@@ -34,13 +34,13 @@ module Beaker
         it "sleeps in fibonacci increasing intervals" do
 
           block = double( 'block' )
-          block.should_receive( :exec ).exactly( 5 ).times.and_return( false )
-          subject.stub( 'sleep' ).and_return( true )
-          subject.should_receive( :sleep ).with( 1 ).exactly( 2 ).times
-          subject.should_receive( :sleep ).with( 2 ).once
-          subject.should_receive( :sleep ).with( 3 ).once
-          subject.should_receive( :sleep ).with( 5 ).once
-          subject.should_receive( :sleep ).with( 8 ).never
+          expect( block ).to receive( :exec ).exactly( 5 ).times.and_return( false )
+          allow( subject ).to receive( 'sleep' ).and_return( true )
+          expect( subject ).to receive( :sleep ).with( 1 ).exactly( 2 ).times
+          expect( subject ).to receive( :sleep ).with( 2 ).once
+          expect( subject ).to receive( :sleep ).with( 3 ).once
+          expect( subject ).to receive( :sleep ).with( 5 ).once
+          expect( subject ).to receive( :sleep ).with( 8 ).never
 
           subject.repeat_fibonacci_style_for( 5 ) do
             block.exec
@@ -51,13 +51,13 @@ module Beaker
         it "should short circuit if the block is complete" do
 
           block = double( 'block' )
-          block.should_receive( :exec ).once.and_return( true )
-          subject.stub( 'sleep' ).and_return( true )
-          subject.should_receive( :sleep ).with( 1 ).once
-          subject.should_receive( :sleep ).with( 2 ).never
-          subject.should_receive( :sleep ).with( 3 ).never
-          subject.should_receive( :sleep ).with( 5 ).never
-          subject.should_receive( :sleep ).with( 8 ).never
+          expect( block ).to receive( :exec ).once.and_return( true )
+          allow( subject ).to receive( 'sleep' ).and_return( true )
+          expect( subject ).to receive( :sleep ).with( 1 ).once
+          expect( subject ).to receive( :sleep ).with( 2 ).never
+          expect( subject ).to receive( :sleep ).with( 3 ).never
+          expect( subject ).to receive( :sleep ).with( 5 ).never
+          expect( subject ).to receive( :sleep ).with( 8 ).never
 
           subject.repeat_fibonacci_style_for( 5 ) do
             block.exec