beaker-puppet 0.17.1 → 1.0.0

data/lib/beaker-puppet/install_utils/windows_utils.rb

@@ -0,0 +1,223 @@
+module Beaker
+  module DSL
+    module InstallUtils
+      #
+      # This module contains methods useful for Windows installs
+      #
+      module WindowsUtils
+        # Given a host, returns it's system TEMP path
+        #
+        # @param [Host] host An object implementing {Beaker::Hosts}'s interface.
+        #
+        # @return [String] system temp path
+        def get_system_temp_path(host)
+          host.system_temp_path
+        end
+        alias_method :get_temp_path, :get_system_temp_path
+
+        # Generates commands to be inserted into a Windows batch file to launch an MSI install
+        # @param [String] msi_path The path of the MSI - can be a local Windows style file path like
+        #                   c:\temp\puppet.msi OR a url like https://download.com/puppet.msi or file://c:\temp\puppet.msi
+        # @param  [Hash{String=>String}] msi_opts MSI installer options
+        #                   See https://docs.puppetlabs.com/guides/install_puppet/install_windows.html#msi-properties
+        # @param [String] log_path The path to write the MSI log - must be a local Windows style file path
+        #
+        # @api private
+        def msi_install_script(msi_path, msi_opts, log_path)
+          # msiexec requires backslashes in file paths launched under cmd.exe start /w
+          url_pattern = /^(https?|file):\/\//
+          msi_path = msi_path.gsub(/\//, "\\") if msi_path !~ url_pattern
+
+          msi_params = msi_opts.map{|k, v| "#{k}=#{v}"}.join(' ')
+
+          # msiexec requires quotes around paths with backslashes - c:\ or file://c:\
+          # not strictly needed for http:// but it simplifies this code
+          batch_contents = <<-BATCH
+start /w msiexec.exe /i \"#{msi_path}\" /qn /L*V #{log_path} #{msi_params}
+exit /B %errorlevel%
+          BATCH
+        end
+
+        # Given a host, path to MSI and MSI options, will create a batch file
+        #   on the host, returning the path to the randomized batch file and
+        #   the randomized log file
+        #
+        # @param [Host] host An object implementing {Beaker::Hosts}'s interface.
+        # @param [String] msi_path The path of the MSI - can be a local Windows
+        #   style file path like c:\temp\puppet.msi OR a url like
+        #   https://download.com/puppet.msi or file://c:\temp\puppet.msi
+        # @param  [Hash{String=>String}] msi_opts MSI installer options
+        #   See https://docs.puppetlabs.com/guides/install_puppet/install_windows.html#msi-properties
+        #
+        # @api private
+        # @return [String, String] path to the batch file, patch to the log file
+        def create_install_msi_batch_on(host, msi_path, msi_opts)
+          timestamp = Time.new.strftime('%Y-%m-%d_%H.%M.%S')
+          tmp_path = host.system_temp_path
+          tmp_path.gsub!('/', '\\')
+
+          batch_name = "install-puppet-msi-#{timestamp}.bat"
+          batch_path = "#{tmp_path}#{host.scp_separator}#{batch_name}"
+          log_path = "#{tmp_path}\\install-puppet-#{timestamp}.log"
+
+          Tempfile.open(batch_name) do |tmp_file|
+            batch_contents = msi_install_script(msi_path, msi_opts, log_path)
+
+            File.open(tmp_file.path, 'w') { |file| file.puts(batch_contents) }
+            host.do_scp_to(tmp_file.path, batch_path, {})
+          end
+
+          return batch_path, log_path
+        end
+
+        # Given hosts construct a PATH that includes puppetbindir, facterbindir and hierabindir
+        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
+        #                            or a role (String or Symbol) that identifies one or more hosts.
+        # @param [String] msi_path The path of the MSI - can be a local Windows style file path like
+        #                   c:\temp\puppet.msi OR a url like https://download.com/puppet.msi or file://c:\temp\puppet.msi
+        # @param  [Hash{String=>String}] msi_opts MSI installer options
+        #                   See https://docs.puppetlabs.com/guides/install_puppet/install_windows.html#msi-properties
+        # @option msi_opts [String] INSTALLIDIR Where Puppet and its dependencies should be installed.
+        #                  (Defaults vary based on operating system and intaller architecture)
+        #                  Requires Puppet 2.7.12 / PE 2.5.0
+        # @option msi_opts [String] PUPPET_MASTER_SERVER The hostname where the puppet master server can be reached.
+        #                  (Defaults to puppet)
+        #                  Requires Puppet 2.7.12 / PE 2.5.0
+        # @option msi_opts [String] PUPPET_CA_SERVER The hostname where the CA puppet master server can be reached, if you are using multiple masters and only one of them is acting as the CA.
+        #                  (Defaults the value of PUPPET_MASTER_SERVER)
+        #                  Requires Puppet 2.7.12 / PE 2.5.0
+        # @option msi_opts [String] PUPPET_AGENT_CERTNAME The node’s certificate name, and the name it uses when requesting catalogs. This will set a value for
+        #                  (Defaults to the node's fqdn as discovered by facter fqdn)
+        #                  Requires Puppet 2.7.12 / PE 2.5.0
+        # @option msi_opts [String] PUPPET_AGENT_ENVIRONMENT The node’s environment.
+        #                  (Defaults to production)
+        #                  Requires Puppet 3.3.1 / PE 3.1.0
+        # @option msi_opts [String] PUPPET_AGENT_STARTUP_MODE Whether the puppet agent service should run (or be allowed to run)
+        #                  (Defaults to Manual - valid values are Automatic, Manual or Disabled)
+        #                  Requires Puppet 3.4.0 / PE 3.2.0
+        # @option msi_opts [String] PUPPET_AGENT_ACCOUNT_USER Whether the puppet agent service should run (or be allowed to run)
+        #                  (Defaults to LocalSystem)
+        #                  Requires Puppet 3.4.0 / PE 3.2.0
+        # @option msi_opts [String] PUPPET_AGENT_ACCOUNT_PASSWORD The password to use for puppet agent’s user account
+        #                  (No default)
+        #                  Requires Puppet 3.4.0 / PE 3.2.0
+        # @option msi_opts [String] PUPPET_AGENT_ACCOUNT_DOMAIN The domain of puppet agent’s user account.
+        #                  (Defaults to .)
+        #                  Requires Puppet 3.4.0 / PE 3.2.0
+        # @option opts [Boolean] :debug output the MSI installation log when set to true
+        #                 otherwise do not output log (false; default behavior)
+        #
+        # @example
+        #  install_msi_on(hosts, 'c:\puppet.msi', {:debug => true})
+        #
+        # @api private
+        def install_msi_on(hosts, msi_path, msi_opts = {}, opts = {})
+          block_on hosts do | host |
+            msi_opts['PUPPET_AGENT_STARTUP_MODE'] ||= 'Manual'
+            batch_path, log_file = create_install_msi_batch_on(host, msi_path, msi_opts)
+
+            # begin / rescue here so that we can reuse existing error msg propagation
+            begin
+              # 1641 = ERROR_SUCCESS_REBOOT_INITIATED
+              # 3010 = ERROR_SUCCESS_REBOOT_REQUIRED
+              on host, Command.new("\"#{batch_path}\"", [], { :cmdexe => true }), :acceptable_exit_codes => [0, 1641, 3010]
+            rescue
+              on host, Command.new("type \"#{log_file}\"", [], { :cmdexe => true })
+              raise
+            end
+
+            if opts[:debug]
+              on host, Command.new("type \"#{log_file}\"", [], { :cmdexe => true })
+            end
+
+            if !host.is_cygwin?
+              # HACK: for some reason, post install we need to refresh the connection to make puppet available for execution
+              host.close
+            end
+
+            # verify service status post install
+            # if puppet service exists, then pe-puppet is not queried
+            # if puppet service does not exist, pe-puppet is queried and that exit code is used
+            # therefore, this command will always exit 0 if either service is installed
+            #
+            # We also take advantage of this output to verify the startup
+            # settings are honored as supplied to the MSI
+            on host, Command.new("sc qc puppet || sc qc pe-puppet", [], { :cmdexe => true }) do |result|
+              output = result.stdout
+              startup_mode = msi_opts['PUPPET_AGENT_STARTUP_MODE'].upcase
+
+              search = case startup_mode
+                when 'AUTOMATIC'
+                  { :code => 2, :name => 'AUTO_START' }
+                when 'MANUAL'
+                  { :code => 3, :name => 'DEMAND_START' }
+                when 'DISABLED'
+                  { :code => 4, :name => 'DISABLED' }
+                end
+
+              if output !~ /^\s+START_TYPE\s+:\s+#{search[:code]}\s+#{search[:name]}/
+                raise "puppet service startup mode did not match supplied MSI option '#{startup_mode}'"
+              end
+            end
+
+            # (PA-514) value for PUPPET_AGENT_STARTUP_MODE should be present in
+            # registry and honored after install/upgrade.
+            reg_key = host.is_x86_64? ? "HKLM\\SOFTWARE\\Wow6432Node\\Puppet Labs\\PuppetInstaller" :
+                                        "HKLM\\SOFTWARE\\Puppet Labs\\PuppetInstaller"
+            reg_query_command = %Q(reg query "#{reg_key}" /v "RememberedPuppetAgentStartupMode" | findstr #{msi_opts['PUPPET_AGENT_STARTUP_MODE']})
+            on host, Command.new(reg_query_command, [], { :cmdexe => true })
+
+            # emit the misc/versions.txt file which contains component versions for
+            # puppet, facter, hiera, pxp-agent, packaging and vendored Ruby
+            [
+              "\\\"%ProgramFiles%\\Puppet Labs\\puppet\\misc\\versions.txt\\\"",
+              "\\\"%ProgramFiles(x86)%\\Puppet Labs\\puppet\\misc\\versions.txt\\\""
+            ].each do |path|
+              on host, Command.new("\"if exist #{path} type #{path}\"", [], { :cmdexe => true })
+            end
+          end
+        end
+
+        # Installs a specified msi path on given hosts
+        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
+        #                            or a role (String or Symbol) that identifies one or more hosts.
+        # @param [String] msi_path The path of the MSI - can be a local Windows style file path like
+        #                   c:\temp\foo.msi OR a url like https://download.com/foo.msi or file://c:\temp\foo.msi
+        # @param  [Hash{String=>String}] msi_opts MSI installer options
+        # @option opts [Boolean] :debug output the MSI installation log when set to true
+        #                 otherwise do not output log (false; default behavior)
+        #
+        # @example
+        #  generic_install_msi_on(hosts, 'https://releases.hashicorp.com/vagrant/1.8.4/vagrant_1.8.4.msi', {}, {:debug => true})
+        #
+        # @api private
+        def generic_install_msi_on(hosts, msi_path, msi_opts = {}, opts = {})
+          block_on hosts do | host |
+            batch_path, log_file = create_install_msi_batch_on(host, msi_path, msi_opts)
+
+            # begin / rescue here so that we can reuse existing error msg propagation
+            begin
+              # 1641 = ERROR_SUCCESS_REBOOT_INITIATED
+              # 3010 = ERROR_SUCCESS_REBOOT_REQUIRED
+              on host, Command.new("\"#{batch_path}\"", [], { :cmdexe => true }), :acceptable_exit_codes => [0, 1641, 3010]
+            rescue
+              on host, Command.new("type \"#{log_file}\"", [], { :cmdexe => true })
+              raise
+            end
+
+            if opts[:debug]
+              on host, Command.new("type \"#{log_file}\"", [], { :cmdexe => true })
+            end
+
+            if !host.is_cygwin?
+              # HACK: for some reason, post install we need to refresh the connection to make puppet available for execution
+              host.close
+            end
+
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/beaker-puppet/version.rb

@@ -1,3 +1,3 @@
 module BeakerPuppet
-  VERSION = '0.17.1'
+  VERSION = '1.0.0'
 end

data/spec/beaker-puppet/helpers/facter_helpers_spec.rb

@@ -5,7 +5,7 @@ class ClassMixedWithDSLHelpers
   include Beaker::DSL::Wrappers
   include Beaker::DSL::Roles
   include Beaker::DSL::Patterns
-  # include Beaker::DSL::Helpers::FacterHelpers
+  include Beaker::DSL::Helpers::FacterHelpers
   # include Beaker::DSL::Wrappers
   # include BeakerTestHelpers
 

data/spec/beaker-puppet/helpers/puppet_helpers_spec.rb

@@ -7,8 +7,6 @@ class ClassMixedWithDSLHelpers
   include Beaker::DSL::Patterns
   include Beaker::DSL::Outcomes
   include Beaker::DSL::Helpers::PuppetHelpers
-  # include Beaker::DSL::Wrappers
-  # include BeakerTestHelpers
 
   def logger
     RSpec::Mocks::Double.new('logger').as_null_object
@@ -29,6 +27,98 @@ describe ClassMixedWithDSLHelpers do
   let( :db )     { make_host( 'db',       :roles => %w( database agent )  ) }
   let( :hosts )  { [ master, agent, dash, db, custom ] }
 
+  describe '#create_tmpdir_on' do
+    let(:host) { {'user' => 'puppet', 'group' => 'muppets'} }
+    let(:result_success) { double.as_null_object }
+    let(:result_failure) { double.as_null_object }
+    let(:tmpdir) { '/tmp/beaker.XXXXXX/' }
+
+    before :each do
+      allow( host ).to receive( :tmpdir ).and_return( tmpdir )
+      allow( host ).to receive( :result ).and_return( result_success )
+      allow( result_success ).to receive( :success? ).and_return( true )
+      allow( result_success ).to receive( :stdout ).and_return( 'puppet' )
+      allow( result_failure ).to receive( :success? ).and_return( false )
+    end
+
+    context 'with the path_prefix argument' do
+      it 'passes path_prefix to host.tmpdir' do
+        expect( host ).to receive( :tmpdir ).with( 'beaker' )
+        subject.create_tmpdir_on( host, 'beaker' )
+      end
+    end
+
+    context 'with the user argument' do
+      it 'calls chown when a user is specified' do
+        expect( host ).to receive( :user_get ).and_return( result_success )
+        expect( host ).to receive( :chown ).with( host['user'], tmpdir )
+
+        subject.create_tmpdir_on( host, 'beaker', host['user'] )
+      end
+
+      it 'does not call chown when a user is not specified' do
+        expect( host ).to_not receive( :chown )
+
+        subject.create_tmpdir_on( host, 'beaker' )
+      end
+
+      it 'does not call chown and cleans up when the user does not exist on the host' do
+        expect( host ).to receive( :user_get ).and_return( result_failure )
+        expect( host ).to receive( :rm_rf ).with( tmpdir )
+
+        expect{
+          subject.create_tmpdir_on( host, 'beaker', 'invalid.user' )
+        }.to raise_error( RuntimeError, /User invalid.user does not exist on / )
+      end
+    end
+
+    context 'with the group argument' do
+      it 'calls chgrp when a group is specified' do
+        expect( host ).to receive( :group_get ).and_return( result_success )
+        expect( host ).to receive( :chgrp ).with( host['group'], tmpdir )
+
+        subject.create_tmpdir_on( host, 'beaker', nil, host['group'] )
+      end
+
+      it 'does not call chgrp when a group is not specified' do
+        expect( subject ).to_not receive( :chgrp )
+
+        subject.create_tmpdir_on( host, 'beaker' )
+      end
+
+      it 'does not call chgrp and cleans up when the group does not exist on the host' do
+        expect( host ).to receive( :group_get ).and_return( result_failure )
+        expect( host ).to receive( :rm_rf ).with( tmpdir )
+
+        expect{
+          subject.create_tmpdir_on( host, 'beaker', nil, 'invalid.group' )
+        }.to raise_error( RuntimeError, /Group invalid.group does not exist on / )
+      end
+    end
+
+    context 'with user and group arguments' do
+      # don't coalesce the group into chown, i.e. `chown user:group`
+      # this keeps execution paths simple, clean, and discrete
+      it 'calls chown and chgrp separately' do
+        expect( host ).to receive( :user_get ).and_return( result_success )
+        expect( host ).to receive( :group_get ).and_return( result_success )
+        expect( host ).to receive( :chown ).with( host['user'], tmpdir )
+        expect( host ).to receive( :chgrp ).with( host['group'], tmpdir )
+
+        subject.create_tmpdir_on( host, 'beaker', host['user'], host['group'] )
+      end
+
+      it 'does not pass group to chown' do
+        allow( host ).to receive( :user_get ).and_return( result_success )
+        allow( host ).to receive( :chgrp ).with( host['group'], tmpdir )
+
+        expect( host ).to receive( :group_get ).and_return( result_success )
+        expect( host ).to receive( :chown ).with( host['user'], tmpdir )
+
+        subject.create_tmpdir_on( host, 'beaker', host['user'], host['group'] )
+      end
+    end
+  end
 
   describe '#create_tmpdir_for_user' do
     let(:host) { {} }

data/spec/beaker-puppet/helpers/tk_helpers_spec.rb

@@ -5,9 +5,7 @@ class ClassMixedWithDSLHelpers
   include Beaker::DSL::Wrappers
   include Beaker::DSL::Roles
   include Beaker::DSL::Patterns
-  # include Beaker::DSL::Helpers::TKHelpers
-  # include Beaker::DSL::Wrappers
-  # include BeakerTestHelpers
+  include Beaker::DSL::Helpers::TKHelpers
 
   def logger
     RSpec::Mocks::Double.new('logger').as_null_object

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

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