beaker 4.41.2 → 5.0.0

data/spec/beaker/options/parser_spec.rb

@@ -2,18 +2,16 @@ require "spec_helper"
 
 module Beaker
   module Options
-
     describe Parser do
       let(:parser) { described_class.new }
-      let(:opts_path) { File.join(File.expand_path(File.dirname(__FILE__)), "data", "opts.txt") }
-      let(:hosts_path) { File.join(File.expand_path(File.dirname(__FILE__)), "data", "hosts.cfg") }
+      let(:opts_path) { File.join(__dir__, "data", "opts.txt") }
+      let(:hosts_path) { File.join(__dir__, "data", "hosts.cfg") }
 
       it "supports usage function" do
         expect { parser.usage }.not_to raise_error
       end
 
       describe 'parse_git_repos' do
-
         it "transforms arguments of <PROJECT_NAME>/<REF> to <GIT_BASE_URL>/<lowercased_project_name>#<REF>" do
           opts = ["PUPPET/3.1"]
           expect(parser.parse_git_repos(opts)).to be === ["#{parser.repo}/puppet.git#3.1"]
@@ -23,7 +21,7 @@ module Beaker
           projects = [['puppet', 'my_branch', 'PUPPET/my_branch'],
                       ['facter', 'my_branch', 'FACTER/my_branch'],
                       ['hiera', 'my_branch', 'HIERA/my_branch'],
-                      ['hiera-puppet', 'my_branch', 'HIERA-PUPPET/my_branch']]
+                      ['hiera-puppet', 'my_branch', 'HIERA-PUPPET/my_branch'],]
           projects.each do |project, ref, input|
             expect(parser.parse_git_repos([input])).to be === ["#{parser.repo}/#{project}.git##{ref}"]
           end
@@ -31,15 +29,14 @@ module Beaker
       end
 
       describe 'split_arg' do
-
         it "can split comma separated list into an array" do
           arg = "file1,file2,file3"
-          expect(parser.split_arg(arg)).to be === ["file1", "file2", "file3"]
+          expect(parser.split_arg(arg)).to be === %w[file1 file2 file3]
         end
 
         it "can use an existing Array as an acceptable argument" do
-          arg = ["file1", "file2", "file3"]
-          expect(parser.split_arg(arg)).to be === ["file1", "file2", "file3"]
+          arg = %w[file1 file2 file3]
+          expect(parser.split_arg(arg)).to be === %w[file1 file2 file3]
         end
 
         it "can generate an array from a single value" do
@@ -49,7 +46,6 @@ module Beaker
       end
 
       context 'testing path traversing' do
-
         let(:test_dir) { 'tmp/tests' }
         let(:rb_test) { File.expand_path(test_dir + '/my_ruby_file.rb') }
         let(:pl_test) { File.expand_path(test_dir + '/my_perl_file.pl') }
@@ -80,10 +76,11 @@ module Beaker
 
         before do
           files = [
-              '00_EnvSetup.rb', '035_StopFirewall.rb', '05_HieraSetup.rb',
-              '01_TestSetup.rb', '03_PuppetMasterSanity.rb',
-              '06_InstallModules.rb', '02_PuppetUserAndGroup.rb',
-              '04_ValidateSignCert.rb', '07_InstallCACerts.rb']
+            '00_EnvSetup.rb', '035_StopFirewall.rb', '05_HieraSetup.rb',
+            '01_TestSetup.rb', '03_PuppetMasterSanity.rb',
+            '06_InstallModules.rb', '02_PuppetUserAndGroup.rb',
+            '04_ValidateSignCert.rb', '07_InstallCACerts.rb',
+          ]
 
           @lone_file = '08_foss.rb'
 
@@ -137,52 +134,60 @@ module Beaker
         end
 
         describe 'does prioritization correctly' do
