beaker 1.16.0 → 1.17.0

data/spec/beaker/dsl/install_utils_spec.rb

@@ -4,10 +4,11 @@ class ClassMixedWithDSLInstallUtils
   include Beaker::DSL::InstallUtils
   include Beaker::DSL::Structure
   include Beaker::DSL::Roles
+  include Beaker::DSL::Patterns
 end
 
 describe ClassMixedWithDSLInstallUtils do
-  let(:opts)          { Beaker::Options::Presets.env_vars }
+  let(:opts)          { Beaker::Options::Presets.presets.merge(Beaker::Options::Presets.env_vars) }
   let(:basic_hosts)   { make_hosts( { :pe_ver => '3.0',
                                        :platform => 'linux',
                                        :roles => [ 'agent' ] } ) }
@@ -276,10 +277,6 @@ describe ClassMixedWithDSLInstallUtils do
       subject.stub( :hosts ).and_return( hosts )
       #determine mastercert
       subject.should_receive( :on ).with( hosts[0], /uname/ ).once
-      #create working dirs per-host
-      subject.should_receive( :on ).with( hosts[0], /mkdir/ ).once
-      subject.should_receive( :on ).with( hosts[1], /mkdir/ ).once
-      subject.should_receive( :on ).with( hosts[2], /mkdir/ ).once
       #create answers file per-host, except windows
       subject.should_receive( :create_remote_file ).with( hosts[0], /answers/, /q/ ).once
       #run installer on all hosts
@@ -316,6 +313,56 @@ describe ClassMixedWithDSLInstallUtils do
     end
   end
 
