beaker 3.37.0 → 4.0.0

data/spec/beaker/dsl/ezbake_utils_spec.rb

@@ -1,279 +0,0 @@
-require 'spec_helper'
-
-EZBAKE_CONFIG_EXAMPLE= {
-  :project => 'puppetserver',
-  :real_name => 'puppetserver',
-  :user => 'puppet',
-  :group => 'puppet',
-  :uberjar_name => 'puppetserver-release.jar',
-  :config_files => [],
-  :terminus_info => {},
-  :debian => { :additional_dependencies => ["puppet (= 3.6.1-puppetlabs1)"], },
-  :redhat => { :additional_dependencies => ["puppet = 3.6.1"], },
-  :java_args => '-Xmx192m',
-}
-
-class ClassMixedWithEZBakeUtils
-  include Beaker::DSL::EZBakeUtils
-
-  def initialize_ezbake_config
-    Beaker::DSL::EZBakeUtils.config = EZBAKE_CONFIG_EXAMPLE
-  end
-
-  def wipe_out_ezbake_config
-    Beaker::DSL::EZBakeUtils.config = nil
-  end
-
-  def logger
-    @logger ||= RSpec::Mocks::Double.new('logger').as_null_object
-  end
-end
-
-module Beaker::DSL::EZBakeUtils::EZBake
-  Config = EZBAKE_CONFIG_EXAMPLE
-end
-
-describe ClassMixedWithEZBakeUtils do
-  let( :opts ) { Beaker::Options::Presets.env_vars }
-  let( :host ) { double.as_null_object }
-  let( :local_commands ) { Beaker::DSL::EZBakeUtils::LOCAL_COMMANDS_REQUIRED }
-
-  describe '#install_from_ezbake' do
-    let(:platform) { Beaker::Platform.new('el-7-i386') }
-    let(:host) do
-      FakeHost.create('fakevm', platform.to_s)
-    end
-
-    before do
-      allow(subject).to receive(:ezbake_tools_available?) { true }
-    end
-
-    it "when ran with an el-7 machine runs correct installsh command" do
-      expect(subject).to receive(:install_ezbake_tarball_on_host).
-                          ordered
-      expect(subject).
-        to receive(:ezbake_installsh).with(host, "service")
-      subject.install_from_ezbake host
-    end
-  end
-
-  describe '#install_termini_from_ezbake' do
-    let(:platform) { Beaker::Platform.new('el-7-i386') }
-    let(:host) do
-      FakeHost.create('fakevm', platform.to_s)
-    end
-
-    before do
-      allow(subject).to receive(:ezbake_tools_available?) { true }
-    end
-
-    it "when ran with an el-7 machine runs correct installsh command" do
-      expect(subject).to receive(:ezbake_validate_support).with(host).ordered
-      expect(subject).to receive(:install_ezbake_tarball_on_host).
-                          with(host).ordered
-      expect(subject).
-        to receive(:ezbake_installsh).with(host, "termini")
-      subject.install_termini_from_ezbake host
-    end
-  end
-
-  describe '#ezbake_validate_support' do
-    context 'when OS supported' do
-      let(:platform) { Beaker::Platform.new('el-7-i386') }
-      let(:host) do
-        FakeHost.create('fakevm', platform.to_s)
-      end
-
-      it 'should do nothing' do
-        subject.ezbake_validate_support host
-      end
-    end
-
-    context 'when OS not supported' do
-      let(:platform) { Beaker::Platform.new('aix-12-ppc') }
-      let(:host) do
-        FakeHost.create('fakevm', platform.to_s)
-      end
-
-      it 'should throw exception' do
-        expect {
-          subject.ezbake_validate_support host
-        }.to raise_error(RuntimeError,
-                         "No support for aix within ezbake_utils ...")
-      end
-    end
-  end
-
-  def install_ezbake_tarball_on_host_common_expects
-    result = object_double(Beaker::Result.new(host, "foo"), :exit_code => 1)
-    expect(subject).to receive(:on).
-                        with(kind_of(Beaker::Host), /test -d/,
-                             anything()).ordered { result }
-    expect(Dir).to receive(:chdir).and_yield()
-    expect(subject).to receive(:ezbake_local_cmd).with(/rake package:tar/).ordered
-    expect(subject).to receive(:scp_to).
-                        with(kind_of(Beaker::Host), anything(), anything()).ordered
-    expect(subject).to receive(:on).
-                        with(kind_of(Beaker::Host), /tar -xzf/).ordered
-    expect(subject).to receive(:on).
-                        with(kind_of(Beaker::Host), /test -d/).ordered
-  end
-
-  describe '#install_ezbake_tarball_on_host' do
-    let(:platform) { Beaker::Platform.new('el-7-i386') }
-    let(:host) do
-      FakeHost.create('fakevm', platform.to_s)
-    end
-
-    it 'when invoked with configuration should run expected tasks' do
-      subject.initialize_ezbake_config
-      install_ezbake_tarball_on_host_common_expects
-      subject.install_ezbake_tarball_on_host host
-    end
-
-    it 'when invoked with nil configuration runs ezbake_stage' do
-      subject.wipe_out_ezbake_config
-      expect(subject).to receive(:ezbake_stage) {
-        Beaker::DSL::EZBakeUtils.config = EZBAKE_CONFIG_EXAMPLE
-      }.ordered
-      install_ezbake_tarball_on_host_common_expects
-      subject.install_ezbake_tarball_on_host host
-    end
-  end
-
-  describe '#ezbake_tools_available?' do
-    before do
-      allow(subject).to receive(:check_for_package) { true }
-      allow(subject).to receive(:system) { true }
-    end
-
-    describe "checks for local successful commands" do
-
-      it "and succeeds if all commands return successfully" do
-        local_commands.each do |software_name, command, additional_error_messages|
-          expect(subject).to receive(:system).with(/#{command}/)
-        end
-        subject.ezbake_tools_available?
-      end
-
-      it "and raises an exception if a command returns failure" do
-        allow(subject).to receive(:system) { false }
-        local_commands.each do |software_name, command, additional_error_messages|
-          expect(subject).to receive(:system).with(/#{command}/)
-          break # just need first element
-        end
-        expect{
-          subject.ezbake_tools_available?
-        }.to raise_error(RuntimeError, /Must have .* installed on development system./)
-      end
-
-    end
-
-  end
-
-  describe '#ezbake_config' do
-    it "returns a map with ezbake configuration parameters" do
-      subject.initialize_ezbake_config
-      config = subject.ezbake_config
-      expect(config).to include(EZBAKE_CONFIG_EXAMPLE)
-    end
-  end
-
-  describe '#ezbake_stage' do
-    before do
-      allow(subject).to receive(:ezbake_tools_available?) { true }
-      subject.wipe_out_ezbake_config
-    end
-
-    it "initializes EZBakeUtils.config" do
-      allow(Dir).to receive(:chdir).and_yield()
-
-      expect(subject).to receive(:ezbake_local_cmd).
-                          with(/^lein.*install/, :throw_on_failure =>
-                                                 true).ordered
-      expect(subject).to receive(:ezbake_local_cmd).
-                          with(/^lein.*with-profile ezbake ezbake stage/, :throw_on_failure =>
-                                                 true).ordered
-      expect(subject).to receive(:ezbake_local_cmd).with("rake package:bootstrap").ordered
-      expect(subject).to receive(:load) { }.ordered
-      expect(subject).to receive(:`).ordered
-
-      config = subject.ezbake_config
-      expect(config).to eq(nil)
-
-      subject.ezbake_stage
-
-      config = subject.ezbake_config
-      expect(config).to include(EZBAKE_CONFIG_EXAMPLE)
-    end
-  end
-
-  describe '#ezbake_local_cmd' do
-    it 'should execute system on the command specified' do
-      expect(subject).to receive(:system).with("my command") { true }
-      subject.ezbake_local_cmd("my command")
-    end
-
-    it 'with :throw_on_failure should throw exeception when failed' do
-      expect(subject).to receive(:system).with("my failure") { false }
-      expect {
-        subject.ezbake_local_cmd("my failure", :throw_on_failure => true)
-      }.to raise_error(RuntimeError, "Command failure my failure")
-    end
-
-    it 'without :throw_on_failure should just fail and return false' do
-      expect(subject).to receive(:system).with("my failure") { false }
-      expect(subject.ezbake_local_cmd("my failure")).to eq(false)
-    end
-  end
-
-  describe '#ezbake_install_name' do
-    it 'should return the installation name from example configuration' do
-      expect(subject).to receive(:ezbake_config) {{
-        :package_version => '1.1.1',
-        :project => 'myproject',
-      }}
-      expect(subject.ezbake_install_name).to eq "myproject-1.1.1"
-    end
-  end
-
-  describe '#ezbake_install_dir' do
-    it 'should return the full path from ezbake_install_name' do
-      expect(subject).to receive(:ezbake_install_name) {
-        "mynewproject-2.3.4"
-      }
-      expect(subject.ezbake_install_dir).to eq "/root/mynewproject-2.3.4"
-    end
-  end
-
-  describe '#ezbake_installsh' do
-    it 'run on command correctly when invoked' do
-      expect(subject).to receive(:on).with(host,
-                                           /install.sh my_task/)
-      subject.ezbake_installsh host, "my_task"
-    end
-  end
-
-  describe '#conditionally_clone' do
-    it 'when repo exists, just do fetch and checkout' do
-      expect(subject).to receive(:ezbake_local_cmd).
-        with(/git status/) { true }
-      expect(subject).to receive(:ezbake_local_cmd).
-        with(/git fetch origin/)
-      expect(subject).to receive(:ezbake_local_cmd).
-        with(/git checkout/)
-      subject.conditionally_clone("my_url", "my_local_path")
-    end
-
-    it 'when repo does not exist, do clone and checkout' do
-      expect(subject).to receive(:ezbake_local_cmd).
-                          with(/git status/) { false }
-      expect(subject).to receive(:ezbake_local_cmd).
-                          with(/git clone/)
-      expect(subject).to receive(:ezbake_local_cmd).
-                          with(/git checkout/)
-      subject.conditionally_clone("my_url", "my_local_path")
-    end
-  end
-
-end

data/spec/beaker/dsl/install_utils/pe_defaults_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-class ClassMixedWithDSLInstallUtils
-  include Beaker::DSL::InstallUtils
-  include Beaker::DSL::Wrappers
-  include Beaker::DSL::Helpers
-  include Beaker::DSL::Structure
-  include Beaker::DSL::Roles
-  include Beaker::DSL::Patterns
-
-  attr_accessor :hosts
-
-  def logger
-    @logger ||= RSpec::Mocks::Double.new('logger').as_null_object
-  end
-end
-
-describe ClassMixedWithDSLInstallUtils do
-  let(:presets)       { Beaker::Options::Presets.new }
-  let(:opts)          { presets.presets.merge(presets.env_vars) }
-  let(:basic_hosts)   { make_hosts( { :pe_ver => @pe_ver || '3.0',
-                                       :platform => 'linux',
-                                       :roles => [ 'agent' ] }, 4 ) }
-  let(:hosts)         { basic_hosts[0][:roles] = ['master', 'database', 'dashboard']
-                        basic_hosts[1][:platform] = 'windows'
-                        basic_hosts[2][:platform] = 'osx-10.9-x86_64'
-                        basic_hosts[3][:platform] = 'eos'
-                        basic_hosts  }
-  let(:hosts_sorted)  { [ hosts[1], hosts[0], hosts[2], hosts[3] ] }
-  let(:winhost)       { make_host( 'winhost', { :platform => 'windows',
-                                                :pe_ver => '3.0',
-                                                :working_dir => '/tmp' } ) }
-  let(:machost)       { make_host( 'machost', { :platform => 'osx-10.9-x86_64',
-                                                :pe_ver => '3.0',
-                                                :working_dir => '/tmp' } ) }
-  let(:unixhost)      { make_host( 'unixhost', { :platform => 'linux',
-                                                 :pe_ver => '3.0',
-                                                 :working_dir => '/tmp',
-                                                 :dist => 'puppet-enterprise-3.1.0-rc0-230-g36c9e5c-debian-7-i386' } ) }
-  let(:eoshost)       { make_host( 'eoshost', { :platform => 'eos',
-                                                :pe_ver => '3.0',
-                                                :working_dir => '/tmp',
-                                                :dist => 'puppet-enterprise-3.7.1-rc0-78-gffc958f-eos-4-i386' } ) }
-
-  describe '#add_platform_pe_defaults' do
-    it 'sets puppetservice on master to be pe-httpd on pre-3.4 pe' do
-      @pe_ver = '3.3'
-      subject.add_platform_pe_defaults(hosts[0], 'unix')
-      expect(hosts[0]['puppetservice']).to be == 'pe-httpd'
-
-    end
-
-    it 'sets puppetservice on master to be pe-puppetserver on post-3.4 pe' do
-      @pe_ver = '3.7'
-      subject.add_platform_pe_defaults(hosts[0], 'unix')
-      expect(hosts[0]['puppetservice']).to be == 'pe-puppetserver'
-    end
-
-  end
-
-end

data/spec/beaker/dsl/install_utils/windows_utils_spec.rb

@@ -1,263 +0,0 @@
-require 'spec_helper'
-
-class ClassMixedWithDSLInstallUtils
-  include Beaker::DSL::Helpers
-  include Beaker::DSL::Patterns
-  include Beaker::DSL::InstallUtils
-
-  def logger
-    @logger ||= RSpec::Mocks::Double.new('logger').as_null_object
-  end
-end
-
-describe ClassMixedWithDSLInstallUtils do
-  let(:windows_temp)        { 'C:\\Windows\\Temp' }
-  let( :batch_path )        { '/fake/batch/path' }
-  let(:msi_path)            { 'c:\\foo\\puppet.msi' }
-  let(:winhost)             { make_host( 'winhost',
-                            { :platform => Beaker::Platform.new('windows-2008r2-64'),
-                                :pe_ver => '3.0',
-                                :working_dir => '/tmp',
-                                :is_cygwin => true} ) }
-  let(:winhost_non_cygwin)  { make_host( 'winhost_non_cygwin',
-                              { :platform => 'windows',
-                                :pe_ver => '3.0',
-                                :working_dir => '/tmp',
-                                :is_cygwin => 'false' } ) }
-  let(:hosts)              { [ winhost, winhost_non_cygwin ] }
-
-  def expect_install_called(times = hosts.length)
-    result = expect( Beaker::Command ).to receive( :new )
-      .with( /^"#{batch_path}"$/, [], {:cmdexe => true})
-      .exactly( times ).times
-
-    yield result if block_given?
-  end
-
-  def expect_status_called(times = hosts.length)
-    expect( Beaker::Command ).to receive( :new )
-      .with( "sc qc puppet || sc qc pe-puppet", [], {:cmdexe => true} )
-      .exactly( times ).times
-  end
-
-  def expect_version_log_called(times = hosts.length)
-    [
-      "\\\"%ProgramFiles%\\Puppet Labs\\puppet\\misc\\versions.txt\\\"",
-      "\\\"%ProgramFiles(x86)%\\Puppet Labs\\puppet\\misc\\versions.txt\\\"",
-    ].each do |path|
-      expect( Beaker::Command ).to receive( :new )
-        .with( "\"if exist #{path} type #{path}\"", [], {:cmdexe => true} )
-        .exactly( times ).times
-    end
-  end
-
-  def expect_script_matches(hosts, contents)
-    hosts.each do |host|
-      expect( host )
-        .to receive( :do_scp_to ) do |local_path, remote_path|
-          expect(File.read(local_path)).to match(contents)
-        end
-        .and_return( true )
-    end
-  end
-
-  def expect_reg_query_called(times = hosts.length)
-    hosts.each do |host|
-      expect(host).to receive(:is_x86_64?).and_return(:true)
-    end
-
-    expect( Beaker::Command ).to receive( :new )
-      .with(%r{reg query "HKLM\\SOFTWARE\\Wow6432Node\\Puppet Labs\\PuppetInstaller}, [], {:cmdexe => true})
-      .exactly(times).times
-  end
-
-  describe "#install_msi_on" do
-    let( :log_file )    { '/fake/log/file.log' }
-    before :each do
-      allow( subject ).to receive( :on ).and_return( true )
-      allow( subject ).to receive( :create_install_msi_batch_on ).and_return( [batch_path, log_file] )
-    end
-
-    it "will specify a PUPPET_AGENT_STARTUP_MODE of Manual (disabling the service) by default" do
-      expect_install_called
-      expect_status_called
-      expect_reg_query_called
-      expect_version_log_called
-      expect( subject ).to receive( :create_install_msi_batch_on ).with(
-          anything, anything,
-          'PUPPET_AGENT_STARTUP_MODE' => 'Manual')
-      subject.install_msi_on(hosts, msi_path, {})
-    end
-
-    it "allows configuration of PUPPET_AGENT_STARTUP_MODE" do
-      expect_install_called
-      expect_status_called
-      expect_reg_query_called
-      expect_version_log_called
-      value = 'Automatic'
-      expect( subject ).to receive( :create_install_msi_batch_on ).with(
-          anything, anything,
-          'PUPPET_AGENT_STARTUP_MODE' => value)
-      subject.install_msi_on(hosts, msi_path, {'PUPPET_AGENT_STARTUP_MODE' => value})
-    end
-
-    it "will not generate a command to emit a log file without the :debug option set" do
-      expect_install_called
-      expect_status_called
-      expect( Beaker::Command ).not_to receive( :new ).with( /^type .*\.log$/, [], {:cmdexe => true} )
-      subject.install_msi_on(hosts, msi_path)
-    end
-
-    it "will generate a command to emit a log file when the install script fails" do
-      # note a single failure aborts executing against remaining hosts
-      hosts_affected = 1
-
-      expect_install_called(hosts_affected) { |e| e.and_raise }
-      expect_status_called(0)
-
-      expect( Beaker::Command ).to receive( :new ).with( /^type \".*\.log\"$/, [], {:cmdexe => true} ).exactly( hosts_affected ).times
-      expect { subject.install_msi_on(hosts, msi_path) }.to raise_error(RuntimeError)
-    end
-
-    it "will generate a command to emit a log file with the :debug option set" do
-      expect_install_called
-      expect_reg_query_called
-      expect_status_called
-      expect_version_log_called
-
-      expect( Beaker::Command ).to receive( :new ).with( /^type \".*\.log\"$/, [], {:cmdexe => true} ).exactly( hosts.length ).times
-      subject.install_msi_on(hosts, msi_path, {}, { :debug => true })
-    end
-
-    it 'will pass msi_path to #create_install_msi_batch_on as-is' do
-      expect_install_called
-      expect_reg_query_called
-      expect_status_called
-      expect_version_log_called
-      test_path = 'test/path'
-      expect( subject ).to receive( :create_install_msi_batch_on ).with(
-          anything, test_path, anything)
-      subject.install_msi_on(hosts, test_path)
-    end
-
-    it 'will search in Wow6432Node for the remembered startup setting on 64-bit hosts' do
-      expect_install_called
-      expect_status_called
-      expect_version_log_called
-
-      hosts.each do |host|
-        expect(host).to receive(:is_x86_64?).and_return(true)
-      end
-
-      expect( Beaker::Command ).to receive( :new )
-        .with('reg query "HKLM\\SOFTWARE\\Wow6432Node\\Puppet Labs\\PuppetInstaller" /v "RememberedPuppetAgentStartupMode" | findstr Foo', [], {:cmdexe => true})
-        .exactly(hosts.length).times
-
-      subject.install_msi_on(hosts, msi_path, {'PUPPET_AGENT_STARTUP_MODE' => "Foo"})
-    end
-
-    it 'will omit Wow6432Node in the registry search for remembered startup setting on 32-bit hosts' do
-      expect_install_called
-      expect_status_called
-      expect_version_log_called
-
-      hosts.each do |host|
-        expect(host).to receive(:is_x86_64?).and_return(false)
-      end
-
-      expect( Beaker::Command ).to receive( :new )
-        .with('reg query "HKLM\\SOFTWARE\\Puppet Labs\\PuppetInstaller" /v "RememberedPuppetAgentStartupMode" | findstr Foo', [], {:cmdexe => true})
-        .exactly(hosts.length).times
-
-      subject.install_msi_on(hosts, msi_path, {'PUPPET_AGENT_STARTUP_MODE' => "Foo"})
-    end
-  end
-
-  describe '#create_install_msi_batch_on' do
-    let( :tmp         ) { '/tmp/create_install_msi_batch_on' }
-    let( :tmp_slashes ) { tmp.gsub('/', '\\') }
-
-    before :each do
-      FakeFS::FileSystem.add(File.expand_path tmp)
-      hosts.each do |host|
-        allow( host ).to receive( :system_temp_path ).and_return( tmp )
-      end
-    end
-
-    it 'passes msi_path & msi_opts down to #msi_install_script' do
-      allow( winhost ).to receive( :do_scp_to )
-      test_path = '/path/to/test/with/13540'
-      test_opts = { 'key1' => 'val1', 'key2' => 'val2' }
-      expect( subject ).to receive( :msi_install_script ).with(
-        test_path, test_opts, anything )
-      subject.create_install_msi_batch_on(winhost, test_path, test_opts)
-    end
-
-    it 'SCPs to & returns the same batch file path, corrected for slashes' do
-      test_time = Time.now
-      allow( Time ).to receive( :new ).and_return( test_time )
-      timestamp = test_time.strftime('%Y-%m-%d_%H.%M.%S')
-
-      correct_path = "#{tmp_slashes}\\install-puppet-msi-#{timestamp}.bat"
-      expect( winhost ).to receive( :do_scp_to ).with( anything, correct_path, {} )
-      test_path, _ = subject.create_install_msi_batch_on( winhost, msi_path, {} )
-      expect( test_path ).to be === correct_path
-    end
-
-    it 'returns & sends log_path to #msi_install_scripts, corrected for slashes' do
-      allow( winhost ).to receive( :do_scp_to )
-      test_time = Time.now
-      allow( Time ).to receive( :new ).and_return( test_time )
-      timestamp = test_time.strftime('%Y-%m-%d_%H.%M.%S')
-
-      correct_path = "#{tmp_slashes}\\install-puppet-#{timestamp}.log"
-      expect( subject ).to receive( :msi_install_script ).with(
-          anything, anything, correct_path )
-      _, log_path = subject.create_install_msi_batch_on( winhost, msi_path, {} )
-      expect( log_path ).to be === correct_path
-    end
-  end
-
-  describe '#msi_install_script' do
-    let( :log_path ) { '/log/msi_install_script' }
-
-    context 'msi_params parameter' do
-      it 'can take an empty hash' do
-        expected_cmd = /^start \/w msiexec\.exe \/i ".*" \/qn \/L\*V #{log_path}\ .exit/m
-        expect( subject.msi_install_script(msi_path, {}, log_path) ).to match(expected_cmd)
-      end
-
-      it 'uses a key-value pair correctly' do
-        params = { 'tk1' => 'tv1' }
-        expected_cmd = /^start \/w msiexec\.exe \/i ".*" \/qn \/L\*V #{log_path}\ tk1\=tv1/
-        expect( subject.msi_install_script(msi_path, params, log_path) ).to match(expected_cmd)
-      end
-
-      it 'uses multiple key-value pairs correctly' do
-        params = { 'tk1' => 'tv1', 'tk2' => 'tv2' }
-        expected_cmd = /^start \/w msiexec\.exe \/i ".*" \/qn \/L\*V #{log_path}\ tk1\=tv1\ tk2\=tv2/
-        expect( subject.msi_install_script(msi_path, params, log_path) ).to match(expected_cmd)
-      end
-    end
-
-    context 'msi_path parameter' do
-      it "will generate an appropriate command with a MSI file path using non-Windows slashes" do
-        msi_path = 'c:/foo/puppet.msi'
-        expected_cmd = /^start \/w msiexec\.exe \/i "c:\\foo\\puppet.msi" \/qn \/L\*V #{log_path}/
-        expect( subject.msi_install_script(msi_path, {}, log_path) ).to match(expected_cmd)
-      end
-
-      it "will generate an appropriate command with a MSI http(s) url" do
-        msi_url = "https://downloads.puppetlabs.com/puppet.msi"
-        expected_cmd = /^start \/w msiexec\.exe \/i "https\:\/\/downloads\.puppetlabs\.com\/puppet\.msi" \/qn \/L\*V #{log_path}/
-        expect( subject.msi_install_script(msi_url, {}, log_path) ).to match(expected_cmd)
-      end
-
-      it "will generate an appropriate command with a MSI file url" do
-        msi_url = "file://c:\\foo\\puppet.msi"
-        expected_cmd = /^start \/w msiexec\.exe \/i "file\:\/\/c:\\foo\\puppet\.msi" \/qn \/L\*V #{log_path}/
-        expect( subject.msi_install_script(msi_url, {}, log_path) ).to match(expected_cmd)
-      end
-    end
-  end
-end