-          let(:env) { @env || {:level => 'highest'} }
-          let(:argv) { @argv || {:level => 'second'} }
-          let(:host_file) { @host_file || {:level => 'third'} }
-          let(:opt_file) { @opt_file || {
+          let(:env) { @env || { :level => 'highest' } }
+          let(:argv) { @argv || { :level => 'second' } }
+          let(:host_file) { @host_file || { :level => 'third' } }
+          let(:opt_file) do
+            @opt_file || {
               :level => 'fourth',
               :ssh => {
-                  :auth_methods => 'auth123',
-                  :user_known_hosts_file => 'hosts123'
-              }
-          }}
-          let(:subcommand_file) {@subcommand_file || {:level => 'fifth'}}
-          let(:homedir_file) {@homedir_file || {
+                :auth_methods => 'auth123',
+                :user_known_hosts_file => 'hosts123',
+              },
+            }
+          end
+          let(:subcommand_file) { @subcommand_file || { :level => 'fifth' } }
+          let(:homedir_file) do
+            @homedir_file || {
               :level => 'sixth',
               :ssh => {
-                  :auth_methods => 'auth_home_123'
-              }
-          }}
-          let(:project_file) {@project_file || {
+                :auth_methods => 'auth_home_123',
+              },
+            }
+          end
+          let(:project_file) do
+            @project_file || {
               :level => 'seventh',
               :ssh => {
-                  :auth_methods => 'auth_project_123'
-              }
-          }}
-          let(:presets) { {
+                :auth_methods => 'auth_project_123',
+              },
+            }
+          end
+          let(:presets) do
+            {
               :level => 'lowest',
               :ssh => {
-                  :config => 'config123',
-                  :verify_host_key => 'verify123',
-                  :port => 'port123',
-                  :forward_agent => 'forwardagent123',
-                  :keys => 'keys123',
-                  :keepalive => 'keepalive123'
-              }
-          }}
+                :config => 'config123',
+                :verify_host_key => 'verify123',
+                :port => 'port123',
+                :forward_agent => 'forwardagent123',
+                :keys => 'keys123',
+                :keepalive => 'keepalive123',
+              },
+            }
+          end
 
           before do
             expect(parser).to receive(:normalize_args).and_return(true)
           end
 
           def mock_out_parsing
-            presets_obj = double()
+            presets_obj = double
             allow(presets_obj).to receive(:presets).and_return(presets)
             allow(presets_obj).to receive(:env_vars).and_return(env)
             parser.instance_variable_set(:@presets, presets_obj)
 
-            command_line_parser_obj = double()
+            command_line_parser_obj = double
             allow(command_line_parser_obj).to receive(:parse).and_return(argv)
             parser.instance_variable_set(:@command_line_parser, command_line_parser_obj)
 
@@ -190,7 +195,7 @@ module Beaker
             allow(parser).to receive(:parse_hosts_options).and_return(host_file)
 
             allow(SubcommandOptionsParser).to receive(:parse_options_file).with(".beaker.yml").and_return(project_file)
-            allow(SubcommandOptionsParser).to receive(:parse_subcommand_options).with(anything, "#{ENV['HOME']}/.beaker/subcommand_options.yaml").and_return(homedir_file)
+            allow(SubcommandOptionsParser).to receive(:parse_subcommand_options).with(anything, "#{ENV.fetch('HOME', nil)}/.beaker/subcommand_options.yaml").and_return(homedir_file)
             allow(SubcommandOptionsParser).to receive(:parse_subcommand_options).with(anything, Pathname(".beaker/subcommand_options.yaml")).and_return(subcommand_file)
           end
 
@@ -290,7 +295,7 @@ module Beaker
             mock_out_parsing
 
             project_file[:options_file] = 'my_options_file.rb'
-            allow(OptionsFileParser).to receive(:parse_options_file).with('my_options_file.rb').and_return(ssh: {config: true})
+            allow(OptionsFileParser).to receive(:parse_options_file).with('my_options_file.rb').and_return(ssh: { config: true })
 
             output = parser.parse_args([])
             attribution = parser.attribution
@@ -307,7 +312,6 @@ module Beaker
             expect(output[:level]).to eq('seventh')
             expect(attribution[:level]).to eq('project')
           end
