beaker 1.13.1 → 1.14.0

data/lib/beaker/options/presets.rb

@@ -16,6 +16,9 @@ module Beaker
           :project             => ENV['BEAKER_PROJECT'] || ENV['BEAKER_project'],
           :department          => ENV['BEAKER_DEPARTMENT'] || ENV['BEAKER_department'],
           :jenkins_build_url   => ENV['BEAKER_BUILD_URL'] || ENV['BUILD_URL'],
+          :release_apt_repo_url=> ENV['BEAKER_RELEASE_APT_REPO'] || ENV['RELEASE_APT_REPO'] || "http://apt.puppetlabs.com",
+          :release_yum_repo_url=> ENV['BEAKER_RELEASE_YUM_REPO'] || ENV['RELEASE_YUM_REPO'] || "http://yum.puppetlabs.com",
+          :dev_builds_url      => ENV['BEAKER_DEV_BUILDS_URL'] || ENV['DEV_BUILDS_URL'] || "http://builds.puppetlabs.lan",
           :consoleport         => consoleport ? consoleport.to_i : nil,
           :type                => (ENV['BEAKER_IS_PE'] || ENV['IS_PE']) ? 'pe' : nil,
           :pe_dir              => ENV['BEAKER_PE_DIR'] || ENV['pe_dist_dir'],
@@ -80,7 +83,6 @@ module Beaker
           :repo_proxy          => false,
           :package_proxy       => false,
           :add_el_extras       => false,
-          :add_master_entry    => false,
           :consoleport         => 443,
           :pe_dir              => '/opt/enterprise/dists',
           :pe_version_file     => 'LATEST',

data/lib/beaker/platform.rb

@@ -17,6 +17,16 @@ module Beaker
                    },
       }
 
+    # A string with the name of the platform.
+    attr_reader :variant
+    # A string with the version number of the platform.
+    attr_reader :version
+    # A string with the codename of the platform+version, nil on platforms
+    # without codenames.
+    attr_reader :codename
+    # A string with the cpu architecture of the platform.
+    attr_reader :arch
+
     #Creates the Platform object.  Checks to ensure that the platform String provided meets the platform
     #formatting rules.  Platforms name must be of the format /^OSFAMILY-VERSION-ARCH.*$/ where OSFAMILY is one of:
     # * osx
@@ -36,7 +46,30 @@ module Beaker
       if name !~ PLATFORMS
         raise ArgumentError, "Unsupported platform name #{name}"
       end
+
       super
+
+      @variant, version, @arch = self.split('-', 3)
+      codename_version_hash = PLATFORM_VERSION_CODES[@variant.to_sym]
+
+      @version = version
+      @codename = nil
+
+      if codename_version_hash
+        if codename_version_hash[version]
+          @version = codename_version_hash[version]
+        else
+          version = version.delete('.')
+          version_codename_hash = codename_version_hash.invert
+          @codename = version_codename_hash[version]
+        end
+      end
+    end
+
+    # Returns array of attributes to allow single line assignment to local
+    # variables in DSL and test case methods.
+    def to_array
+      return @variant, @version, @arch, @codename
     end
 
     # Returns the platform string with the platform version as a codename.  If no conversion is
@@ -44,20 +77,11 @@ module Beaker
     # @example Platform.new('debian-7-xxx').with_version_codename == 'debian-wheezy-xxx'
     # @return [String] the platform string with the platform version represented as a codename
     def with_version_codename
-      name, version, extra = self.split('-', 3)
-      PLATFORM_VERSION_CODES.each_key do |platform|
-        if name =~ /#{platform}/
-          PLATFORM_VERSION_CODES[platform].each do |version_codename, version_number|
-            #remove '.' from version number
-            if version.delete('.') =~ /#{version_number}/
-              version = version_codename
-              break
-            end
-          end
-          break
-        end
+      version_array = [@variant, @version, @arch]
+      if @codename
+        version_array = [@variant, @codename, @arch]
       end
