beaker 4.39.0 → 5.0.0

data/spec/beaker/options/command_line_parser_spec.rb

@@ -3,25 +3,23 @@ require "spec_helper"
 module Beaker
   module Options
     describe CommandLineParser do
-
-      let(:parser) {described_class.new}
-      let(:test_opts) {["-h", "vcloud.cfg", "--debug", "--tests", "test.rb", "--help"]}
-      let(:full_opts_in)  {["--hosts", "host.cfg",           "--options", "opts_file", "--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", "--pre-cleanup", "pre_cleanup.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", "--no-color-host-output",                 "--version", "--log-level", "info", "--package-proxy", "http://192.168.100.1:3128",        "--collect-perf-data",    "--parse-only",    "--validate", "--timeout", "40", "--log-prefix", "pants",      "--configure", "--test-tag-and", "1,2,3", "--test-tag-or", "4,5,6", "--test-tag-exclude", "7,8,9",        "--xml-time-order"]}
-      let(:full_opts_out) {{:hosts_file=>"anotherfile.cfg",:options_file=>"opts_file",  :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", :pre_cleanup => "pre_cleanup.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, :color_host_output=>false, :beaker_version_print=>true,  :log_level => "info",  :package_proxy => "http://192.168.100.1:3128", :collect_perf_data=>"normal", :parse_only=>true, :validate=>true,  :timeout => "40",  :log_prefix => "pants", :configure => true,  :test_tag_and => "1,2,3",  :test_tag_or => "4,5,6",  :test_tag_exclude => "7,8,9", :xml_time_enabled => true}}
-      let(:validate_true)  {["--validate"]}
-      let(:validate_false) {["--no-validate"]}
-      let(:configure_true)  {['--configure']}
-      let(:configure_false) {['--no-configure']}
-      let(:provision_false) {['--no-provision']}
-      let(:provision_other) {{:provision => false, :configure => false, :validate => false}}
-      let(:provision_both_in)   {['--no-provision', '--configure', '--validate']}
-      let(:provision_both_out)  {{:provision => false, :configure => true, :validate => true}}
-      let(:provision_half_in)   {['--no-provision', '--configure']}
-      let(:provision_half_out)  {{:provision => false, :configure => true, :validate => false}}
-
+      let(:parser) { described_class.new }
+      let(:test_opts) { ["-h", "vcloud.cfg", "--debug", "--tests", "test.rb", "--help"] }
+      let(:full_opts_in)  { ["--hosts", "host.cfg", "--options", "opts_file", "--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", "--pre-cleanup", "pre_cleanup.rb", "--no-provision", "--preserve-hosts", "always", "--root-keys", "--keyfile", "../.ssh/id_rsa", "--install", "gitrepopath", "-m", "module",         "-q", "--dry-run", "--no-ntp", "--repo-proxy", "--config", "anotherfile.cfg", "--fail-mode", "fast", "--no-color", "--no-color-host-output", "--version", "--log-level", "info", "--package-proxy", "http://192.168.100.1:3128", "--collect-perf-data", "--parse-only", "--validate", "--timeout", "40", "--log-prefix", "pants", "--configure", "--test-tag-and", "1,2,3", "--test-tag-or", "4,5,6", "--test-tag-exclude", "7,8,9", "--xml-time-order"] }
+      let(:full_opts_out) { { :hosts_file => "anotherfile.cfg", :options_file => "opts_file", :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", :pre_cleanup => "pre_cleanup.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, :fail_mode => "fast", :color => false, :color_host_output => false, :beaker_version_print => true, :log_level => "info", :package_proxy => "http://192.168.100.1:3128", :collect_perf_data => "normal", :parse_only => true, :validate => true, :timeout => "40", :log_prefix => "pants", :configure => true, :test_tag_and => "1,2,3", :test_tag_or => "4,5,6", :test_tag_exclude => "7,8,9", :xml_time_enabled => true } }
+      let(:validate_true)  { ["--validate"] }
+      let(:validate_false) { ["--no-validate"] }
+      let(:configure_true)  { ['--configure'] }
+      let(:configure_false) { ['--no-configure'] }
+      let(:provision_false) { ['--no-provision'] }
+      let(:provision_other) { { :provision => false, :configure => false, :validate => false } }
+      let(:provision_both_in)   { ['--no-provision', '--configure', '--validate'] }
+      let(:provision_both_out)  { { :provision => false, :configure => true, :validate => true } }
+      let(:provision_half_in)   { ['--no-provision', '--configure'] }
+      let(:provision_half_out)  { { :provision => false, :configure => true, :validate => false } }
 
       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}
+        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
@@ -29,17 +27,17 @@ module Beaker
       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}
+        expect(parser.parse(validate_true)).to be === { :validate => true }
+        expect(parser.parse(validate_false)).to be === { :validate => false }
       end
 
       it 'supports both configure options' do
-        expect(parser.parse(configure_true)).to be === {:configure=>true}
-        expect(parser.parse(configure_false)).to be === {:configure=>false}
+        expect(parser.parse(configure_true)).to be === { :configure => true }
+        expect(parser.parse(configure_false)).to be === { :configure => false }
       end
 
       it "can produce a usage description" do