-
         end
 
         it "can correctly combine arguments from different sources" do
@@ -315,7 +319,7 @@ module Beaker
           type      = 'git'
           log_level = 'debug'
 
-          old_build_url    = ENV["BUILD_URL"]
+          old_build_url    = ENV.fetch("BUILD_URL", nil)
           ENV["BUILD_URL"] = build_url
 
           args   = ["-h", hosts_path, "--log-level", log_level, "--type", type, "--install", "PUPPET/1.0,HIERA/hello"]
@@ -338,20 +342,19 @@ module Beaker
       end
 
       describe '#parse_hosts_options' do
-
         context 'Hosts file exists' do
           before do
             allow(File).to receive(:exist?).and_return(true)
           end
 
           it 'returns the parser\'s output' do
-            parser.instance_variable_set( :@options, {} )
+            parser.instance_variable_set(:@options, {})
             test_value = 'blaqwetjijl,emikfuj1235'
-            allow( Beaker::Options::HostsFileParser ).to receive(
-              :parse_hosts_file
-            ).and_return( test_value )
-            val1, _ = parser.parse_hosts_options
-            expect( val1 ).to be === test_value
+            allow(Beaker::Options::HostsFileParser).to receive(
+              :parse_hosts_file,
+            ).and_return(test_value)
+            val1, = parser.parse_hosts_options
+            expect(val1).to be === test_value
           end
         end
 
@@ -362,54 +365,58 @@ module Beaker
           end
 
           it 'calls beaker-hostgenerator to get hosts information' do
-            parser.instance_variable_set( :@options, {
-              :hosts_file => 'notafile.yml'
-            } )
-            allow( Beaker::Options::HostsFileParser ).to receive(
-              :parse_hosts_file
-            ).and_raise( Errno::ENOENT )
+            old_beaker_hypervisor = ENV.delete('BEAKER_HYPERVISOR')
+
+            parser.instance_variable_set(:@options, {
+                                           :hosts_file => 'notafile.yml',
+                                         })
+            allow(Beaker::Options::HostsFileParser).to receive(
+              :parse_hosts_file,
+            ).and_raise(Errno::ENOENT)
 
             mock_beaker_hostgenerator_cli = Object.new
             cli_execute_return = 'job150865'
-            expect( mock_beaker_hostgenerator_cli ).to receive(
-              :execute
-            ).and_return( cli_execute_return )
-            expect( BeakerHostGenerator::CLI ).to receive(
-              :new
+            expect(mock_beaker_hostgenerator_cli).to receive(
+              :execute,
+            ).and_return(cli_execute_return)
+            expect(BeakerHostGenerator::CLI).to receive(
+              :new,
             ).with(
-              [ 'notafile.yml' ]
-            ).and_return( mock_beaker_hostgenerator_cli )
-            allow( Beaker::Options::HostsFileParser ).to receive(
-              :parse_hosts_string
-            ).with( cli_execute_return )
+              ['notafile.yml'],
+            ).and_return(mock_beaker_hostgenerator_cli)
+            allow(Beaker::Options::HostsFileParser).to receive(
+              :parse_hosts_string,
+            ).with(cli_execute_return)
             parser.parse_hosts_options
+          ensure
+            ENV['BEAKER_HYPERVISOR'] = old_beaker_hypervisor if old_beaker_hypervisor
           end
 
           it 'calls beaker-hostgenerator to get hosts information with a default hypervisor' do
-            old_beaker_hypervisor = ENV['BEAKER_HYPERVISOR']
+            old_beaker_hypervisor = ENV.fetch('BEAKER_HYPERVISOR', nil)
             begin
               ENV['BEAKER_HYPERVISOR'] = 'docker'
 