-      [name, version, extra].join('-')
+      return version_array.join('-')
     end
 
     # Returns the platform string with the platform version as a number.  If no conversion is necessary
@@ -65,19 +89,7 @@ module Beaker
     # @example Platform.new('debian-wheezy-xxx').with_version_number == 'debian-7-xxx'
     # @return [String] the platform string with the platform version represented as a number
     def with_version_number
-      name, version, extra = self.split('-', 3)
-      PLATFORM_VERSION_CODES.each_key do |platform|
-        if name =~ /#{platform}/
-          PLATFORM_VERSION_CODES[platform].each do |version_codename, version_number|
-            if version =~ /#{version_codename}/
-              version = version_number
-              break
-            end
-          end
-          break
-        end
-      end
-      [name, version, extra].join('-')
+      [@variant, @version, @arch].join('-')
     end
 
   end

data/lib/beaker/result.rb

@@ -31,9 +31,10 @@ module Beaker
     end
 
     def convert string
-      if string.respond_to?( :force_encoding ) and defined?( Encoding )
+      if string.respond_to?( :encode )
         # We're running in >= 1.9 and we'll need to convert
-        return string.force_encoding( Encoding.default_external )
+        # Remove invalide and undefined UTF-8 character encodings
+        return string.encode('UTF-8', 'binary', :invalid => :replace, :undef => :replace, :replace => '')
       else
         # We're running in < 1.9 and Ruby doesn't care
         return string

data/lib/beaker/tasks/rake_task.rb

@@ -49,14 +49,8 @@ module Beaker
 
         check_for_beaker_type_config
         command = beaker_command
-
-        begin
-          puts command if verbose
-          success = system(command)
-          preserve_configuration(@options_file)
-        rescue
-          puts failure_message if failure_message
-        end
+        puts command if verbose
+        success = system(command)
         if fail_mode == "fast" && !success
           $stderr.puts "#{command} failed"
           exit $?.exitstatus

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '1.13.1'
+    STRING = '1.14.0'
   end
 end

data/spec/beaker/answers_spec.rb

@@ -9,6 +9,12 @@ module Beaker
                           basic_hosts }
     let( :master_certname ) { 'master_certname' }
 
+    it 'generates 3.4 answers for 3.4 hosts' do
+      @ver = '3.4'
+      Beaker::Answers::Version34.should_receive( :answers ).with( hosts, master_certname, {}).once
+      subject.answers( @ver, hosts, master_certname, {} )
+    end
+
     it 'generates 3.2 answers for 3.3 hosts' do
       @ver = '3.3'
       Beaker::Answers::Version32.should_receive( :answers ).with( hosts, master_certname, {}).once
@@ -52,6 +58,23 @@ module Beaker
   end
 
   module Answers
+    describe Version34 do
+      let( :options )     { Beaker::Options::Presets.env_vars }
+      let( :basic_hosts ) { make_hosts( {'pe_ver' => @ver } ) }
+      let( :hosts ) { basic_hosts[0]['roles'] = ['master', 'agent']
+                      basic_hosts[1]['roles'] = ['dashboard', 'agent']
+                      basic_hosts[2]['roles'] = ['database', 'agent']
+                      basic_hosts }
+      let( :master_certname ) { 'master_certname' }
+      it 'should add answers to the host objects' do
+        @ver = '3.4'
+        answers = subject.answers( hosts, master_certname, options )
+        hosts.each do |host|
+          expect( host[:answers] ).to be === answers[host.name]
+        end
+      end
+    end
+
     describe Version32 do
       let( :options )     { Beaker::Options::Presets.env_vars }
       let( :basic_hosts ) { make_hosts( {'pe_ver' => @ver } ) }

