beaker 4.41.2 → 5.0.0

data/spec/beaker/subcommand_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 module Beaker
   SubcommandUtil = Beaker::Subcommands::SubcommandUtil
   describe Subcommand do
-    let( :subcommand ) {
+    let(:subcommand) do
       described_class.new
-    }
+    end
 
     describe '#initialize' do
       it 'creates a cli object' do
@@ -32,51 +32,51 @@ module Beaker
     end
 
     context 'ensure that beaker options can be passed through' do
+      let(:beaker_options_list) do
+        %w[
+          options-file
+          helper
+          load-path
+          tests
+          pre-suite
+          post-suite
+          pre-cleanup
+          provision
+          preserve-hosts
+          preserve-state
+          root-keys
+          keyfile
+          timeout
+          install
+          modules
+          quiet
+          color
+          color-host-output
+          log-level
+          log-prefix
+          dry-run
+          fail-mode
+          ntp
+          repo-proxy
+          package-proxy
+          validate
+          collect-perf-data
+          parse-only
+          tag
+          exclude-tags
+          xml-time-order
+          debug-errors
+          exec_manual_tests
+          test-tag-exclude
+          test-tag-and
+          test-tag-or
+          xml
+          type
+          debug
+        ]
+      end
 
-      let(:beaker_options_list) { [
-        'options-file',
-        'helper',
-        'load-path',
-        'tests',
-        'pre-suite',
-        'post-suite',
-        'pre-cleanup',
-        'provision',
-        'preserve-hosts',
-        'preserve-state',
-        'root-keys',
-        'keyfile',
-        'timeout',
-        'install',
-        'modules',
-        'quiet',
-        'color',
-        'color-host-output',
-        'log-level',
-        'log-prefix',
-        'dry-run',
-        'fail-mode',
-        'ntp',
-        'repo-proxy',
-        'add-el-extras',
-        'package-proxy',
-        'validate',
-        'collect-perf-data',
-        'parse-only',
-        'tag',
-        'exclude-tags',
-        'xml-time-order',
-        'debug-errors',
-        'exec_manual_tests',
-        'test-tag-exclude',
-        'test-tag-and',
-        'test-tag-or',
-        'xml',
-        'type',
-        'debug',
-      ] }
-
-      let( :yaml_store_mock ) { double('yaml_store_mock') }
+      let(:yaml_store_mock) { double('yaml_store_mock') }
 
       it 'does not error with valid beaker options' do
         beaker_options_list.each do |option|
@@ -91,7 +91,7 @@ module Beaker
           expect(SubcommandUtil::SUBCOMMAND_OPTIONS).to receive(:exist?).and_return(true)
           expect(SubcommandUtil::SUBCOMMAND_STATE).to receive(:exist?).and_return(true)
 
-          expect {described_class.start(['init', '--hosts', 'centos', "--#{option}"])}.not_to output(/ERROR/).to_stderr
+          expect { described_class.start(['init', '--hosts', 'centos', "--#{option}"]) }.not_to output(/ERROR/).to_stderr
         end
       end
 
@@ -102,14 +102,14 @@ module Beaker
         expect(File).not_to receive(:open)
         expect(SubcommandUtil::SUBCOMMAND_OPTIONS).to receive(:exist?).and_return(true)
         expect(SubcommandUtil::SUBCOMMAND_STATE).to receive(:exist?).and_return(true)
-        expect {described_class.start(['init', '--hosts', 'centos', '--bad-option'])}.to output(/ERROR/).to_stderr
+        expect { described_class.start(['init', '--hosts', 'centos', '--bad-option']) }.to output(/ERROR/).to_stderr
       end
     end
 
     describe '#init' do
-      let( :cli ) { subcommand.cli }
-      let( :mock_options ) { {:timestamp => 'noon', :other_key => 'cordite'}}
-      let( :yaml_store_mock ) { double('yaml_store_mock') }
+      let(:cli) { subcommand.cli }
+      let(:mock_options) { { :timestamp => 'noon', :other_key => 'cordite' } }
+      let(:yaml_store_mock) { double('yaml_store_mock') }
 
       before do
         allow(cli).to receive(:parse_options)
@@ -126,21 +126,21 @@ module Beaker
       end
 
       it 'requires hosts flag' do
-        expect{subcommand.init}.to raise_error(NotImplementedError)
+        expect { subcommand.init }.to raise_error(NotImplementedError)
       end
     end
 
     describe '#provision' do