-              parser.instance_variable_set( :@options, {
-                :hosts_file => 'notafile.yml'
-              } )
-              allow( Beaker::Options::HostsFileParser ).to receive(
-                :parse_hosts_file
-              ).and_raise( Errno::ENOENT )
+              parser.instance_variable_set(:@options, {
+                                             :hosts_file => 'notafile.yml',
+                                           })
+              allow(Beaker::Options::HostsFileParser).to receive(
+                :parse_hosts_file,
+              ).and_raise(Errno::ENOENT)
 
               mock_beaker_hostgenerator_cli = Object.new
               cli_execute_return = 'job150865'
-              expect( mock_beaker_hostgenerator_cli ).to receive(
-                :execute
-              ).and_return( cli_execute_return )
-              expect( BeakerHostGenerator::CLI ).to receive(
-                :new
+              expect(mock_beaker_hostgenerator_cli).to receive(
+                :execute,
+              ).and_return(cli_execute_return)
+              expect(BeakerHostGenerator::CLI).to receive(
+                :new,
               ).with(
-                [ 'notafile.yml', '--hypervisor', 'docker' ]
-              ).and_return( mock_beaker_hostgenerator_cli )
-              allow( Beaker::Options::HostsFileParser ).to receive(
-                :parse_hosts_string
-              ).with( cli_execute_return )
+                ['notafile.yml', '--hypervisor', 'docker'],
+              ).and_return(mock_beaker_hostgenerator_cli)
+              allow(Beaker::Options::HostsFileParser).to receive(
+                :parse_hosts_string,
+              ).with(cli_execute_return)
               parser.parse_hosts_options
             ensure
               ENV['BEAKER_HYPERVISOR'] = old_beaker_hypervisor
@@ -418,73 +425,70 @@ module Beaker
 
           it 'sets the :hosts_file_generated flag to signal others when needed' do
             options_test = {
-              :hosts_file => 'not_a_file.yml'
+              :hosts_file => 'not_a_file.yml',
             }
-            parser.instance_variable_set( :@options, options_test )
-            allow( Beaker::Options::HostsFileParser ).to receive(
-              :parse_hosts_file
-            ).and_raise( Errno::ENOENT )
+            parser.instance_variable_set(:@options, options_test)
+            allow(Beaker::Options::HostsFileParser).to receive(
+              :parse_hosts_file,
+            ).and_raise(Errno::ENOENT)
 
             mock_beaker_hostgenerator_cli = Object.new
-            allow( mock_beaker_hostgenerator_cli ).to receive( :execute )
-            allow( BeakerHostGenerator::CLI ).to receive(
-              :new
-            ).and_return( mock_beaker_hostgenerator_cli )
-            allow( Beaker::Options::HostsFileParser ).to receive( :parse_hosts_string )
+            allow(mock_beaker_hostgenerator_cli).to receive(:execute)
+            allow(BeakerHostGenerator::CLI).to receive(
+              :new,
+            ).and_return(mock_beaker_hostgenerator_cli)
+            allow(Beaker::Options::HostsFileParser).to receive(:parse_hosts_string)
             parser.parse_hosts_options
 
-            expect( options_test[:hosts_file_generated] ).to be true
+            expect(options_test[:hosts_file_generated]).to be true
           end
 
           it 'beaker-hostgenerator failures trigger nice prints & a rethrow' do
             options_test = {
-              :hosts_file => 'not_a_file.yml'
+              :hosts_file => 'not_a_file.yml',
             }
-            parser.instance_variable_set( :@options, options_test )
-            allow( Beaker::Options::HostsFileParser ).to receive(
-              :parse_hosts_file
-            ).and_raise( Errno::ENOENT )
+            parser.instance_variable_set(:@options, options_test)
+            allow(Beaker::Options::HostsFileParser).to receive(
+              :parse_hosts_file,
+            ).and_raise(Errno::ENOENT)
 
             mock_beaker_hostgenerator_cli = Object.new