+  describe 'do_higgs_install' do
+
+    before :each do
+      my_time = double( "time double" )
+      my_time.stub( :strftime ).and_return( "2014-07-01_15.27.53" )
+      Time.stub( :new ).and_return( my_time )
+
+      hosts[0]['working_dir'] = "tmp/2014-07-01_15.27.53"
+      hosts[0]['dist'] = 'dist'
+      hosts[0]['pe_installer'] = 'pe-installer'
+      hosts[0].stub( :tmpdir ).and_return( "/tmp/2014-07-01_15.27.53" )
+
+      @fail_result = Beaker::Result.new( {}, '' )
+      @fail_result.stdout = "No match here"
+      @success_result = Beaker::Result.new( {}, '' )
+      @success_result.stdout = "Please go to https://website in your browser to continue installation"
+    end
+
+    it 'can perform a simple installation' do
+      subject.stub( :fetch_puppet ).and_return( true )
+      subject.stub( :sleep ).and_return( true )
+
+      subject.stub( :hosts ).and_return( hosts )
+
+      #run higgs installer command
+      subject.should_receive( :on ).with( hosts[0],
+                                         "cd /tmp/2014-07-01_15.27.53/puppet-enterprise-3.0-linux ; nohup ./pe-installer <<<Y > higgs_2014-07-01_15.27.53.log 2>&1 &",
+                                        opts ).once
+      #check to see if the higgs installation has proceeded correctly, works on second check
+      subject.should_receive( :on ).with( hosts[0], /cat #{hosts[0]['higgs_file']}/, { :acceptable_exit_codes => 0..255 }).and_return( @fail_result, @success_result )
+      subject.do_higgs_install( hosts[0], opts )
+    end
+
+    it 'fails out after checking installation log 10 times' do
+      subject.stub( :fetch_puppet ).and_return( true )
+      subject.stub( :sleep ).and_return( true )
+
+      subject.stub( :hosts ).and_return( hosts )
+
+      #run higgs installer command
+      subject.should_receive( :on ).with( hosts[0],
+                                         "cd /tmp/2014-07-01_15.27.53/puppet-enterprise-3.0-linux ; nohup ./pe-installer <<<Y > higgs_2014-07-01_15.27.53.log 2>&1 &",
+                                        opts ).once
+      #check to see if the higgs installation has proceeded correctly, works on second check
+      subject.should_receive( :on ).with( hosts[0], /cat #{hosts[0]['higgs_file']}/, { :acceptable_exit_codes => 0..255 }).exactly(10).times.and_return( @fail_result )
+      expect{ subject.do_higgs_install( hosts[0], opts ) }.to raise_error
+    end
+
+  end
+
   describe '#install_puppet' do
     let(:hosts) do
       make_hosts({:platform => platform })
@@ -381,12 +428,18 @@ describe ClassMixedWithDSLInstallUtils do
     end
     describe 'on unsupported platforms' do
       let(:platform) { 'solaris-11-x86_64' }
+      let(:host) { make_host('henry', :platform => 'solaris-11-x86_64') }
+      let(:hosts) { [host] }
       it 'by default raises an error' do
         expect(subject).to_not receive(:on)
         expect { subject.install_puppet }.to raise_error(/unsupported platform/)
       end
       it 'falls back to installing from gem when given :default_action => "gem_install"' do
-        expect(subject).to receive(:on).with(hosts[0], /gem install/)
+        result = double
+        gem_env_string = '{"RubyGems Environment": [ {"GEM PATHS": [] } ] }'
+        allow( result ).to receive(:stdout).and_return gem_env_string
+        allow(subject).to receive(:on).with(host, /gem environment/).and_return result
+        expect(subject).to receive(:on).with(host, /gem install/)
         subject.install_puppet :default_action => 'gem_install'
       end
     end
@@ -418,6 +471,20 @@ describe ClassMixedWithDSLInstallUtils do
     end
   end
 
+  describe 'install_higgs' do
+    it 'fills in missing pe_ver' do
+      hosts[0]['pe_ver'] = nil
+      Beaker::Options::PEVersionScraper.stub( :load_pe_version ).and_return( '2.8' )
+      subject.stub( :hosts ).and_return( [ hosts[1], hosts[0], hosts[2] ] )
+      subject.stub( :options ).and_return( {} )
+      subject.stub( :do_higgs_install ).and_return( true )
+      subject.should_receive( :do_higgs_install ).with( hosts[0], {} )
+      subject.install_higgs
+      expect( hosts[0]['pe_ver'] ).to be === '2.8'
+    end
+
+  end
+
   describe 'upgrade_pe' do
 
     it 'calls puppet-enterprise-upgrader for pre 3.0 upgrades' do
@@ -518,7 +585,7 @@ describe ClassMixedWithDSLInstallUtils do
   describe "#install_puppetlabs_release_repo" do
     let( :platform ) { Beaker::Platform.new('solaris-7-i386') }
     let( :host ) do
-      FakeHost.new( :options => { 'platform' => platform })
+      FakeHost.create('fakevm', platform.to_s)
     end
 
     before do
@@ -585,9 +652,7 @@ describe ClassMixedWithDSLInstallUtils do
     let( :package_name ) { "puppet" }
     let( :package_version ) { "7.5.6" }
     let( :host ) do
-      FakeHost.new( :options => opts.merge({
-        'platform' => platform,
-      }))
+      FakeHost.create('fakvm', platform.to_s, opts)
     end
 
     describe "When host is unsupported platform" do

data/spec/beaker/dsl/roles_spec.rb

@@ -12,7 +12,7 @@ describe ClassMixedWithDSLRoles do
   let( :agent1 )     { make_host( 'agent1',     { :roles => [ 'agent' ] } ) }
   let( :agent2 )     { make_host( 'agent2',     { :roles => [ 'agent' ] } ) }
   let( :a_and_dash ) { make_host( 'a_and_dash', { :roles => [ 'agent', 'dashboard' ] } ) }
-  let( :custom )     { make_host( 'custom',     { :roles => [ 'custome_role' ] } ) }
+  let( :custom )     { make_host( 'custom',     { :roles => [ 'custom_role' ] } ) }
   let( :db )         { make_host( 'db',         { :roles => [ 'database' ] } ) }
   let( :master )     { make_host( 'master',     { :roles => [ 'master', 'agent' ] } ) }
   let( :default )    { make_host( 'default',    { :roles => [ 'default'] } ) }
@@ -94,4 +94,39 @@ describe ClassMixedWithDSLRoles do
       expect { subject.database }.to raise_error Beaker::DSL::FailTest
     end
   end
+  describe '#add_role_def' do
+    it 'raises an error on unsupported role format "1role"' do
+      expect { subject.add_role_def( "1role" ) }.to raise_error
+    end
+    it 'raises an error on unsupported role format "role_!a"' do
+      expect { subject.add_role_def( "role_!a" ) }.to raise_error
+    end
+    it 'raises an error on unsupported role format "role=="' do
+      expect { subject.add_role_def( "role==" ) }.to raise_error
+    end
+    it 'creates new method for role "role_correct!"' do
+      test_role = "role_correct!"
+      subject.add_role_def( test_role )
+      subject.should respond_to test_role
+      subject.class.send( :undef_method, test_role )
+    end
+    it 'returns a single node for a new method for a role defined in a single node' do
+      @hosts = [ agent1, agent2, monolith ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      test_role = "custom_role"
+      subject.add_role_def( test_role )
+      subject.should respond_to test_role
+      expect( subject.send( test_role )).to be == @hosts[2]
+      subject.class.send( :undef_method, test_role )
+    end
+    it 'returns an array of nodes for a new method for a role defined in multiple nodes' do
+      @hosts = [ agent1, agent2, monolith, custom ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      test_role = "custom_role"
+      subject.add_role_def( test_role )
+      subject.should respond_to test_role
+      expect( subject.send( test_role )).to be == [@hosts[2], @hosts[3]]
+      subject.class.send( :undef_method, test_role )
+    end
+  end
 end

data/spec/beaker/host_prebuilt_steps_spec.rb

@@ -17,7 +17,8 @@ describe Beaker do
                            hosts[1][:roles] = ['master', 'dashboard', 'agent', 'database']
                            hosts[2][:roles] = ['agent']
                            hosts }
-  let( :dummy_class )    { Class.new { include Beaker::HostPrebuiltSteps } }
+  let( :dummy_class )    { Class.new { include Beaker::HostPrebuiltSteps
+                                       include Beaker::DSL::Patterns } }
 
   context 'timesync' do
 
@@ -271,10 +272,25 @@ describe Beaker do
           host.should_receive( :check_for_package ).with( pkg ).once.and_return( false )
           host.should_receive( :install_package ).with( pkg ).once
         end
-        
       end
 
-      subject.validate_host(hosts, logger)
+      subject.validate_host(hosts, options)
+
+    end
+
+    it "can validate unix hosts that need sysstat installed" do
+      total_pkgs = Array.new(unix_only_pkgs);
+      total_pkgs << "sysstat"
+
+      hosts.each do |host|
+        total_pkgs.each do |pkg|
+          host.should_receive( :check_for_package ).with( pkg ).once.and_return( false )
+          host.should_receive( :install_package ).with( pkg ).once
+        end
+      end
+
+      opts = options.merge({:collect_perf_data => true})
+      subject.validate_host(hosts, opts)
 
     end
 
@@ -288,7 +304,7 @@ describe Beaker do
         end
       end
 
-      subject.validate_host(hosts, logger)
+      subject.validate_host(hosts, options)
 
     end
 
@@ -303,7 +319,7 @@ describe Beaker do
 
       end
 
-      subject.validate_host(hosts, logger)
+      subject.validate_host(hosts, options)
 
     end
   end

data/spec/beaker/host_spec.rb

@@ -24,6 +24,86 @@ module Beaker
       expect( host['value'] ).to be === 'blarg'
     end
 
+    describe "host types" do
+      let(:options) { Beaker::Options::OptionsHash.new }
+
+      it "can be a pe host" do
+        options['type'] = 'pe'
+        expect(host.is_pe?).to be_true
+        expect(host.use_service_scripts?).to be_true
+        expect(host.is_using_passenger?).to be_true
+        expect(host.graceful_restarts?).to be_false
+      end
+
+      it "can be a foss-source host" do
+        expect(host.is_pe?).to be_false
+        expect(host.use_service_scripts?).to be_false
+        expect(host.is_using_passenger?).to be_false
+      end
+
+      it "can be a foss-package host" do
+        options['use-service'] = true
+        expect(host.is_pe?).to be_false
+        expect(host.use_service_scripts?).to be_true
+        expect(host.is_using_passenger?).to be_false
+        expect(host.graceful_restarts?).to be_false
+      end
+
+      it "can be a foss-packaged host using passenger" do
+        host.uses_passenger!
+        expect(host.is_pe?).to be_false
+        expect(host.use_service_scripts?).to be_true
+        expect(host.is_using_passenger?).to be_true
+        expect(host.graceful_restarts?).to be_true
+      end
+    end
+
+    describe "uses_passenger!" do
+      it "sets passenger property" do
+        host.uses_passenger!
+        expect(host['passenger']).to be_true
+        expect(host.is_using_passenger?).to be_true
+      end
+
+      it "sets puppetservice" do
+        host.uses_passenger!('servicescript')
+        expect(host['puppetservice']).to eq('servicescript')
+      end
+
+      it "sets puppetservice to apache2 by default" do
+        host.uses_passenger!
+        expect(host['puppetservice']).to eq('apache2')
+      end
+    end
+
+    describe "graceful_restarts?" do
+      it "is true if graceful-restarts property is set true" do
+        options['graceful-restarts'] = true
+        expect(host.graceful_restarts?).to be_true
+      end
+
+      it "is false if graceful-restarts property is set false" do
+        options['graceful-restarts'] = false
+        expect(host.graceful_restarts?).to be_false
+      end
+
+      it "is false if is_pe and graceful-restarts is nil" do
+        options['type'] = 'pe'
+        expect(host.graceful_restarts?).to be_false
+      end
+
+      it "is true if is_pe and graceful-restarts is true" do
+        options['type'] = 'pe'
+        options['graceful-restarts'] = true
+        expect(host.graceful_restarts?).to be_true
+      end
+
+      it "falls back to passenger property if not pe and graceful-restarts is nil" do
+        host.uses_passenger!
+        expect(host.graceful_restarts?).to be_true
+      end
+    end
+
     describe "windows hosts" do
       describe "install_package" do
         let(:cygwin) { 'setup-x86.exe' }
@@ -148,40 +228,124 @@ module Beaker
       end
     end
 
-    # it takes a location and a destination
-    # it basically proxies that to the connection object
-    it 'do_scp_to logs info and proxies to the connection' do
-      logger = host[:logger]
-      conn = double(:connection)
-      @options = { :logger => logger }
-      host.instance_variable_set :@connection, conn
-      args = [ 'source', 'target', {} ]
-      conn_args = args + [ nil ]
+    context 'do_scp_to' do
+      # it takes a location and a destination
+      # it basically proxies that to the connection object
+      it 'do_scp_to logs info and proxies to the connection' do
+        File.stub(:file?).and_return(true)
+        logger = host[:logger]
+        conn = double(:connection)
+        @options = { :logger => logger }
+        host.instance_variable_set :@connection, conn
+        args = [ 'source', 'target', {} ]
+        conn_args = args + [ nil ]
+
+        logger.should_receive(:debug)
+        conn.should_receive(:scp_to).with( *conn_args ).and_return(Beaker::Result.new(host, 'output!'))
+
+        host.do_scp_to *args
+      end
+
+      context "using an ignore array" do
+
+        before :each do
+          test_dir = 'tmp/tests'
+          other_test_dir = 'tmp/tests2'
+
+          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'              ]
 
-      logger.should_receive(:debug)
-      conn.should_receive(:scp_to).with( *conn_args )
+          @fileset1 = files.shuffle.map {|file| test_dir + '/' + file }
+          @fileset2 = files.shuffle.map {|file| other_test_dir + '/' + file }
 
-      host.do_scp_to *args
+          create_files( @fileset1 )
+          create_files( @fileset2 )
+        end
+
+        it 'can take an ignore list that excludes all files and not call scp_to', :use_fakefs => true do
+          logger = host[:logger]
+          conn = double(:connection)
+          @options = { :logger => logger }
+          host.instance_variable_set :@connection, conn
+          args = [ 'tmp', 'target', {:ignore => ['tests', 'tests2']} ]
+
+          logger.should_receive(:debug)
+          host.should_receive( :mkdir_p ).exactly(0).times
+          conn.should_receive(:scp_to).exactly(0).times
+
+          host.do_scp_to *args
+        end
+
+        it 'can take an ignore list that excludes a single file and scp the rest', :use_fakefs => true do
+          exclude_file = '07_InstallCACerts.rb'
+          logger = host[:logger]
+          conn = double(:connection)
+          @options = { :logger => logger }
+          host.instance_variable_set :@connection, conn
+          args = [ 'tmp', 'target', {:ignore => [exclude_file]} ]
+
+          Dir.stub( :glob ).and_return( @fileset1 + @fileset2 )
+
+          logger.should_receive(:debug)
+          host.should_receive( :mkdir_p ).with('target/tmp/tests')
+          host.should_receive( :mkdir_p ).with('target/tmp/tests2')
+          (@fileset1 + @fileset2).each do |file|
+            if file !~ /#{exclude_file}/
+              file_args = [ file, File.join('target', file), {:ignore => [exclude_file]} ]
+              conn_args = file_args + [ nil ]
+              conn.should_receive(:scp_to).with( *conn_args ).and_return(Beaker::Result.new(host, 'output!'))
+            end
+          end
+
+          host.do_scp_to *args
+        end
+
+        it 'can take an ignore list that excludes a dir and scp the rest', :use_fakefs => true do
+          exclude_file = 'tests'
+          logger = host[:logger]
+          conn = double(:connection)
+          @options = { :logger => logger }
+          host.instance_variable_set :@connection, conn
+          args = [ 'tmp', 'target', {:ignore => [exclude_file]} ]
+
+          Dir.stub( :glob ).and_return( @fileset1 + @fileset2 )
+
+          logger.should_receive(:debug)
+          host.should_receive( :mkdir_p ).with('target/tmp/tests2')
+          (@fileset2).each do |file|
+            file_args = [ file, File.join('target', file), {:ignore => [exclude_file]} ]
+            conn_args = file_args + [ nil ]
+            conn.should_receive(:scp_to).with( *conn_args ).and_return(Beaker::Result.new(host, 'output!'))
+          end
+
+          host.do_scp_to *args
+        end
+      end
     end
 
-    it 'do_scp_from logs info and proxies to the connection' do
-      logger = host[:logger]
-      conn = double(:connection)
-      @options = { :logger => logger }
-      host.instance_variable_set :@connection, conn
-      args = [ 'source', 'target', {} ]
-      conn_args = args + [ nil ]
+    context 'do_scp_from' do
+      it 'do_scp_from logs info and proxies to the connection' do
+        logger = host[:logger]
+        conn = double(:connection)
+        @options = { :logger => logger }
+        host.instance_variable_set :@connection, conn
+        args = [ 'source', 'target', {} ]
+        conn_args = args + [ nil ]
 
-      logger.should_receive(:debug)
-      conn.should_receive(:scp_from).with( *conn_args )
+        logger.should_receive(:debug)
+        conn.should_receive(:scp_from).with( *conn_args ).and_return(Beaker::Result.new(host, 'output!'))
 
-      host.do_scp_from *args
+        host.do_scp_from *args
+      end
     end
+
     it 'interpolates to its "name"' do
       expect( "#{host}" ).to be === 'name'
     end
 
-
     context 'merging defaults' do
       it 'knows the difference between foss and pe' do
         @options = { :type => 'pe' }

data/spec/beaker/hypervisor/ec2_helper_spec.rb

@@ -5,19 +5,19 @@ describe Beaker::EC2Helper do
   context ".amiports" do
     let(:ec2) { Beaker::EC2Helper }
     it "can set ports for database host" do
-      expect(ec2.amiports(["database"])).to be === [22, 8080, 8081]
+      expect(ec2.amiports(["database"])).to be === [22, 61613, 8139, 8080, 8081]
     end
 
     it "can set ports for master host" do
-      expect(ec2.amiports(["master"])).to be === [22, 8140]
+      expect(ec2.amiports(["master"])).to be === [22, 61613, 8139, 8140]
     end
 
     it "can set ports for dashboard host" do
-      expect(ec2.amiports(["dashboard"])).to be === [22, 443]
+      expect(ec2.amiports(["dashboard"])).to be === [22, 61613, 8139, 443]
     end
 
     it "can set ports for combined master/database/dashboard host" do
-      expect(ec2.amiports(["dashboard", "master", "database"])).to be === [22, 8080, 8081, 8140, 443]
+      expect(ec2.amiports(["dashboard", "master", "database"])).to be === [22, 61613, 8139, 8080, 8081, 8140, 443]
     end
   end
 end

data/spec/beaker/hypervisor/vagrant_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Beaker
   describe Vagrant do
-    let( :options ) { make_opts.merge({ 'logger' => double().as_null_object }) }
+    let( :options ) { make_opts.merge({ 'logger' => double().as_null_object, :hosts_file => 'sample.cfg' }) }
     let( :vagrant ) { Beaker::Vagrant.new( @hosts, options ) }
 
     before :each do

data/spec/beaker/options/hosts_file_parser_spec.rb

@@ -20,6 +20,11 @@ module Beaker
         expect(config['consoleport']).to be === 443
       end
 
+      it "returns empty configuration when no file provided" do
+        FakeFS.deactivate!
+        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(ArgumentError)

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?) === true
+        expect(options.is_pe?).to be_true
       end
 
       it "supports is_pe?, respects :type == foss" do
         options[:type] = 'foss'
-        expect(options.is_pe?) === false
+        expect(options.is_pe?).to be_false
       end
 
       it "can delete by string of symbol key" do

data/spec/beaker/options/parser_spec.rb

@@ -200,6 +200,12 @@ module Beaker
           expect( hosts[:node1][:roles].include?('default') ).to be === true
         end
 
+        it "makes a single non-master node default" do
+          @roles = [ ["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"] ]
           expect{ parser.set_default_host!(hosts) }.to raise_error(ArgumentError)

data/spec/beaker/options/presets_spec.rb

@@ -11,14 +11,30 @@ module Beaker
       end
 
       it "removes all empty/nil entries in env_vars" do
-        expect(presets.env_vars.has_value?(nil)).to be === false and expect(presets.env_vars.has_value?({})).to be === false
+        expect(presets.env_vars.has_value?(nil)).to be === false
+        expect(presets.env_vars.has_value?({})).to be === false
       end
 
       it "returns a presets OptionsHash" do
         expect(presets.presets).to be_instance_of(Beaker::Options::OptionsHash)
       end
 
-
+      describe 'when setting the type as pe from the environment' do
+        describe 'sets type to pe if...' do
+          it 'env var is set to "true"' do
+            munged = presets.munge_found_env_vars :is_pe => 'true'
+            expect( munged[:type] ).to be == 'pe'
+          end
+          it 'env var is set to "yes"' do
+            munged = presets.munge_found_env_vars :is_pe => 'yes'
+            expect( munged[:type] ).to be == 'pe'
+          end
+        end
+        it 'does not set type otherwise' do
+          munged = presets.munge_found_env_vars :is_pe => 'false'
+          expect( munged[:type] ).to be == nil
+        end
+      end
     end
   end
 end