-      let( :cli ) { subcommand.cli }
-      let( :yaml_store_mock ) { double('yaml_store_mock') }
-      let( :host_hash ) { {'mynode.net' => {:name => 'mynode', :platform => Beaker::Platform.new('centos-6-x86_64')}}}
-      let( :cleaned_hosts ) {double()}
-      let( :yielded_host_hash ) {double()}
-      let( :yielded_host_name) {double()}
-      let( :network_manager) {double('network_manager')}
-      let( :hosts) {double('hosts')}
-      let( :hypervisors) {double('hypervisors')}
-      let(:options) {double('options')}
+      let(:cli) { subcommand.cli }
+      let(:yaml_store_mock) { double('yaml_store_mock') }
+      let(:host_hash) { { 'mynode.net' => { :name => 'mynode', :platform => Beaker::Platform.new('centos-6-x86_64') } } }
+      let(:cleaned_hosts) { double }
+      let(:yielded_host_hash) { double }
+      let(:yielded_host_name) { double }
+      let(:network_manager) { double('network_manager') }
+      let(:hosts) { double('hosts') }
+      let(:hypervisors) { double('hypervisors') }
+      let(:options) { double('options') }
 
       it 'provisions the host and saves the host info' do
         expect(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_STATE).and_return(yaml_store_mock)
@@ -168,8 +168,8 @@ module Beaker
       end
 
       it 'does not allow hosts to be passed' do
-        subcommand.options = {:hosts => "myhost"}
-        expect{subcommand.provision()}.to raise_error(NotImplementedError)
+        subcommand.options = { :hosts => "myhost" }
+        expect { subcommand.provision }.to raise_error(NotImplementedError)
       end
     end
 
@@ -180,15 +180,15 @@ module Beaker
         allow(subcommand.cli).to receive(:execute!)
       end
 
-      let( :cleaned_hosts ) {double()}
-      let( :host_hash ) { {'mynode.net' => {:name => 'mynode', :platform => Beaker::Platform.new('centos-6-x86_64')}}}
-      let( :yaml_store_mock ) { double('yaml_store_mock') }
+      let(:cleaned_hosts) { double }
+      let(:host_hash) { { 'mynode.net' => { :name => 'mynode', :platform => Beaker::Platform.new('centos-6-x86_64') } } }
+      let(:yaml_store_mock) { double('yaml_store_mock') }
 
       it 'calls execute! when no resource is given' do
         expect_any_instance_of(Pathname).not_to receive(:directory?)
         expect_any_instance_of(Pathname).not_to receive(:exist?)
         expect(subcommand.cli).to receive(:execute!).once
-        expect{subcommand.exec}.not_to raise_error
+        expect { subcommand.exec }.not_to raise_error
       end
 
       it 'allows hard coded suite names to be specified' do
@@ -205,7 +205,7 @@ module Beaker
 
       it 'errors when a resource is neither a valid file resource or suite name' do
         allow_any_instance_of(Pathname).to receive(:exist?).and_return(false)
-        expect{subcommand.exec('blahblahblah')}.to raise_error(ArgumentError)
+        expect { subcommand.exec('blahblahblah') }.to raise_error(ArgumentError)
       end
 
       it 'accepts a tests directory, clearing all other suites' do
@@ -249,13 +249,11 @@ module Beaker
       it 'rejects comma-separated file and suite name' do
         allow_any_instance_of(Pathname).to receive(:exist?).and_return(false)
 
-        expect {
+        expect do
           subcommand.exec('pre-suite,tests/whoops')
-        }.to raise_error(ArgumentError, %r{Unable to parse pre-suite,tests/whoops})
+        end.to raise_error(ArgumentError, %r{Unable to parse pre-suite,tests/whoops})
       end
 
-
-
       it 'updates the subcommand_options file with new host info if `preserve-state` is set' do
         allow(yaml_store_mock).to receive(:[]).and_return(false)
         allow(subcommand).to receive(:options).and_return('preserve-state' => true)
@@ -280,10 +278,10 @@ module Beaker
     end
 
     context 'destroy' do
-      let( :cli ) { subcommand.cli }
-      let( :mock_options ) { {:timestamp => 'noon', :other_key => 'cordite'}}
-      let( :yaml_store_mock ) { double('yaml_store_mock') }
-      let( :network_manager) {double('network_manager')}
+      let(:cli) { subcommand.cli }
+      let(:mock_options) { { :timestamp => 'noon', :other_key => 'cordite' } }
+      let(:yaml_store_mock) { double('yaml_store_mock') }
+      let(:network_manager) { double('network_manager') }
 
       it 'calls destroy and updates the yaml store' do
         allow(cli).to receive(:parse_options)

data/spec/beaker/test_case_spec.rb

@@ -9,116 +9,96 @@ module Beaker
     context 'run_test' do
       it 'defaults to test_status :pass on success' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write ""
-        end
+        File.write(path, "")
         @path = path
-        expect( testcase ).not_to receive( :log_and_fail_test )
+        expect(testcase).not_to receive(:log_and_fail_test)
         testcase.run_test
         expect(testcase.test_status).to be === :pass
       end
 
       it 'updates test_status to :skip on SkipTest' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write "raise SkipTest"
-        end
+        File.write(path, "raise SkipTest")
         @path = path
-        expect( testcase ).not_to receive( :log_and_fail_test )
+        expect(testcase).not_to receive(:log_and_fail_test)
         testcase.run_test
         expect(testcase.test_status).to be === :skip
       end
 
       it 'updates test_status to :pending on PendingTest' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write "raise PendingTest"