-            expect( BeakerHostGenerator::CLI ).to receive(
-              :new
-            ).and_return( mock_beaker_hostgenerator_cli )
-            expect( mock_beaker_hostgenerator_cli ).to receive(
-              :execute
-            ).and_raise( BeakerHostGenerator::Exceptions::InvalidNodeSpecError )
-            expect( Beaker::Options::HostsFileParser ).not_to receive( :parse_hosts_string )
-            expect( $stdout ).to receive( :puts ).with(
-              /does not exist/
+            expect(BeakerHostGenerator::CLI).to receive(
+              :new,
+            ).and_return(mock_beaker_hostgenerator_cli)
+            expect(mock_beaker_hostgenerator_cli).to receive(
+              :execute,
+            ).and_raise(BeakerHostGenerator::Exceptions::InvalidNodeSpecError)
+            expect(Beaker::Options::HostsFileParser).not_to receive(:parse_hosts_string)
+            expect($stdout).to receive(:puts).with(
+              /does not exist/,
             ).ordered
-            expect( $stderr ).to receive( :puts ).with(
-              /Exiting with an Error/
+            expect($stderr).to receive(:puts).with(
+              /Exiting with an Error/,
             ).ordered
 
-            expect {
+            expect do
               parser.parse_hosts_options
-            }.to raise_error( BeakerHostGenerator::Exceptions::InvalidNodeSpecError )
+            end.to raise_error(BeakerHostGenerator::Exceptions::InvalidNodeSpecError)
           end
 
           it 'can be passed a nil hosts file and get the default hash back' do
-            parser.instance_variable_set( :@options, {} )
+            parser.instance_variable_set(:@options, {})
 
             host_options = parser.parse_hosts_options
             expect(host_options[:HOSTS]).to be === {}
-
           end
         end
-
       end
 
       context "set_default_host!" do
-
-        let(:roles) { @roles || [["master", "agent", "database"], ["agent"]] }
-        let(:node1) { {:node1 => {:roles => roles[0]}} }
-        let(:node2) { {:node2 => {:roles => roles[1]}} }
+        let(:roles) { @roles || [%w[master agent database], ["agent"]] }
+        let(:node1) { { :node1 => { :roles => roles[0] } } }
+        let(:node2) { { :node2 => { :roles => roles[1] } } }
         let(:hosts) { node1.merge(node2) }
 
         it "does nothing if the default host is already set" do
-          @roles = [["master"], ["agent", "default"]]
+          @roles = [["master"], %w[agent default]]
           parser.set_default_host!(hosts)
           expect(hosts[:node1][:roles].include?('default')).to be === false
           expect(hosts[:node2][:roles].include?('default')).to be === true
@@ -498,42 +502,41 @@ module Beaker
         end
 
         it "makes a single node default" do
-          @roles = [["master", "database", "dashboard", "agent"]]
+          @roles = [%w[master database dashboard agent]]
           parser.set_default_host!(node1)
           expect(hosts[:node1][:roles].include?('default')).to be === true
         end
 
         it "makes a single non-master node default" do
-          @roles = [["database", "dashboard", "agent"]]
+          @roles = [%w[database dashboard agent]]
           parser.set_default_host!(node1)
           expect(hosts[:node1][:roles].include?('default')).to be === true
         end
 
         it "raises an error if two nodes are defined as default" do
-          @roles = [["master", "default"], ["default"]]
+          @roles = [%w[master default], ["default"]]
           expect { parser.set_default_host!(hosts) }.to raise_error(ArgumentError)
         end
-
       end
 
       describe "normalize_args" do
         let(:hosts) do
           Beaker::Options::OptionsHash.new.merge({
-                                                     'HOSTS'          => {
-                                                         :master => {
-                                                             :roles    => ["master", "agent", "arbitrary_role"],
-                                                             :platform => 'el-7-x86_64',
-                                                             :user     => 'root',
-                                                         },
-                                                         :agent  => {
-                                                             :roles    => ["agent", "default", "other_abitrary_role"],
-                                                             :platform => 'el-7-x86_64',
-                                                             :user     => 'root',
-                                                         },
+                                                   'HOSTS' => {
+                                                     :master => {
+                                                       :roles => %w[master agent arbitrary_role],
+                                                       :platform => 'el-7-x86_64',
+                                                       :user => 'root',
+                                                     },
+                                                     :agent => {
+                                                       :roles => %w[agent default other_abitrary_role],
+                                                       :platform => 'el-7-x86_64',
+                                                       :user => 'root',
                                                      },
-                                                     'fail_mode'      => 'slow',
-                                                     'preserve_hosts' => 'always',
-                                                     'host_tags'      => {}
+                                                   },
+                                                   'fail_mode' => 'slow',
+                                                   'preserve_hosts' => 'always',
+                                                   'host_tags' => {},
                                                  })
         end
 
@@ -547,7 +550,6 @@ module Beaker
         end
 
         shared_examples_for('a platform supporting only agents') do |platform, _type|
-
           it "restricts #{platform} hosts to agent" do
             args = []
             args << '--hosts' << fake_hosts_file_for_platform(hosts, platform)
@@ -561,16 +563,15 @@ module Beaker
         end
 
         context "ssh user" do
-
           it 'uses the ssh[:user] if it is provided' do
-            hosts['HOSTS'][:master][:ssh] = {:user => 'hello'}
+            hosts['HOSTS'][:master][:ssh] = { :user => 'hello' }
             parser.instance_variable_set(:@options, hosts)
             parser.normalize_args
             expect(hosts['HOSTS'][:master][:user]).to be == 'hello'
           end
 
           it 'uses default user if there is an ssh hash, but no ssh[:user]' do
-            hosts['HOSTS'][:master][:ssh] = {:hello => 'hello'}
+            hosts['HOSTS'][:master][:ssh] = { :hello => 'hello' }
             parser.instance_variable_set(:@options, hosts)
             parser.normalize_args
             expect(hosts['HOSTS'][:master][:user]).to be == 'root'
@@ -582,20 +583,19 @@ module Beaker
             expect(hosts['HOSTS'][:master][:user]).to be == 'root'
           end
         end
-
       end
 
       describe '#normalize_tags!' do
-        let(:test_tag_and      ) { @test_tag_and     || [] }
-        let(:test_tag_or       ) { @test_tag_or      || [] }
-        let(:test_tag_exclude  ) { @test_tag_exclude || [] }
-        let(:options           ) {
+        let(:test_tag_and) { @test_tag_and || [] }
+        let(:test_tag_or) { @test_tag_or || [] }
+        let(:test_tag_exclude) { @test_tag_exclude || [] }
+        let(:options) do
           opts                    = Beaker::Options::OptionsHash.new
           opts[:test_tag_and]     = test_tag_and
           opts[:test_tag_or]      = test_tag_or
           opts[:test_tag_exclude] = test_tag_exclude
           opts
-        }
+        end
 
         it 'does not error if no tags overlap' do
           @test_tag_and     = 'can,tommies,potatoes,plant'
@@ -613,9 +613,9 @@ module Beaker
           parser.instance_variable_set(:@options, options)
 
           parser.normalize_test_tags!
-          expect(options[:test_tag_and]    ).to be === ['can', 'tommies', 'potatoes', 'plant']
-          expect(options[:test_tag_or]     ).to be === ['johnny', 'wordsmith', 'zebra']
-          expect(options[:test_tag_exclude]).to be === ['joey', 'long_running', 'pants']
+          expect(options[:test_tag_and]).to be === %w[can tommies potatoes plant]
+          expect(options[:test_tag_or]).to be === %w[johnny wordsmith zebra]
+          expect(options[:test_tag_exclude]).to be === %w[joey long_running pants]
         end
 
         it 'returns empty arrays for empty strings' do
@@ -625,8 +625,8 @@ module Beaker
           parser.instance_variable_set(:@options, options)
 
           parser.normalize_test_tags!
-          expect(options[:test_tag_and]    ).to be === []
-          expect(options[:test_tag_or]     ).to be === []
+          expect(options[:test_tag_and]).to be === []
+          expect(options[:test_tag_or]).to be === []
           expect(options[:test_tag_exclude]).to be === []
         end
 
@@ -637,9 +637,9 @@ module Beaker
           parser.instance_variable_set(:@options, options)
 
           parser.normalize_test_tags!
-          expect(options[:test_tag_and]    ).to be === ['jerry_and_tom', 'parka']
-          expect(options[:test_tag_or]     ).to be === ['clearly_they', 'neva']
-          expect(options[:test_tag_exclude]).to be === ['leet_speak', 'poland']
+          expect(options[:test_tag_and]).to be === %w[jerry_and_tom parka]
+          expect(options[:test_tag_or]).to be === %w[clearly_they neva]
+          expect(options[:test_tag_exclude]).to be === %w[leet_speak poland]
         end
       end
 
@@ -665,11 +665,11 @@ module Beaker
       describe '#get_hypervisors' do
         it 'returns a unique list' do
           hosts_dupe   = {
-              'vm1' => {hypervisor: 'hi'},
-              'vm2' => {hypervisor: 'hi'},
-              'vm3' => {hypervisor: 'bye'}
+            'vm1' => { hypervisor: 'hi' },
+            'vm2' => { hypervisor: 'hi' },
+            'vm3' => { hypervisor: 'bye' },
           }
-          hosts_single = {'vm1' => {hypervisor: 'hi'}}
+          hosts_single = { 'vm1' => { hypervisor: 'hi' } }
 
           expect(parser.get_hypervisors(hosts_dupe)).to eq(%w(hi bye))
           expect(parser.get_hypervisors(hosts_single)).to eq(%w(hi))
@@ -679,11 +679,11 @@ module Beaker
       describe '#get_roles' do
         it 'returns a unique list' do
           roles_dupe   = {
-              'vm1' => {roles: ['master']},
-              'vm2' => {roles: %w(database dashboard)},
-              'vm3' => {roles: ['bye']}
+            'vm1' => { roles: ['master'] },
+            'vm2' => { roles: %w(database dashboard) },
+            'vm3' => { roles: ['bye'] },
           }
-          roles_single = {'vm1' => {roles: ['hi']}}
+          roles_single = { 'vm1' => { roles: ['hi'] } }
 
           expect(parser.get_roles(roles_dupe)).to eq([['master'], %w(database dashboard), ['bye']])
           expect(parser.get_roles(roles_single)).to eq([['hi']])

data/spec/beaker/options/presets_spec.rb

@@ -2,26 +2,25 @@ require "spec_helper"
 
 module Beaker
   module Options
-
     describe Presets do
-      let(:presets)    { described_class.new }
+      let(:presets) { described_class.new }
 
       it "returns an env_vars OptionsHash" do
         expect(presets.env_vars).to be_instance_of(Beaker::Options::OptionsHash)
       end
 
       it "pulls in env vars of the form ':q_*' and adds them to the :answers of the OptionsHash" do
-         ENV['q_puppet_cloud_install'] = 'n'
-         env = presets.env_vars
-         expect(env[:answers][:q_puppet_cloud_install]).to be === 'n'
-         expect(env[:answers]['q_puppet_cloud_install']).to be === 'n'
-         ENV.delete('q_puppet_cloud_install')
+        ENV['q_puppet_cloud_install'] = 'n'
+        env = presets.env_vars
+        expect(env[:answers][:q_puppet_cloud_install]).to be === 'n'
+        expect(env[:answers]['q_puppet_cloud_install']).to be === 'n'
+        ENV.delete('q_puppet_cloud_install')
       end
 
       it "correctly parses the run_in_parallel array" do
         ENV['BEAKER_RUN_IN_PARALLEL'] = "install,configure"
         env = presets.env_vars
-        expect(env[:run_in_parallel]).to eq(['install', 'configure'])
+        expect(env[:run_in_parallel]).to eq(%w[install configure])
       end
 
       it "removes all empty/nil entries in env_vars" do
@@ -37,7 +36,6 @@ module Beaker
         expect(presets.presets).to have_key(:host_tags)
         expect(presets.presets[:host_tags]).to eq({})
       end
-
     end
   end
 end