data/spec/beaker/dsl/ezbake_utils_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+EZBAKE_CONFIG_EXAMPLE= { 
+  :project => 'jvm-puppet',
+  :real_name => 'jvm-puppet',
+  :user => 'puppet',
+  :group => 'puppet',
+  :uberjar_name => 'jvm-puppet-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::Mock.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 }
+  let( :remote_packages ) { Beaker::DSL::EZBakeUtils::REMOTE_PACKAGES_REQUIRED }
+
+  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_tools_available?' do
+
+    before do
+      allow(subject).to receive(:check_for_package) { true }
+      allow(subject).to receive(:system) { true }
+    end
+
+    describe "checks for remote packages when given a host" do
+
+      it "and succeeds if all packages are found" do
+        remote_packages.each do |package|
+          expect(subject).to receive(:check_for_package).with(host, package)
+        end
+        subject.ezbake_tools_available? host
+      end
+
+      it "and raises an exception if a package is missing" do
+        allow(subject).to receive(:check_for_package) { false }
+        remote_packages.each do |package|
+          expect(subject).to receive(:check_for_package).with(host, package)
+          break # just need first element
+        end
+      expect{
+        subject.ezbake_tools_available? host
+      }.to raise_error(RuntimeError, /Required package, .*, not installed on/)
+      end
+
+    end
+
+    describe "checks for local successful local commands when no host given" 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_stage' do
+    before do
+      allow(subject).to receive(:ezbake_tools_available?) { true }
+      subject.wipe_out_ezbake_config
+    end
+
+    it "initializes EZBakeUtils.config" do
+      Dir.stub( :chdir ).and_yield()
+      allow(subject).to receive(:conditionally_clone) { true }
+
+      expect(subject).to receive(:`).with(/^lein.*/).ordered
+      expect(subject).to receive(:`).with("rake package:bootstrap").ordered
+      expect(subject).to receive(:load) { }.ordered
+      expect(subject).to receive(:`).with(anything()).ordered
+
+      config = subject.ezbake_config
+      expect(config).to eq(nil)
+
+      subject.ezbake_stage "ruby", "is", "junky"
+
+      config = subject.ezbake_config
+      expect(config).to include(EZBAKE_CONFIG_EXAMPLE)
+    end
+  end
+
+  RSpec.shared_examples "installs-ezbake-dependencies" do
+    it "installs ezbake dependencies" do
+      expect(subject).to receive(:install_package).
+        with( kind_of(FakeHost), anything(), anything())
+      subject.install_ezbake_deps host
+    end
+  end
+
+  describe '#install_ezbake_deps' do
+    let( :platform ) { Beaker::Platform.new('redhat-7-i386') }
+    let(:host) do
+      FakeHost.new( :options => { 'platform' => platform })
+    end
+
+    before do
+      allow(subject).to receive(:ezbake_tools_available?) { true }
+      subject.initialize_ezbake_config
+    end
+
+    it "Raises an exception for unsupported platforms." do
+      expect{ 
+        subject.install_ezbake_deps host
+      }.to raise_error(RuntimeError, /No repository installation step for/)
+    end
+
+    context "When host is a debian-like platform" do
+      let( :platform ) { Beaker::Platform.new('debian-7-i386') }
+      include_examples "installs-ezbake-dependencies"
+    end
+
+    context "When host is a redhat-like platform" do
+      let( :platform ) { Beaker::Platform.new('centos-7-i386') }
+      include_examples "installs-ezbake-dependencies"
+    end
+  end
+
+  def install_from_ezbake_common_expects
+    expect(subject).to receive(:`).with(/rake package:tar/).ordered
+    expect(subject).to receive(:scp_to).
+      with( kind_of(FakeHost), anything(), anything()).ordered
+    expect(subject).to receive(:on).
+      with( kind_of(FakeHost), /tar -xzf/).ordered
+    expect(subject).to receive(:on).
+      with( kind_of(FakeHost), /make -e install-#{EZBAKE_CONFIG_EXAMPLE[:real_name]}/).ordered
+  end
+
+  describe '#install_from_ezbake' do
+    let( :platform ) { Beaker::Platform.new('redhat-7-i386') }
+    let(:host) do
+      FakeHost.new( :options => { 'platform' => platform })
+    end
+
+    before do
+      allow(subject).to receive(:ezbake_tools_available?) { true }
+    end
+
+
+    context "for non *nix-like platforms" do
+      let( :platform ) { Beaker::Platform.new('windows-7-i386') }
+      it "raises an exception" do
+        expect{ 
+          subject.install_from_ezbake host, "blah", "blah"
+        }.to raise_error(RuntimeError, /Beaker::DSL::EZBakeUtils unsupported platform:/)
+      end
+    end
+
+    it "raises an exception for unsupported *nix-like platforms" do
+      Dir.stub( :chdir ).and_yield()
+      install_from_ezbake_common_expects
+      expect{ 
+        subject.install_from_ezbake host, "blah", "blah"
+      }.to raise_error(RuntimeError, /No ezbake installation step for/)
+    end
+
+    context "When Beaker::DSL::EZBakeUtils.config is nil" do
+      let( :platform ) { Beaker::Platform.new('el-7-i386') }
+      before do
+        Dir.stub( :chdir ).and_yield()
+        subject.wipe_out_ezbake_config
+      end
+
+      it "runs ezbake_stage" do
+        expect(subject).to receive(:ezbake_stage) {
+          Beaker::DSL::EZBakeUtils.config = EZBAKE_CONFIG_EXAMPLE
+        }.ordered
+        install_from_ezbake_common_expects
+        expect(subject).to receive(:on).
+          with( kind_of(FakeHost), /install-rpm-sysv-init/).ordered
+        subject.install_from_ezbake host, "blah", "blah"
+      end
+
+    end
+
+    context "When Beaker::DSL::EZBakeUtils.config is a hash" do
+      let( :platform ) { Beaker::Platform.new('el-7-i386') }
+      before do
+        Dir.stub( :chdir ).and_yield()
+        subject.initialize_ezbake_config
+      end
+
+      it "skips ezbake_stage" do
+        install_from_ezbake_common_expects
+        expect(subject).to receive(:on).
+          with( kind_of(FakeHost), /install-rpm-sysv-init/).ordered
+        subject.install_from_ezbake host, "blah", "blah"
+      end
+
+    end
+
+  end
+
+end

data/spec/beaker/dsl/helpers_spec.rb

@@ -300,7 +300,7 @@ describe ClassMixedWithDSLHelpers do
     it 'scps the module to the module dir' do
       subject.stub( :hosts ).and_return( hosts )
 
-      subject.should_receive( :scp_to ).with( master, '/module', '/etc/puppet/modules/test' ).once
+      subject.should_receive( :puppet ).with('module install test' ).once
       subject.puppet_module_install_on( master, {:source => '/module', :module_name => 'test'} )
     end
   end
@@ -776,6 +776,7 @@ describe ClassMixedWithDSLHelpers do
       subject.instance_variable_set(:@path, test_case_path)
       host.stub(:tmpdir).and_return(tmpdir_path)
       host.stub(:file_exist?).and_return(true)
+      subject.stub( :options ).and_return( {} )
     end
 
     before do
@@ -802,12 +803,14 @@ describe ClassMixedWithDSLHelpers do
         let(:puppetservice) { 'whatever' }
 
         it 'bounces puppet twice' do
+          subject.stub(:curl_with_retries)
           subject.with_puppet_running_on(host, {})
           expect(host).to execute_commands_matching(/#{@ps} restart/).exactly(2).times
         end
 
         it 'yield to a block after bouncing service' do
           execution = 0
+          subject.stub(:curl_with_retries)
           expect do
             subject.with_puppet_running_on(host, {}) do
               expect(host).to execute_commands_matching(/#{@ps} restart/).once
@@ -966,43 +969,50 @@ describe ClassMixedWithDSLHelpers do
   end
 
 
-  describe 'copy_root_module_to' do
-    def source_to_scp (source, target, items)
-      subject.stub(:parse_for_moduleroot).and_return('/totalfake/testmodule')
-      Dir.stub(:getpwd).and_return('/totalfake/testmodule')
-
-      items = [items] unless items.kind_of?(Array)
-      File.stub(:exists?).with(any_args()).and_return(false)
-      File.stub(:directory?).with(any_args()).and_return(false)
-      items.each do |item|
-        source_item = File.join(source,item)
-        File.stub(:exists?).with(source_item).and_return(true)
-        options = {}
-        if ['manifests','lib','templates','files'].include? item
-          File.stub(:directory?).with(source_item).and_return(true)
-          options = {:mkdir => true}
+  describe 'copy_module_to' do
+    let(:ignore_list){%w(.git .idea .vagrant .vendor acceptance spec tests log . ..)}
+    let(:source){'./'}
+    let(:target){'/etc/puppetlabs/puppet/modules/testmodule'}
+    let(:module_parse_name){'testmodule'}
+
+    shared_examples 'copy_module_to' do  |opts|
+      it{
+        host = double("host")
+        host.stub(:[]).with('distmoduledir').and_return('/etc/puppetlabs/puppet/modules')
+        Dir.stub(:getpwd).and_return(source)
+
+        subject.stub(:parse_for_moduleroot).and_return(source)
+        if module_parse_name
+          subject.stub(:parse_for_modulename).with(any_args()).and_return(module_parse_name)
+        else
+          subject.should_not_receive(:parse_for_modulename)
         end
-        master.should_receive(:do_scp_to).with(source_item,target,options).ordered
-      end
+
+        File.stub(:exists?).with(any_args()).and_return(false)
+        File.stub(:directory?).with(any_args()).and_return(false)
+
+        subject.should_receive(:scp_to).with(host,source, target, {:ignore => ignore_list})
+        if opts.nil?
+          subject.copy_module_to(host)
+        else
+          subject.copy_module_to(host,opts)
+        end
+      }
+    end
+    describe 'should call scp with the correct info, with only providing host' do
+      let(:target){'/etc/puppetlabs/puppet/modules/testmodule'}
+
+      it_should_behave_like 'copy_module_to'
+    end
+    describe 'should call scp with the correct info, when specifying the modulename' do
+      let(:target){'/etc/puppetlabs/puppet/modules/bogusmodule'}
+      let(:module_parse_name){false}
+      it_should_behave_like 'copy_module_to', {:module_name =>'bogusmodule'}
     end
-    it 'should call scp with the correct info, with only providing host' do
-      files = ['manifests','lib','templates','metadata.json','Modulefile','files']
-      source_to_scp '/totalfake/testmodule',"#{master['puppetpath']}/modules/testmodule",files
-      subject.stub(:parse_for_modulename).with(any_args()).and_return("testmodule")
-      subject.copy_root_module_to(master)
-    end
-    it 'should call scp with the correct info, when specifying the modulename' do
-      files = ['manifests','lib','metadata.json','Modulefile']
-      source_to_scp '/totalfake/testmodule',"#{master['puppetpath']}/modules/bogusmodule",files
-      subject.stub(:parse_for_modulename).and_return('testmodule')
-      subject.copy_root_module_to(master,{:module_name =>"bogusmodule"})
-    end
-    it 'should call scp with the correct info, when specifying the target to a different path' do
-      files = ['manifests','lib','templates','metadata.json','Modulefile','files']
-      target = "/opt/shared/puppet/modules"
-      source_to_scp '/totalfake/testmodule',"#{target}/testmodule",files
-      subject.stub(:parse_for_modulename).and_return('testmodule')
-      subject.copy_root_module_to(master,{:target_module_path => target})
+    describe 'should call scp with the correct info, when specifying the target to a different path' do
+      target = '/opt/shared/puppet/modules'
+      let(:target){"#{target}/testmodule"}
+      it_should_behave_like 'copy_module_to', {:target_module_path => target}
     end
   end