-        expect{parser.usage}.not_to raise_error
+        expect { parser.usage }.not_to raise_error
       end
 
       context '--no-provision flag effects other options' do
@@ -55,7 +53,6 @@ module Beaker
           expect(parser.parse(provision_half_in)).to be === provision_half_out
         end
       end
-
     end
   end
 end

data/spec/beaker/options/hosts_file_parser_spec.rb

@@ -3,16 +3,15 @@ require "spec_helper"
 module Beaker
   module Options
     describe HostsFileParser do
-
-      let(:parser)      {described_class}
-      let(:filepath)    {File.join(File.expand_path(File.dirname(__FILE__)), "data", "hosts.cfg")}
-      let(:filepath_yaml) {File.join(File.expand_path(File.dirname(__FILE__)), "data", "hosts_preserved.yml")}
+      let(:parser)      { described_class }
+      let(:filepath)    { File.join(__dir__, "data", "hosts.cfg") }
+      let(:filepath_yaml) { File.join(__dir__, "data", "hosts_preserved.yml") }
 
       describe '#parse_hosts_file' do
         it "can correctly read a host file" do
           FakeFS.deactivate!
           config = parser.parse_hosts_file(filepath)
-          expect(config).to be === {:HOSTS=>{:"pe-ubuntu-lucid"=>{:roles=>["agent", "dashboard", "database", "master"], :vmname=>"pe-ubuntu-lucid", :platform=>"ubuntu-10.04-i386", :snapshot=>"clean-w-keys", :hypervisor=>"fusion"}, :"pe-centos6"=>{:roles=>["agent"], :vmname=>"pe-centos6", :platform=>"el-6-i386", :hypervisor=>"fusion", :snapshot=>"clean-w-keys"}}, :nfs_server=>"none", :consoleport=>443}
+          expect(config).to be === { :HOSTS => { :"pe-ubuntu-lucid" => { :roles => %w[agent dashboard database master], :vmname => "pe-ubuntu-lucid", :platform => "ubuntu-10.04-i386", :snapshot => "clean-w-keys", :hypervisor => "fusion" }, :"pe-centos6" => { :roles => ["agent"], :vmname => "pe-centos6", :platform => "el-6-i386", :hypervisor => "fusion", :snapshot => "clean-w-keys" } }, :nfs_server => "none", :consoleport => 443 }
         end
 
         it "can merge CONFIG section into overall hash" do
@@ -24,60 +23,59 @@ module Beaker
 
         it "returns empty configuration when no file provided" do
           FakeFS.deactivate!
-          expect(parser.parse_hosts_file()).to be === { :HOSTS => {} }
+          expect(parser.parse_hosts_file).to be === { :HOSTS => {} }
         end
 
         it "raises an error on no file found" do
           FakeFS.deactivate!
-          expect{parser.parse_hosts_file("not a valid path")}.to raise_error(/is not a valid path/)
+          expect { parser.parse_hosts_file("not a valid path") }.to raise_error(/is not a valid path/)
         end
 
         it "raises an error on bad yaml file" do
           FakeFS.deactivate!
-          expect( File ).to receive(:exist?).and_return(true)
+          expect(File).to receive(:exist?).and_return(true)
 
           expect { parser.parse_hosts_file("not a valid path") }.to raise_error(Errno::ENOENT)
         end
 
         it 'returns a #new_host_options hash if given no arguments' do
           host_options = parser.parse_hosts_file
-          expect( host_options ).to be === parser.new_host_options
+          expect(host_options).to be === parser.new_host_options
         end
 
         it 'passes a YAML.load call through to #merge_hosts_yaml' do
           yaml_string = 'not actually yaml, but that wont matter'
-          expect( File ).to receive( :exist?).and_return(true)
-          expect( File ).to receive( :read ).and_return(yaml_string)
-          parser.parse_hosts_file( yaml_string )
+          expect(File).to receive(:exist?).and_return(true)
+          expect(File).to receive(:read).and_return(yaml_string)
+          parser.parse_hosts_file(yaml_string)
         end
 
         it 'processes ERB in the host YAML successfully' do
           yaml_string = '1 plus 2: <%= 1 + 2 %>'
-          expect( File ).to receive( :exist?).and_return(true)
-          expect( File ).to receive( :read ).and_return(yaml_string)
-          beaker_options_hash = parser.parse_hosts_file( yaml_string )
+          expect(File).to receive(:exist?).and_return(true)
+          expect(File).to receive(:read).and_return(yaml_string)
+          beaker_options_hash = parser.parse_hosts_file(yaml_string)
           expect(beaker_options_hash['1 plus 2']).to eq(3)
         end
 
         it "can correctly read a hosts_preserved.yml file" do
           FakeFS.deactivate!
