beaker-puppet 0.17.1 → 1.0.0

data/spec/beaker-puppet/install_utils/module_utils_spec.rb

@@ -8,6 +8,8 @@ class ClassMixedWithDSLInstallUtils
   include Beaker::DSL::Roles
   include Beaker::DSL::Patterns
 
+  include Beaker::DSL::InstallUtils::ModuleUtils
+
   def logger
     @logger ||= RSpec::Mocks::Double.new('logger').as_null_object
   end

data/spec/beaker-puppet/install_utils/puppet5_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 class ClassMixedWithDSLInstallUtils
   include Beaker::DSL::Outcomes
-  include BeakerPuppet::Install::Puppet5
+  include Beaker::DSL::InstallUtils::Puppet5
 
   def logger
     @logger ||= RSpec::Mocks::Double.new('logger').as_null_object

data/spec/beaker-puppet/install_utils/windows_utils_spec.rb

@@ -0,0 +1,263 @@
+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

data/spec/beaker-puppet/wrappers_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLWrappers
+  include Beaker::DSL::Wrappers
+end
+
+describe ClassMixedWithDSLWrappers do
+  let(:empty_opts) { {'ENV' => {}, :cmdexe => true } }
+
+  describe '#facter' do
+    it 'should split out the options and pass "facter" as first arg to Command' do
+      expect( Beaker::Command ).to receive( :new ).
+        with('facter', [ '-p' ], empty_opts)
+      subject.facter( '-p' )
+    end
+  end
+
+  describe '#cfacter' do
+    it 'should split out the options and pass "cfacter" as first arg to Command' do
+      expect( Beaker::Command ).to receive( :new ).
+        with('cfacter', [ '-p' ], empty_opts)
+      subject.cfacter( '-p' )
+    end
+  end
+
+  describe 'deprecated puppet wrappers' do
+    %w( resource doc kick cert apply master agent filebucket ).each do |sub|
+      it "#{sub} delegates the proper info to #puppet" do
+        expect( subject ).to receive( :puppet ).with( sub, 'blah' )
+        subject.send( "puppet_#{sub}", 'blah')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaker-puppet
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-27 00:00:00.000000000 Z
+date: 2018-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -100,6 +100,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: beaker-vmpooler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -204,12 +218,13 @@ files:
 - acceptance/config/git/acceptance-options.rb
 - acceptance/config/nodes/vagrant-ubuntu-1404.yml
 - acceptance/config/pkg/acceptance-options.rb
-- acceptance/lib/beaker/acceptance/install_utils.rb
 - acceptance/pre_suite/gem/install.rb
 - acceptance/pre_suite/git/install.rb
 - acceptance/pre_suite/pkg/install.rb
 - acceptance/tests/README.md
 - acceptance/tests/backwards_compatible.rb
+- acceptance/tests/clone_git_repo_on_test.rb
+- acceptance/tests/create_tmpdir_on_test.rb
 - acceptance/tests/install_smoke_test.rb
 - acceptance/tests/stub_host.rb
 - acceptance/tests/web_helpers_test.rb
@@ -228,6 +243,7 @@ files:
 - lib/beaker-puppet/install_utils/module_utils.rb
 - lib/beaker-puppet/install_utils/puppet5.rb
 - lib/beaker-puppet/install_utils/puppet_utils.rb
+- lib/beaker-puppet/install_utils/windows_utils.rb
 - lib/beaker-puppet/version.rb
 - lib/beaker-puppet/wrappers.rb
 - lib/beaker/dsl/helpers/facter_helpers.rb
@@ -261,10 +277,13 @@ files:
 - spec/beaker-puppet/helpers/facter_helpers_spec.rb
 - spec/beaker-puppet/helpers/puppet_helpers_spec.rb
 - spec/beaker-puppet/helpers/tk_helpers_spec.rb
+- spec/beaker-puppet/install_utils/ezbake_utils_spec.rb
 - spec/beaker-puppet/install_utils/foss_utils_spec.rb
 - spec/beaker-puppet/install_utils/module_utils_spec.rb
 - spec/beaker-puppet/install_utils/puppet5_spec.rb
 - spec/beaker-puppet/install_utils/puppet_utils_spec.rb
+- spec/beaker-puppet/install_utils/windows_utils_spec.rb
+- spec/beaker-puppet/wrappers_spec.rb
 - spec/helpers.rb
 - spec/spec_helper.rb
 - tasks/ci.rake

data/acceptance/lib/beaker/acceptance/install_utils.rb

@@ -1,58 +0,0 @@
-module Beaker
-  module Acceptance
-    module InstallUtils
-
-      PLATFORM_PATTERNS = {
-        :redhat        => /fedora|el|centos/,
-        :debian        => /debian|ubuntu/,
-        :debian_ruby18 => /debian|ubuntu-lucid|ubuntu-precise/,
-        :solaris_10    => /solaris-10/,
-        :solaris_11    => /solaris-11/,
-        :windows       => /windows/,
-        :sles          => /sles/,
-      }.freeze
-
-      # Installs packages on the hosts.
-      #
-      # @param hosts [Array<Host>] Array of hosts to install packages to.
-      # @param package_hash [Hash{Symbol=>Array<String,Array<String,String>>}]
-      #   Keys should be a symbol for a platform in PLATFORM_PATTERNS.  Values
-      #   should be an array of package names to install, or of two element
-      #   arrays where a[0] is the command we expect to find on the platform
-      #   and a[1] is the package name (when they are different).
-      # @param options [Hash{Symbol=>Boolean}]
-      # @option options [Boolean] :check_if_exists First check to see if
-      #   command is present before installing package.  (Default false)
-      # @return true
-      def install_packages_on(hosts, package_hash, options = {})
-        return true if hosts == nil
-        check_if_exists = options[:check_if_exists]
-        hosts = [hosts] unless hosts.kind_of?(Array)
-        hosts.each do |host|
-          package_hash.each do |platform_key,package_list|
-            if pattern = PLATFORM_PATTERNS[platform_key]
-              if pattern.match(host['platform'])
-                package_list.each do |cmd_pkg|
-                  if cmd_pkg.kind_of?(Array)
-                    command, package = cmd_pkg
-                  else
-                    command = package = cmd_pkg
-                  end
-                  if !check_if_exists || !host.check_for_package(command)
-                    host.logger.notify("Installing #{package}")
-                    additional_switches = '--allow-unauthenticated' if platform_key == :debian
-                    host.install_package(package, additional_switches)
-                  end
-                end
-              end
-            else
-              raise("Unknown platform '#{platform_key}' in package_hash")
-            end
-          end
-        end
-        return true
-      end
-
-    end
-  end
-end