beaker 2.18.3 → 2.19.0

data/lib/beaker/options/parser.rb

@@ -328,6 +328,7 @@ module Beaker
         end
 
         normalize_and_validate_tags()
+        resolve_symlinks()
 
         #set the default role
         set_default_host!(@options[:HOSTS])
@@ -365,6 +366,17 @@ module Beaker
         end
       end
 
+      # resolves all file symlinks that require it.
+      #
+      # @note doing it here allows us to not need duplicate logic, which we
+      #   would need if we were doing it in the parser (--hosts & --config)
+      #
+      # @return nil
+      # @api public
+      def resolve_symlinks()
+        @options[:hosts_file] = File.realpath(@options[:hosts_file]) if @options[:hosts_file]
+      end
+
       private
 
       # @api private

data/lib/beaker/options/presets.rb

@@ -178,7 +178,6 @@ module Beaker
           :ssh                    => {
                                      :config                => false,
                                      :paranoid              => false,
-                                     :timeout               => 300,
                                      :auth_methods          => ["publickey"],
                                      :port                  => 22,
                                      :forward_agent         => true,

data/lib/beaker/ssh_connection.rb

@@ -6,6 +6,7 @@ module Beaker
   class SshConnection
 
     attr_accessor :logger
+    attr_accessor :ip, :vmhostname, :hostname
 
     RETRYABLE_EXCEPTIONS = [
       SocketError,
@@ -21,41 +22,65 @@ module Beaker
       IOError,
     ]
 
-    def initialize hostname, user = nil, ssh_opts = {}, options = {}
-      @hostname = hostname
+    def initialize name_hash, user = nil, ssh_opts = {}, options = {}
+      @vmhostname = name_hash[:vmhostname]
+      @ip = name_hash[:ip]
+      @hostname = name_hash[:hostname]
       @user = user
       @ssh_opts = ssh_opts
       @logger = options[:logger]
       @options = options
     end
 
-    def self.connect hostname, user = 'root', ssh_opts = {}, options = {}
-      connection = new hostname, user, ssh_opts, options
+    def self.connect name_hash, user = 'root', ssh_opts = {}, options = {}
+      connection = new name_hash, user, ssh_opts, options
       connection.connect
       connection
     end
 
+    def connect_block host, user, ssh_opts
+      try = 1
+      last_wait = 2
+      wait = 3
+      begin
+         @logger.debug "Attempting ssh connection to #{host}, user: #{user}, opts: #{ssh_opts}"
+         Net::SSH.start(host, user, ssh_opts)
+       rescue *RETRYABLE_EXCEPTIONS => e
+         if try <= 8
+           @logger.warn "Try #{try} -- Host #{host} unreachable: #{e.class.name} - #{e.message}"
+           @logger.warn "Trying again in #{wait} seconds"
+           sleep wait
+          (last_wait, wait) = wait, last_wait + wait
+           try += 1
+           retry
+         else
+           @logger.warn "Failed to connect to #{host}, after #{try} attempts"
+           nil
+         end
+       end
+    end
+
     # connect to the host
     def connect
-      try = 1
-      last_wait = 0
-      wait = 1
-      @ssh ||= begin
-                 @logger.debug "Attempting ssh connection to #{@hostname}, user: #{@user}, opts: #{@ssh_opts}"
-                 Net::SSH.start(@hostname, @user, @ssh_opts)
-               rescue *RETRYABLE_EXCEPTIONS => e
-                 if try <= 11
-                   @logger.warn "Try #{try} -- Host #{@hostname} unreachable: #{e.class.name} - #{e.message}"
-                   @logger.warn "Trying again in #{wait} seconds"
-                   sleep wait
-                  (last_wait, wait) = wait, last_wait + wait
-                   try += 1
-                   retry
-                 else
-                   @logger.error "Failed to connect to #{@hostname}"
-                   raise
-                 end
-               end
+      #try three ways to connect to host (ip, vmhostname, hostname)
+      methods = []
+      if @ip
+        @ssh ||= connect_block(@ip, @user, @ssh_opts)
+        methods << "ip (#{@ip})"
+      end
+      if @vmhostname && !@ssh
+        @ssh ||= connect_block(@vmhostname, @user, @ssh_opts)
+        methods << "vmhostname (#{@vmhostname})"
+      end
+      if @hostname && !@ssh
+        @ssh ||= connect_block(@hostname, @user, @ssh_opts)
+        methods << "hostname (#{@hostname})"
+      end
+      if not @ssh
+        @logger.error "Failed to connect to #{@hostname}, attempted #{methods.join(', ')}"
+        raise RuntimeError, "Cannot connect to #{@hostname}"
+      end
+      @ssh
     end
 
     # closes this SshConnection

data/lib/beaker/test_case.rb

@@ -1,4 +1,4 @@
-[ 'host', 'answers', 'dsl' ].each do |lib|
+[ 'host', 'dsl' ].each do |lib|
   require "beaker/#{lib}"
 end
 

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '2.18.3'
+    STRING = '2.19.0'
   end
 end

data/spec/beaker/dsl/helpers/web_helpers_spec.rb

@@ -29,12 +29,21 @@ describe ClassMixedWithDSLHelpers do
 
       it "returns its second and third arguments concatenated." do
         create_files(['destdir/name'])
-        result = subject.fetch_http_file "http://beaker.tool/", "name", "destdir"
+        result = subject.fetch_http_file "http://beaker.tool", "name", "destdir"
         expect(result).to eq("destdir/name")
       end
 
     end
 
+    describe 'given invalid arguments' do
+
+      it 'chomps correctly when given a URL ending with a / character' do
+        expect( subject ).to receive( :open ).with( 'http://beaker.tool/name', anything )
+        subject.fetch_http_file( "http://beaker.tool/", "name", "destdir" )
+      end
+
+    end
+
   end
 
   describe "#fetch_http_dir" do

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

@@ -16,10 +16,11 @@ end
 describe ClassMixedWithDSLInstallUtils do
   let(:metadata)      { @metadata ||= {} }
   let(:presets)       { Beaker::Options::Presets.new }
-  let(:opts)          { presets.presets.merge(presets.env_vars) }
+  let(:opts)          { presets.presets.merge(presets.env_vars).merge({ :type => 'foss' }) }
   let(:basic_hosts)   { make_hosts( { :pe_ver => '3.0',
-                                       :platform => 'linux',
-                                       :roles => [ 'agent' ] }, 4 ) }
+                                      :platform => 'linux',
+                                      :roles => [ 'agent' ],
+                                      :type  => 'foss' }, 4 ) }
   let(:hosts)         { basic_hosts[0][:roles] = ['master', 'database', 'dashboard']
                         basic_hosts[1][:platform] = 'windows'
                         basic_hosts[2][:platform] = 'osx-10.9-x86_64'
@@ -29,13 +30,16 @@ describe ClassMixedWithDSLInstallUtils do
   let(:winhost)       { make_host( 'winhost', { :platform => 'windows',
                                                 :pe_ver => '3.0',
                                                 :working_dir => '/tmp',
+                                                :type => 'foss',
                                                 :is_cygwin => true} ) }
   let(:winhost_non_cygwin) { make_host( 'winhost_non_cygwin', { :platform => 'windows',
                                                 :pe_ver => '3.0',
                                                 :working_dir => '/tmp',
+                                                :type => 'foss',
                                                 :is_cygwin => 'false' } ) }
   let(:machost)       { make_host( 'machost', { :platform => 'osx-10.9-x86_64',
                                                 :pe_ver => '3.0',
+                                                :type => 'foss',
                                                 :working_dir => '/tmp' } ) }
   let(:freebsdhost9)   { make_host( 'freebsdhost9', { :platform => 'freebsd-9-x64',
                                                 :pe_ver => '3.0',
@@ -46,55 +50,60 @@ describe ClassMixedWithDSLInstallUtils do
   let(:unixhost)      { make_host( 'unixhost', { :platform => 'linux',
                                                  :pe_ver => '3.0',
                                                  :working_dir => '/tmp',
+                                                :type => 'foss',
                                                  :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',
+                                                :type => 'foss',
                                                 :dist => 'puppet-enterprise-3.7.1-rc0-78-gffc958f-eos-4-i386' } ) }
+  let(:win_temp)      { 'C:\\Windows\\Temp' }
 
 
   context '#configure_foss_defaults_on' do
-    it 'uses aio paths for hosts of type aio' do
+    it 'uses aio paths for hosts with role aio' do
       hosts.each do |host|
-        host[:type] = 'aio'
+        host[:pe_ver] = nil
+        host[:version] = nil
+        host[:roles] = host[:roles] | ['aio']
       end
+      expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
       expect(subject).to receive(:add_aio_defaults_on).exactly(hosts.length).times
       expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
 
       subject.configure_foss_defaults_on( hosts )
     end
 
-    it 'uses foss paths for hosts of type foss' do
+    it 'uses no paths for hosts with no type' do
       hosts.each do |host|
-        host[:type] = 'foss'
+        host[:type] = nil
       end
-      expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
-      expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
+      expect(subject).to receive(:add_aio_defaults_on).never
+      expect(subject).to receive(:add_foss_defaults_on).never
+      expect(subject).to receive(:add_puppet_paths_on).never
 
       subject.configure_foss_defaults_on( hosts )
     end
 
-    it 'uses foss paths for hosts with no type and version < 4.0' do
-      expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
+    it 'uses aio paths for hosts with aio type (backwards compatability)' do
+      hosts.each do |host|
+        host[:type] = 'aio'
+      end
+      expect(subject).to receive(:add_aio_defaults_on).exactly(hosts.length).times
+      expect(subject).to receive(:add_foss_defaults_on).never
       expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
 
       subject.configure_foss_defaults_on( hosts )
     end
 
-    it 'uses aio paths for hosts of version >= 4.0, except for master/database/dashboard' do
-      agents = []
-      not_agents = []
+    it 'uses aio paths for hosts of version >= 4.0' do
       hosts.each do |host|
         host[:version] = '4.0'
         host[:pe_ver] = nil
-        if subject.agent_only(host)
-          agents << host
-        else
-          not_agents << host
-        end
+        host[:roles] = host[:roles] - ['aio']
       end
-      expect(subject).to receive(:add_aio_defaults_on).exactly(agents.length).times
-      expect(subject).to receive(:add_foss_defaults_on).exactly(not_agents.length).times
+      expect(subject).to receive(:add_aio_defaults_on).exactly(hosts.length).times
+      expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
       expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
 
       subject.configure_foss_defaults_on( hosts )
@@ -103,8 +112,23 @@ describe ClassMixedWithDSLInstallUtils do
     it 'uses foss paths for hosts of version < 4.0' do
       hosts.each do |host|
         host[:version] = '3.8'
+        host[:pe_ver] = nil
+      end
+      expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
+      expect(subject).to receive(:add_aio_defaults_on).never
+      expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
+
+      subject.configure_foss_defaults_on( hosts )
+    end
+
+    it 'uses foss paths for foss-like type foss-package' do
+      hosts.each do |host|
+        host[:type] = 'foss-package'
+        host[:version] = '3.8'
+        host[:pe_ver] = nil
       end
       expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
+      expect(subject).to receive(:add_aio_defaults_on).never
       expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
 
       subject.configure_foss_defaults_on( hosts )
@@ -112,6 +136,54 @@ describe ClassMixedWithDSLInstallUtils do
 
   end
 
+  context 'lookup_in_env' do
+    it 'returns a default properly' do
+      env_var = subject.lookup_in_env('noway', 'nonesuch', 'returnme')
+      expect(env_var).to be == 'returnme'
+      env_var = subject.lookup_in_env('noway', nil, 'returnme')
+      expect(env_var).to be == 'returnme'
+    end
+    it 'finds correct env variable' do
+      allow(ENV).to receive(:[]).with(nil).and_return(nil)
+      allow(ENV).to receive(:[]).with('REALLYNONE').and_return(nil)
+      allow(ENV).to receive(:[]).with('NONESUCH').and_return('present')
+      allow(ENV).to receive(:[]).with('NOWAY_PROJ_NONESUCH').and_return('exists')
+      env_var = subject.lookup_in_env('nonesuch', 'noway-proj', 'fail')
+      expect(env_var).to be == 'exists'
+      env_var = subject.lookup_in_env('nonesuch')
+      expect(env_var).to be == 'present'
+      env_var = subject.lookup_in_env('reallynone')
+      expect(env_var).to be == nil
+      env_var = subject.lookup_in_env('reallynone',nil,'default')
+      expect(env_var).to be == 'default'
+    end
+  end
+
+  context 'build_giturl' do
+    it 'returns urls properly' do
+      allow(ENV).to receive(:[]).with('SERVER').and_return(nil)
+      allow(ENV).to receive(:[]).with('FORK').and_return(nil)
+      allow(ENV).to receive(:[]).with('PUPPET_FORK').and_return(nil)
+      allow(ENV).to receive(:[]).with('PUPPET_SERVER').and_return(nil)
+      url = subject.build_giturl('puppet')
+      expect(url).to be == 'https://github.com/puppetlabs/puppet.git'
+      url = subject.build_giturl('puppet', 'er0ck')
+      expect(url).to be == 'https://github.com/er0ck/puppet.git'
+      url = subject.build_giturl('puppet', 'er0ck', 'bitbucket.com')
+      expect(url).to be == 'https://bitbucket.com/er0ck-puppet.git'
+      url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'https://')
+      expect(url).to be == 'https://github.com/er0ck/puppet.git'
+      url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'https')
+      expect(url).to be == 'https://github.com/er0ck/puppet.git'
+      url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'git@')
+      expect(url).to be == 'git@github.com:er0ck/puppet.git'
+      url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'git')
+      expect(url).to be == 'git@github.com:er0ck/puppet.git'
+      url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'ssh')
+      expect(url).to be == 'git@github.com:er0ck/puppet.git'
+    end
+  end
+
   context 'extract_repo_info_from' do
     [{ :protocol => 'git', :path => 'git://github.com/puppetlabs/project.git' },
      { :protocol => 'ssh', :path => 'git@github.com:puppetlabs/project.git' },
@@ -175,13 +247,15 @@ describe ClassMixedWithDSLInstallUtils do
   end
 
   context 'install_puppet_from_msi' do
+    before :each do
+      expect(subject).to receive(:get_temp_path).and_return(win_temp)
+    end
 
     it 'installs puppet on cygwin windows' do
       allow(subject).to receive(:link_exists?).and_return( true )
-
-      expect(subject).to receive(:on).with(winhost, 'curl -O http://downloads.puppetlabs.com/windows/puppet-3.7.1.msi')
+      expect(subject).to receive(:on).with(winhost, "curl -o \"#{win_temp}\\puppet-3.7.1.msi\" -O http://downloads.puppetlabs.com/windows/puppet-3.7.1.msi")
       expect(subject).to receive(:on).with(winhost, " echo 'export PATH=$PATH:\"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/bin\":\"/cygdrive/c/Program Files/Puppet Labs/Puppet/bin\"' > /etc/bash.bashrc ")
-      expect(subject).to receive(:on).with(winhost, 'cmd /C \'start /w msiexec.exe /qn /i puppet-3.7.1.msi\'')
+      expect(subject).to receive(:install_msi_on).with(winhost, "#{win_temp}\\puppet-3.7.1.msi", {}, {:debug => nil})
 
       subject.install_puppet_from_msi( winhost, {:version => '3.7.1', :win_download_url => 'http://downloads.puppetlabs.com/windows'}  )
     end
@@ -191,18 +265,18 @@ describe ClassMixedWithDSLInstallUtils do
 
       expect(winhost_non_cygwin).to receive(:mkdir_p).with('C:\\ProgramData\\PuppetLabs\\puppet\\etc\\modules')
 
-      expect(subject).to receive(:on) do |winhost_non_cygwin, beaker_command|
+      expect(subject).to receive(:on).with(winhost_non_cygwin, instance_of( Beaker::Command )) do |host, beaker_command|
         expect(beaker_command.command).to eq('powershell.exe')
-        expect(beaker_command.args).to eq(["-ExecutionPolicy Bypass", "-InputFormat None", "-NoLogo", "-NoProfile", "-NonInteractive", "-Command $webclient = New-Object System.Net.WebClient;  $webclient.DownloadFile('http://downloads.puppetlabs.com/windows/puppet-3.7.1.msi','C:\\Windows\\Temp\\puppet-3.7.1.msi')"])
-      end
+        expect(beaker_command.args).to eq(["-ExecutionPolicy Bypass", "-InputFormat None", "-NoLogo", "-NoProfile", "-NonInteractive", "-Command $webclient = New-Object System.Net.WebClient;  $webclient.DownloadFile('http://downloads.puppetlabs.com/windows/puppet-3.7.1.msi','#{win_temp}\\puppet-3.7.1.msi')"])
+      end.once
 
-      expect(subject).to receive(:on).with(winhost_non_cygwin, "start /w msiexec.exe /qn /i C:\\Windows\\Temp\\puppet-3.7.1.msi")
+      expect(subject).to receive(:install_msi_on).with(winhost_non_cygwin, "#{win_temp}\\puppet-3.7.1.msi", {}, {:debug => nil})
 
       subject.install_puppet_from_msi( winhost_non_cygwin, {:version => '3.7.1', :win_download_url => 'http://downloads.puppetlabs.com/windows'}   )
     end
   end
 
-  context 'install_from_git' do
+  context 'clone_git_repo_on' do
     it 'does a ton of stuff it probably shouldnt' do
       repo = { :name => 'puppet',
                :path => 'git://my.server.net/puppet.git',
@@ -214,11 +288,11 @@ describe ClassMixedWithDSLInstallUtils do
       allow( subject ).to receive( :metadata ).and_return( metadata )
       allow( subject ).to receive( :configure_foss_defaults_on ).and_return( true )
 
-      expect( subject ).to receive( :logger ).exactly( 3 ).times.and_return( logger )
-      expect( subject ).to receive( :on ).exactly( 4 ).times
+      expect( subject ).to receive( :logger ).exactly( 2 ).times.and_return( logger )
+      expect( subject ).to receive( :on ).exactly( 3 ).times
 
       subject.instance_variable_set( :@metadata, {} )
-      subject.install_from_git( host, path, repo )
+      subject.clone_git_repo_on( host, path, repo )
     end
 
     it 'allows a checkout depth of 1' do
@@ -233,15 +307,14 @@ describe ClassMixedWithDSLInstallUtils do
       logger = double.as_null_object
       allow( subject ).to receive( :metadata ).and_return( metadata )
       allow( subject ).to receive( :configure_foss_defaults_on ).and_return( true )
-      expect( subject ).to receive( :logger ).exactly( 3 ).times.and_return( logger )
-      expect( subject ).to receive( :on ).with( host,"test -d #{path} || mkdir -p #{path}").exactly( 1 ).times
+      expect( subject ).to receive( :logger ).exactly( 2 ).times.and_return( logger )
+      expect( subject ).to receive( :on ).with( host, "test -d #{path} || mkdir -p #{path}", {:accept_all_exit_codes=>true} ).exactly( 1 ).times
       # this is the the command we want to test
-      expect( subject ).to receive( :on ).with( host, cmd ).exactly( 1 ).times
-      expect( subject ).to receive( :on ).with( host, "cd #{path}/#{repo[:name]} && git remote rm origin && git remote add origin #{repo[:path]} && git fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/* && git clean -fdx && git checkout -f #{repo[:rev]}" ).exactly( 1 ).times
-      expect( subject ).to receive( :on ).with( host, "cd #{path}/#{repo[:name]} && if [ -f install.rb ]; then ruby ./install.rb ; else true; fi" ).exactly( 1 ).times
+      expect( subject ).to receive( :on ).with( host, cmd, {:accept_all_exit_codes=>true} ).exactly( 1 ).times
+      expect( subject ).to receive( :on ).with( host, "cd #{path}/#{repo[:name]} && git remote rm origin && git remote add origin #{repo[:path]} && git fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/* && git clean -fdx && git checkout -f #{repo[:rev]}", {:accept_all_exit_codes=>true} ).exactly( 1 ).times
 
       subject.instance_variable_set( :@metadata, {} )
-      subject.install_from_git( host, path, repo )
+      subject.clone_git_repo_on( host, path, repo )
     end
 
     it 'allows a checkout depth with a rev from a specific branch' do
@@ -257,16 +330,57 @@ describe ClassMixedWithDSLInstallUtils do
       allow( subject ).to receive( :configure_foss_defaults_on ).and_return( true )
       logger = double.as_null_object
       allow( subject ).to receive( :metadata ).and_return( metadata )
-      expect( subject ).to receive( :logger ).exactly( 3 ).times.and_return( logger )
-      expect( subject ).to receive( :on ).with( host,"test -d #{path} || mkdir -p #{path}").exactly( 1 ).times
+      expect( subject ).to receive( :logger ).exactly( 2 ).times.and_return( logger )
+      expect( subject ).to receive( :on ).with( host, "test -d #{path} || mkdir -p #{path}", {:accept_all_exit_codes=>true} ).exactly( 1 ).times
       # this is the the command we want to test
-      expect( subject ).to receive( :on ).with( host, cmd ).exactly( 1 ).times
-      expect( subject ).to receive( :on ).with( host, "cd #{path}/#{repo[:name]} && git remote rm origin && git remote add origin #{repo[:path]} && git fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/* && git clean -fdx && git checkout -f #{repo[:rev]}" ).exactly( 1 ).times
-      expect( subject ).to receive( :on ).with( host, "cd #{path}/#{repo[:name]} && if [ -f install.rb ]; then ruby ./install.rb ; else true; fi" ).exactly( 1 ).times
+      expect( subject ).to receive( :on ).with( host, cmd, {:accept_all_exit_codes=>true} ).exactly( 1 ).times
+      expect( subject ).to receive( :on ).with( host, "cd #{path}/#{repo[:name]} && git remote rm origin && git remote add origin #{repo[:path]} && git fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/* && git clean -fdx && git checkout -f #{repo[:rev]}", {:accept_all_exit_codes=>true} ).exactly( 1 ).times
+
+      subject.instance_variable_set( :@metadata, {} )
+      subject.clone_git_repo_on( host, path, repo )
+    end
+  end
+
+  context 'install_from_git' do
+    it 'does a ton of stuff it probably shouldnt' do
+      repo = { :name => 'puppet',
+               :path => 'git://my.server.net/puppet.git',
+               :rev => 'master' }
+      path = '/path/to/repos'
+      host = { 'platform' => 'debian' }
+      logger = double.as_null_object
+
+      allow( subject ).to receive( :metadata ).and_return( metadata )
+      allow( subject ).to receive( :configure_foss_defaults_on ).and_return( true )
+
+      expect( subject ).to receive( :logger ).exactly( 3 ).times.and_return( logger )
+      expect( subject ).to receive( :on ).exactly( 4 ).times
 
       subject.instance_variable_set( :@metadata, {} )
       subject.install_from_git( host, path, repo )
     end
+
+    it 'should attempt to install ruby code' do
+      repo   = { :name => 'puppet',
+                 :path => 'git://my.server.net/puppet.git',
+                 :rev => 'master',
+                 :depth => 1 }
+
+      path   = '/path/to/repos'
+      cmd    = "test -d #{path}/#{repo[:name]} || git clone --branch #{repo[:rev]} --depth #{repo[:depth]} #{repo[:path]} #{path}/#{repo[:name]}"
+      host   = { 'platform' => 'debian' }
+      logger = double.as_null_object
+      allow( subject ).to receive( :metadata ).and_return( metadata )
+      allow( subject ).to receive( :configure_foss_defaults_on ).and_return( true )
+      expect( subject ).to receive( :logger ).exactly( 3 ).times.and_return( logger )
+      expect( subject ).to receive( :on ).with( host, "test -d #{path} || mkdir -p #{path}", {:accept_all_exit_codes=>true} ).exactly( 1 ).times
+      expect( subject ).to receive( :on ).with( host, cmd, {:accept_all_exit_codes=>true} ).exactly( 1 ).times
+      expect( subject ).to receive( :on ).with( host, "cd #{path}/#{repo[:name]} && git remote rm origin && git remote add origin #{repo[:path]} && git fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/* && git clean -fdx && git checkout -f #{repo[:rev]}", {:accept_all_exit_codes=>true} ).exactly( 1 ).times
+      expect( subject ).to receive( :on ).with( host, "cd #{path}/#{repo[:name]} && if [ -f install.rb ]; then ruby ./install.rb ; else true; fi", {:accept_all_exit_codes=>true} ).exactly( 1 ).times
+
+      subject.instance_variable_set( :@metadata, {} )
+      subject.install_from_git_on( host, path, repo )
+    end
    end
 
   describe '#install_puppet' do
@@ -337,19 +451,28 @@ describe ClassMixedWithDSLInstallUtils do
     end
     context 'on windows' do
       let(:platform) { Beaker::Platform.new('windows-2008r2-i386') }
+
+      before :each do
+        expect(subject).to receive(:get_temp_path).exactly(hosts.length).times.and_return(win_temp)
+      end
+
       it 'installs specific version of puppet when passed :version' do
         allow(hosts[0]).to receive(:is_cygwin?).and_return(true)
         allow(subject).to receive(:link_exists?).and_return( true )
-        expect(subject).to receive(:on).with(hosts[0], 'curl -O http://downloads.puppetlabs.com/windows/puppet-3.msi')
+        expect(subject).to receive(:on).with(hosts[0], "curl -o \"#{win_temp}\\puppet-3.msi\" -O http://downloads.puppetlabs.com/windows/puppet-3.msi")
         expect(subject).to receive(:on).with(hosts[0], " echo 'export PATH=$PATH:\"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/bin\":\"/cygdrive/c/Program Files/Puppet Labs/Puppet/bin\"' > /etc/bash.bashrc ")
-        expect(subject).to receive(:on).with(hosts[0], 'cmd /C \'start /w msiexec.exe /qn /i puppet-3.msi\'')
+        expect(subject).to receive(:install_msi_on).with(hosts[0], "#{win_temp}\\puppet-3.msi", {}, {:debug => nil}).exactly(1).times
+        allow(subject).to receive(:install_msi_on).with(any_args)
+
         subject.install_puppet(:version => '3')
       end
       it 'installs from custom url when passed :win_download_url' do
         allow(hosts[0]).to receive(:is_cygwin?).and_return(true)
         allow(subject).to receive(:link_exists?).and_return( true )
-        expect(subject).to receive(:on).with(hosts[0], 'curl -O http://nightlies.puppetlabs.com/puppet-latest/repos/windows/puppet-3.msi')
-        expect(subject).to receive(:on).with(hosts[0], 'cmd /C \'start /w msiexec.exe /qn /i puppet-3.msi\'')
+        expect(subject).to receive(:on).with(hosts[0], "curl -o \"#{win_temp}\\puppet-3.msi\" -O http://nightlies.puppetlabs.com/puppet-latest/repos/windows/puppet-3.msi")
+        expect(subject).to receive(:install_msi_on).with(hosts[0], "#{win_temp}\\puppet-3.msi", {}, {:debug => nil})
+        allow(subject).to receive(:install_msi_on).with(any_args)
+
         subject.install_puppet( :version => '3', :win_download_url => 'http://nightlies.puppetlabs.com/puppet-latest/repos/windows' )
       end
     end
@@ -742,13 +865,14 @@ describe ClassMixedWithDSLInstallUtils do
       host['platform'] = platform
       opts = { :version => '0.1.0' }
       allow( subject ).to receive( :options ).and_return( {} )
+      copied_path = "#{win_temp}\\puppet-agent-x64.msi"
       mock_echo = Object.new()
-      allow( mock_echo ).to receive( :raw_output ).and_return( " " )
+      allow( mock_echo ).to receive( :raw_output ).and_return( copied_path )
 
       expect(subject).to receive(:fetch_http_file).once.with(/\/windows$/, 'puppet-agent-x64.msi', /\/windows$/)
       expect(subject).to receive(:scp_to).once.with(host, /\/puppet-agent-x64.msi$/, /cygpath/)
+      expect(subject).to receive(:install_msi_on).with(host, copied_path, {}, {:debug => nil}).once
       expect(subject).to receive(:on).ordered.with(host, /echo/).and_return(mock_echo)
-      expect(subject).to receive(:on).ordered.with(host, anything)
 
       subject.install_puppetagent_dev_repo( host, opts )
     end
@@ -786,6 +910,25 @@ describe ClassMixedWithDSLInstallUtils do
     end
   end
 
+  describe '#install_puppet_agent_pe_promoted_repo_on' do
+
+    it 'splits the platform string version correctly to get ubuntu puppet-agent packages' do
+      platform = Object.new()
+      allow(platform).to receive(:to_array) { ['ubuntu', '9999', 'x42']}
+      host = basic_hosts.first
+      host['platform'] = platform
+
+      expect(subject).to receive(:fetch_http_file).once.with(/\/puppet-agent\//, "puppet-agent-ubuntu-99.99-x42.tar.gz", /ubuntu/)
+      expect(subject).to receive(:scp_to).once.with(host, /-ubuntu-99.99-x42\./, "/root")
+      expect(subject).to receive(:on).ordered.with(host, /^tar.*-ubuntu-99.99-x42/)
+      expect(subject).to receive(:on).ordered.with(host, /dpkg\ -i\ --force-all/)
+      expect(subject).to receive(:on).ordered.with(host, /apt-get\ update/)
+
+      subject.install_puppet_agent_pe_promoted_repo_on( host, {} )
+    end
+
+  end
+
   describe '#install_cert_on_windows' do
     before do
       allow(subject).to receive(:on).and_return(Beaker::Result.new({},''))
@@ -842,11 +985,13 @@ describe ClassMixedWithDSLInstallUtils do
 
     before :each do
       allow( subject ).to receive( :configure_foss_defaults_on ).and_return( true )
+      allow( subject ).to receive( :install_msi_on ).with( any_args )
     end
 
     def test_fetch_http_file_no_ending_slash(platform)
       @platform = platform
       allow( subject ).to receive( :scp_to )
+      allow( subject ).to receive( :configure_type_defaults_on ).with(host)
 
       expect( subject ).to receive( :fetch_http_file ).with( /[^\/]\z/, anything, anything )
       subject.install_puppet_agent_pe_promoted_repo_on( host, opts )