-          expect{ parser.parse_hosts_file(filepath_yaml) }.not_to raise_error
+          expect { parser.parse_hosts_file(filepath_yaml) }.not_to raise_error
           expect(parser.parse_hosts_file(filepath_yaml).dig(:HOSTS, :"primary.host")).not_to be_nil
         end
       end
 
       describe '#parse_hosts_string' do
-
         it 'will return a #new_host_options hash if given no arguments' do
           host_options = parser.parse_hosts_string
-          expect( host_options ).to be === parser.new_host_options
+          expect(host_options).to be === parser.new_host_options
         end
 
         it 'passes a process_yaml call through to #merge_hosts_yaml' do
           yaml_string = 'not actually yaml, but that wont matter'
           expect(described_class).to receive(:process_yaml).with(yaml_string, instance_of(Binding))
 
-          parser.parse_hosts_string( yaml_string )
+          parser.parse_hosts_string(yaml_string)
         end
       end
 
@@ -86,29 +84,29 @@ module Beaker
           host_options = {}
           yield_to_merge = { :pants => 'truth to the face' }
           block_count = 0
-          answer = parser.merge_hosts_yaml( host_options, 'err_msg' ) {
+          answer = parser.merge_hosts_yaml(host_options, 'err_msg') do
             block_count += 1
             yield_to_merge
-          }
+          end
 
-          expect( block_count ).to be === 1
-          expect( answer ).to be === host_options.merge( yield_to_merge )
+          expect(block_count).to be === 1
+          expect(answer).to be === host_options.merge(yield_to_merge)
         end
 
         class MockSyntaxError < Psych::SyntaxError
           def initialize
-            super( '', 0, 0, 0, '', '' )
+            super('', 0, 0, 0, '', '')
           end
         end
 
         it 'raises an ArgumentError if can\'t process YAML' do
           # allow( parser ).to receive( :merge_hosts_yaml )
           err_value = 'err_msg8797'
-          expect {
-            parser.merge_hosts_yaml( {}, err_value ) {
+          expect do
+            parser.merge_hosts_yaml({}, err_value) do
               raise MockSyntaxError
-            }
-          }.to raise_error( ArgumentError, /#{err_value}/ )
+            end
+          end.to raise_error(ArgumentError, /#{err_value}/)
         end
       end
 
@@ -116,13 +114,13 @@ module Beaker
         it 'adds a roles array to a host if not present' do
           host_options = { 'HOSTS' => {
             'host1' => {},
-            'host2' => {}
-          }}
+            'host2' => {},
+          } }
 
-          parser.fix_roles_array( host_options )
+          parser.fix_roles_array(host_options)
 
           host_options['HOSTS'].each do |_host_name, host_hash|
-            expect( host_hash['roles'] ).to be === []
+            expect(host_hash['roles']).to be === []
           end
         end
       end

data/spec/beaker/options/options_file_parser_spec.rb

@@ -3,21 +3,18 @@ require "spec_helper"
 module Beaker
   module Options
     describe OptionsFileParser do
-
-      let(:parser) {described_class}
-      let(:simple_opts) {File.join(File.expand_path(File.dirname(__FILE__)), "data", "opts.txt")}
+      let(:parser) { described_class }
+      let(:simple_opts) { File.join(__dir__, "data", "opts.txt") }
 
       it "can correctly read options from a file" do
         FakeFS.deactivate!
-        expect(parser.parse_options_file(simple_opts)).to be === {:debug=>true, :tests=>"test.rb", :pre_suite=>["pre-suite.rb"], :post_suite=>"post_suite1.rb,post_suite2.rb"}
+        expect(parser.parse_options_file(simple_opts)).to be === { :debug => true, :tests => "test.rb", :pre_suite => ["pre-suite.rb"], :post_suite => "post_suite1.rb,post_suite2.rb" }
       end
 
       it "raises an error on no file found" do
         FakeFS.deactivate!
-        expect{parser.parse_options_file("not a valid path")}.to raise_error(ArgumentError)
+        expect { parser.parse_options_file("not a valid path") }.to raise_error(ArgumentError)
       end
-
-
     end
   end
 end

data/spec/beaker/options/options_hash_spec.rb

@@ -3,8 +3,7 @@ require "spec_helper"
 module Beaker
   module Options
     describe OptionsHash do
-      let(:options)    { described_class.new }
-
+      let(:options) { described_class.new }
 
       it "supports is_pe?, defaults to pe" do
         expect(options).to be_is_pe
@@ -19,21 +18,20 @@ module Beaker
         let(:options) { described_class.new }
 
         it 'returns pe as expected in the normal case' do
-          newhash = options.merge({:type => 'pe'})
+          newhash = options.merge({ :type => 'pe' })
           expect(newhash.get_type).to be === :pe
         end
 
         it 'returns foss as expected in the normal case' do
-          newhash = options.merge({:type => 'foss'})
+          newhash = options.merge({ :type => 'foss' })
           expect(newhash.get_type).to be === :foss
         end
 
         it 'returns foss as the default' do
-          newhash = options.merge({:type => 'git'})
+          newhash = options.merge({ :type => 'git' })
           expect(newhash.get_type).to be === :foss
         end
       end
     end
-
   end
 end