beaker 4.38.1 → 5.0.0

data/spec/beaker/options/hosts_file_parser_spec.rb

@@ -3,15 +3,15 @@ require "spec_helper"
 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)      { 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
@@ -23,54 +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).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
 
@@ -79,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
 
@@ -109,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 === []
+          host_options['HOSTS'].each do |_host_name, host_hash|
+            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) {Beaker::Options::OptionsFileParser}
-      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,37 +3,35 @@ require "spec_helper"
 module Beaker
   module Options
     describe OptionsHash do
-      let(:options)    { Beaker::Options::OptionsHash.new }
-
+      let(:options) { described_class.new }
 
       it "supports is_pe?, defaults to pe" do
-        expect(options.is_pe?).to be_truthy
+        expect(options).to be_is_pe
       end
 
       it "supports is_pe?, respects :type == foss" do
         options[:type] = 'foss'
-        expect(options.is_pe?).to be_falsy
+        expect(options).not_to be_is_pe
       end
 
       describe '#get_type' do
-        let(:options) { Beaker::Options::OptionsHash.new }
+        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