-        end
+        File.write(path, "raise PendingTest")
         @path = path
-        expect( testcase ).not_to receive( :log_and_fail_test )
+        expect(testcase).not_to receive(:log_and_fail_test)
         testcase.run_test
         expect(testcase.test_status).to be === :pending
       end
 
       it 'updates test_status to :fail on FailTest' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write "raise FailTest"
-        end
+        File.write(path, "raise FailTest")
         @path = path
-        expect( testcase ).to receive( :log_and_fail_test ).once.with(kind_of(Beaker::DSL::FailTest), :fail).and_call_original
+        expect(testcase).to receive(:log_and_fail_test).once.with(kind_of(Beaker::DSL::FailTest), :fail).and_call_original
         testcase.run_test
         expect(testcase.test_status).to be === :fail
       end
 
       it 'correctly handles RuntimeError' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write "raise RuntimeError"
-        end
+        File.write(path, "raise RuntimeError")
         @path = path
-        expect( testcase ).to receive( :log_and_fail_test ).once.with(kind_of(RuntimeError))
+        expect(testcase).to receive(:log_and_fail_test).once.with(kind_of(RuntimeError))
         testcase.run_test
       end
 
       it 'correctly handles ScriptError' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write "raise ScriptError"
-        end
+        File.write(path, "raise ScriptError")
         @path = path
-        expect( testcase ).to receive( :log_and_fail_test ).once.with(kind_of(ScriptError))
+        expect(testcase).to receive(:log_and_fail_test).once.with(kind_of(ScriptError))
         testcase.run_test
       end
 
       it 'correctly handles Timeout::Error' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write "raise Timeout::Error"
-        end
+        File.write(path, "raise Timeout::Error")
         @path = path
-        expect( testcase ).to receive( :log_and_fail_test ).once.with(kind_of(Timeout::Error))
+        expect(testcase).to receive(:log_and_fail_test).once.with(kind_of(Timeout::Error))
         testcase.run_test
       end
 
       it 'correctly handles CommandFailure' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write "raise Host::CommandFailure"
-        end
+        File.write(path, "raise Host::CommandFailure")
         @path = path
-        expect( testcase ).to receive( :log_and_fail_test ).once.with(kind_of(Host::CommandFailure))
+        expect(testcase).to receive(:log_and_fail_test).once.with(kind_of(Host::CommandFailure))
         testcase.run_test
       end
 
       it 'records a test failure if an assertion fails in a teardown block' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write <<-EOF
+        File.write(path, <<-EOF)
             teardown do
               assert_equal(1, 2, 'Oh noes!')
             end
-          EOF
-        end
+        EOF
         @path = path
-        expect( testcase ).to receive( :log_and_fail_test ).once.with(kind_of(Minitest::Assertion), :teardown_error).and_call_original
+        expect(testcase).to receive(:log_and_fail_test).once.with(kind_of(Minitest::Assertion), :teardown_error).and_call_original
         testcase.run_test
         expect(testcase.test_status).to eq(:error)
       end
 
       it 'does not overwrite a test failure if an assertion also happens in a teardown block' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write <<-EOF
+        File.write(path, <<-EOF)
             teardown do
               assert_equal(1, 2, 'Oh noes!')
             end
             assert_equal(true, false, 'failed test')
-          EOF
-        end
+        EOF
         @path = path
-        expect( testcase ).to receive( :log_and_fail_test ).once.with(kind_of(Minitest::Assertion), :fail).and_call_original
-        expect( testcase ).to receive( :log_and_fail_test ).once.with(kind_of(Minitest::Assertion), :teardown_error).and_call_original
+        expect(testcase).to receive(:log_and_fail_test).once.with(kind_of(Minitest::Assertion), :fail).and_call_original
+        expect(testcase).to receive(:log_and_fail_test).once.with(kind_of(Minitest::Assertion), :teardown_error).and_call_original
         testcase.run_test
         expect(testcase.test_status).to eq(:fail)
       end
@@ -128,9 +108,7 @@ module Beaker
       it 'sets the filename correctly from the path' do
         answer = 'jacket'
         path = "#{answer}.rb"
-        File.open(path, 'w') do |f|
-          f.write ""
-        end
+        File.write(path, "")
         @path = path
         testcase.run_test
         metadata = testcase.instance_variable_get(:@metadata)
@@ -139,9 +117,7 @@ module Beaker
 
       it 'resets the step name' do
         path = 'test.rb'
-        File.open(path, 'w') do |f|
-          f.write ""
-        end
+        File.write(path, "")
         @path = path
         # we have to create a TestCase by hand, so that we can set old
         tc = described_class.new({}, logger, {}, path)
@@ -153,6 +129,5 @@ module Beaker
         expect(metadata[:step][:name]).to be_nil
       end
     end
-
   end
 end