beaker 0.0.0

data/lib/beaker/utils/repo_control.rb

@@ -0,0 +1,92 @@
+module Beaker 
+  module Utils
+    class RepoControl
+
+      APT_CFG = %q{ Acquire::http::Proxy "http://proxy.puppetlabs.net:3128/"; }
+      IPS_PKG_REPO="http://solaris-11-internal-repo.delivery.puppetlabs.net"
+
+      def initialize(options, hosts)
+        @options = options.dup
+        @hosts = hosts
+        @logger = options[:logger]
+        @debug_opt = options[:debug] ? 'vh' : ''
+      end
+
+      def epel_info_for! host
+        version = host['platform'].match(/el-(\d+)/)[1]
+        if version == '6'
+          pkg = 'epel-release-6-8.noarch.rpm'
+          url = "http://mirror.itc.virginia.edu/fedora-epel/6/i386/#{pkg}"
+        elsif version == '5'
+          pkg = 'epel-release-5-4.noarch.rpm'
+          url = "http://archive.linux.duke.edu/pub/epel/5/i386/#{pkg}"
+        else
+          raise "I don't understand your platform description!"
+        end
+        return url
+      end
+
+      def apt_get_update
+        @hosts.each do |host|
+          if host['platform'] =~ /ubuntu|debian/
+            host.exec(Command.new("apt-get -y -f -m update"))
+          end
+        end
+      end
+
+      def copy_file_to_remote(host, file_path, file_content)
+        Tempfile.open 'beaker' do |tempfile|
+          File.open(tempfile.path, 'w') {|file| file.puts file_content }
+
+          host.do_scp_to(tempfile.path, file_path, @options)
+        end
+
+      end
+
+      def proxy_config
+        # repo_proxy
+        # supports ubuntu, debian and solaris platforms
+        @hosts.each do |host|
+          case
+          when host['platform'] =~ /ubuntu/
+            host.exec(Command.new("if test -f /etc/apt/apt.conf; then mv /etc/apt/apt.conf /etc/apt/apt.conf.bk; fi"))
+            copy_file_to_remote(host, '/etc/apt/apt.conf', APT_CFG)
+            apt_get_update
+          when host['platform'] =~ /debian/
+            host.exec(Command.new("if test -f /etc/apt/apt.conf; then mv /etc/apt/apt.conf /etc/apt/apt.conf.bk; fi"))
+            copy_file_to_remote(host, '/etc/apt/apt.conf', APT_CFG)
+            apt_get_update
+          when host['platform'] =~ /solaris-11/
+            host.exec(Command.new("/usr/bin/pkg unset-publisher solaris || :"))
+            host.exec(Command.new(host,"/usr/bin/pkg set-publisher -g %s solaris" % IPS_PKG_REPO))
+          else
+            @logger.debug "#{host}: repo proxy configuration not modified"
+          end
+        end
+      rescue => e
+        report_and_raise(@logger, e, "proxy_config")
+      end
+
+      def add_el_extras
+        #add_el_extras
+        #only supports el-* platforms
+        @hosts.each do |host|
+          case
+          when host['platform'] =~ /el-(5|6)/
+            result = host.exec(Command.new('rpm -qa | grep epel-release'), :acceptable_exit_codes => [0,1])
+            if result.exit_code == 1
+              url = epel_info_for! host
+              host.exec(Command.new("rpm -i#{@debug_opt} #{url}"))
+              host.exec(Command.new('yum clean all && yum makecache'))
+            end
+          else
+            @logger.debug "#{host}: package repo configuration not modified"
+          end
+        end
+      rescue => e
+        report_and_raise(@logger, e, "add_repos")
+      end
+
+    end
+  end
+end

data/lib/beaker/utils/setup_helper.rb

@@ -0,0 +1,77 @@
+module Beaker
+  module Utils
+    class SetupHelper
+
+      def initialize(options, hosts)
+        @options = options.dup
+        @hosts = hosts
+        @logger = options[:logger]
+      end
+
+      def find_masters(hosts)
+        hosts.select do |host|
+          host['roles'].include?("master")
+        end
+      end
+
+      def find_only_master(hosts)
+        m = find_masters(hosts)
+        raise "too many masters, expected one but found #{m.map {|h| h.to_s }}" unless m.length == 1
+        m.first
+      end
+
+      def add_master_entry
+        @logger.notify "Add Master entry to /etc/hosts"
+        master = find_only_master(@hosts)
+        if master["hypervisor"] and master["hypervisor"] =~ /vagrant/
+          @logger.debug "Don't update master entry on vagrant masters"
+          return
+        end
+        @logger.debug "Get ip address of Master #{master}"
+        if master['platform'].include? 'solaris'
+          stdout = master.exec(Command.new("ifconfig -a inet| awk '/broadcast/ {print $2}' | cut -d/ -f1 | head -1")).stdout
+        else
+          stdout = master.exec(Command.new("ip a|awk '/g/{print$2}' | cut -d/ -f1 | head -1")).stdout
+        end
+        ip=stdout.chomp
+
+        path = "/etc/hosts"
+        if master['platform'].include? 'solaris'
+          path = "/etc/inet/hosts"
+        end
+
+        @logger.debug "Update %s on #{master}" % path
+        # Preserve the mode the easy way...
+        master.exec(Command.new("cp %s %s.old" % [path, path]))
+        master.exec(Command.new("cp %s %s.new" % [path, path]))
+        master.exec(Command.new("grep -v '#{ip} #{master}' %s > %s.new" % [path, path]))
+        master.exec(Command.new("echo '#{ip} #{master}' >> %s.new" % path))
+        master.exec(Command.new("mv %s.new %s" % [path, path]))
+      rescue => e
+        report_and_raise(@logger, e, "add_master_entry")
+      end
+
+      def sync_root_keys
+        # JJM This step runs on every system under test right now.  We're anticipating
+        # issues on Windows and maybe Solaris.  We will likely need to filter this step
+        # but we're deliberately taking the approach of "assume it will work, fix it
+        # when reality dictates otherwise"
+        @logger.notify "Sync root authorized_keys from github"
+        script = "https://raw.github.com/puppetlabs/puppetlabs-sshkeys/master/templates/scripts/manage_root_authorized_keys"
+        setup_root_authorized_keys = "curl -k -o - #{script} | %s"
+        @logger.notify "Sync root authorized_keys from github"
+        @hosts.each do |host|
+          # Allow all exit code, as this operation is unlikely to cause problems if it fails.
+          if host['platform'].include? 'solaris'
+            host.exec(Command.new(setup_root_authorized_keys % "bash"), :acceptable_exit_codes => (0..255))
+          else
+            host.exec(Command.new(setup_root_authorized_keys % "env PATH=/usr/gnu/bin:$PATH bash"), :acceptable_exit_codes => (0..255))
+          end
+        end
+      rescue => e
+        report_and_raise(@logger, e, "sync_root_keys")
+      end
+
+    end
+  end
+end

data/lib/beaker/utils/validator.rb

@@ -0,0 +1,27 @@
+module Beaker
+  module Utils
+    module Validator
+      PACKAGES = ['curl']
+      UNIX_PACKAGES = ['ntpdate']
+
+      def self.validate(hosts, logger)
+        hosts.each do |host|
+          PACKAGES.each do |pkg|
+            if not host.check_for_package pkg
+              host.install_package pkg
+            end
+          end
+          if host['platform'] !~ /(windows)|(aix)|(solaris)/
+            UNIX_PACKAGES.each do |pkg|
+              if not host.check_for_package pkg
+                host.install_package pkg
+              end
+            end
+          end
+        end
+      rescue => e
+        report_and_raise(logger, e, "validate")
+      end
+    end
+  end
+end

data/spec/beaker/command_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module Beaker
+  describe Command do
+    let(:command) { @command || '/bin/ls' }
+    let(:args)    { @args    || Array.new }
+    let(:options) { @options || Hash.new  }
+    subject(:cmd) { Command.new( command, args, options ) }
+    let(:host)    { Hash.new }
+
+    it 'creates a new Command object' do
+      @command = '/usr/bin/blah'
+      @args    = [ 'to', 'the', 'baz' ]
+      @options = { :foo => 'bar' }
+
+      expect( cmd.options ).to be == @options
+      expect( cmd.args    ).to be == @args
+      expect( cmd.command ).to be == @command
+
+      expect( cmd.args_string    ).to be == 'to the baz'
+      expect( cmd.options_string ).to be == '--foo=bar'
+      expect( cmd.environment_string_for(host) ).to be == ''
+
+    end
+
+    describe '#options_string' do
+      it 'parses things' do
+        subject.options = { :v => nil, :test => nil,
+                            :server => 'master', :a => 'answers.txt' }
+        expect( subject.options_string ).to match /-v/
+        expect( subject.options_string ).to match /--test/
+        expect( subject.options_string ).to match /--server=master/
+        expect( subject.options_string ).to match /-a=answers\.txt/
+      end
+    end
+
+    describe '#args_string' do
+      it 'joins an array' do
+        subject.args = ['my/command and', nil, 'its args and opts']
+        expect( subject.args_string ).to be == 'my/command and its args and opts'
+      end
+    end
+
+    describe '#environment_string_for' do
+      it 'returns a blank string if theres no env' do
+        expect( subject.environment_string_for({}) ).to be == ''
+      end
+
+      it 'takes an env hash with var_name/value pairs' do
+        expect( subject.environment_string_for({}, {:HOME => '/'}) ).
+          to be == 'env HOME="/"'
+      end
+
+      it 'takes an env hash with var_name/value[Array] pairs' do
+        expect( subject.environment_string_for({}, {:LD_PATH => ['/', '/tmp']}) ).
+          to be == 'env LD_PATH="/:/tmp"'
+      end
+
+      it 'takes var_names where there is an array of default values' do
+        env = {:PATH => { :default => [ '/bin', '/usr/bin' ] } }
+        expect( subject.environment_string_for({}, env) ).
+          to be == 'env PATH="/bin:/usr/bin"'
+
+      end
+
+      it 'takes var_names where there is an array of host specific values' do
+        host = { 'pe_path' => '/opt/puppet/bin', 'foss_path' => '/usr/bin' }
+        env = {:PATH => { :host => [ 'pe_path', 'foss_path' ] } }
+        expect( subject.environment_string_for( host, env ) ).
+          to be == 'env PATH="/opt/puppet/bin:/usr/bin"'
+
+      end
+      it 'when using an array of values it allows to specify the separator' do
+        host = { 'whoosits_separator' => ' **sparkles** ' }
+        env = {
+          :WHOOSITS => {
+            :default => [ 'whatsits', 'wonkers' ],
+            :opts => {:separator => {:host => 'whoosits_separator' } }
+          }
+        }
+        expect( subject.environment_string_for( host, env ) ).
+          to be == 'env WHOOSITS="whatsits **sparkles** wonkers"'
+      end
+    end
+
+    describe '#parse_env_hash_for' do
+      it 'has too many responsiblities' do
+        env = { :PATH => { :default => [ '/bin', '/usr/bin' ] } }
+        var_array = cmd.parse_env_hash_for host, env
+        expect( var_array ).to be == [ 'PATH="/bin:/usr/bin"' ]
+      end
+    end
+  end
+end

data/spec/beaker/dsl/assertions_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLAssertions
+  include Beaker::DSL::Assertions
+end
+
+describe ClassMixedWithDSLAssertions do
+  describe '#assert_output' do
+    it 'defaults to checking stdout' do
+      stdout = <<CONSOLE
+This should not have space infront of it
+  While this should have two spaces infront of it
+    And this 3, all lines should be to stdout
+CONSOLE
+
+      expectation = <<CONSOLE
+        This should not have space infront of it
+          While this should have two spaces infront of it
+            And this 3, all lines should be to stdout
+CONSOLE
+
+      result = double
+      result.should_receive( :nil? ).at_least( :once ).and_return( false )
+      result.should_receive( :stdout ).and_return( stdout )
+      result.should_receive( :output ).and_return( stdout )
+      result.should_receive( :stderr ).and_return( '' )
+
+      subject.should_receive( :result ).at_least( :once ).and_return( result )
+      expect { subject.assert_output expectation }.to_not raise_error
+    end
+
+    it 'allows specifying stream markers' do
+      output = <<OUTPUT
+This is on stdout
+While this is on stderr
+And THIS is again on stdout
+OUTPUT
+
+      stdout = <<STDOUT
+This is on stdout
+And THIS is again on stdout
+STDOUT
+
+      stderr = <<STDERR
+While this is on stderr
+STDERR
+
+      expectation = <<EXPECT
+        STDOUT> This is on stdout
+        STDERR> While this is on stderr
+        STDOUT> And THIS is again on stdout
+EXPECT
+
+      result = double
+      result.should_receive( :nil? ).at_least( :once ).and_return( false )
+      result.should_receive( :stdout ).and_return( stdout )
+      result.should_receive( :output ).and_return( output )
+      result.should_receive( :stderr ).and_return( stderr )
+
+      subject.should_receive( :result ).at_least( :once ).and_return( result )
+      expect { subject.assert_output expectation }.to_not raise_error
+    end
+
+    it 'raises an approriate error when output does not match expectations' do
+      output = <<OUTPUT
+This is on stdout
+Holy Crap, what HAPPENED!?!?!?
+And THIS is again on stdout
+OUTPUT
+
+      stdout = <<STDOUT
+This is on stdout
+And THIS is again on stdout
+STDOUT
+
+      stderr = <<STDERR
+Holy Crap, what HAPPENED!?!?!?
+STDERR
+
+      expectation = <<EXPECT
+        STDOUT> This is on stdout
+        STDERR> While this is on stderr
+        STDOUT> And THIS is again on stdout
+EXPECT
+
+      require 'rbconfig'
+      ruby_conf = defined?(RbConfig) ? RbConfig::CONFIG : Config::CONFIG
+      if ruby_conf['MINOR'].to_i == 8
+        exception = Test::Unit::AssertionFailedError
+      else
+        exception = MiniTest::Assertion
+      end
+
+      result = double
+      result.should_receive( :nil? ).at_least( :once ).and_return( false )
+      result.should_receive( :stdout ).any_number_of_times.and_return( stdout )
+      result.should_receive( :output ).any_number_of_times.and_return( output )
+      result.should_receive( :stderr ).any_number_of_times.and_return( stderr )
+
+      subject.should_receive( :result ).at_least( :once ).and_return( result )
+      expect { subject.assert_output expectation }.to raise_error( exception )
+    end
+  end
+end

data/spec/beaker/dsl/helpers_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLHelpers
+  include Beaker::DSL::Helpers
+end
+
+describe ClassMixedWithDSLHelpers do
+  describe '#on' do
+    it 'allows the environment the command is run within to be specified' do
+      host = double.as_null_object
+
+      Beaker::Command.should_receive( :new ).
+        with( 'ls ~/.bin', [], {'ENV' => { :HOME => '/tmp/test_home' }} )
+
+      subject.on( host, 'ls ~/.bin', :environment => {:HOME => '/tmp/test_home' } )
+    end
+
+    it 'delegates to itself for each host passed' do
+      hosts = [ double, double, double ]
+
+      hosts.each_with_index do |host, i|
+        host.should_receive( :exec ).and_return( i )
+      end
+
+      results = subject.on( hosts, 'ls' )
+      expect( results ).to be == [ 0, 1, 2 ]
+    end
+
+    it 'yields to a given block' do
+      host = double.as_null_object
+
+      subject.on host, 'ls' do |containing_class|
+        expect( containing_class ).
+          to be_an_instance_of( ClassMixedWithDSLHelpers )
+      end
+    end
+
+    it 'returns the result of the action' do
+      host = double.as_null_object
+
+      host.should_receive( :exec ).and_return( 'my_result' )
+
+      expect( subject.on( host, 'ls' ) ).to be == 'my_result'
+    end
+  end
+
+  describe '#scp_from' do
+    it 'delegates to the host' do
+      hosts = [ double, double, double ]
+      result = double
+
+      subject.should_receive( :logger ).exactly( 3 ).times
+      result.should_receive( :log ).exactly( 3 ).times
+      hosts.each do |host|
+        host.should_receive( :do_scp_from ).and_return( result )
+      end
+
+      subject.scp_from( hosts, '/var/log/my.log', 'log/my.log' )
+    end
+  end
+
+  describe '#scp_to' do
+    it 'delegates to the host' do
+      hosts = [ double, double, double ]
+      result = double
+
+      subject.should_receive( :logger ).exactly( 3 ).times
+      result.should_receive( :log ).exactly( 3 ).times
+      hosts.each do |host|
+        host.should_receive( :do_scp_to ).and_return( result )
+      end
+
+      subject.scp_to( hosts, '/var/log/my.log', 'log/my.log' )
+    end
+  end
+
+  describe '#create_remote_file' do
+    it 'scps the contents passed in to the hosts' do
+      hosts = [ 'uno.example.org', 'dos.example.org' ]
+      my_opts = { :silent => true }
+      tmpfile = double
+
+      tmpfile.should_receive( :path ).exactly( 2 ).times.
+        and_return( '/local/path/to/blah' )
+      Tempfile.should_receive( :open ).and_yield( tmpfile )
+      File.should_receive( :open )
+      subject.should_receive( :scp_to ).
+        with( hosts, '/local/path/to/blah', '/remote/path', my_opts )
+
+      subject.create_remote_file( hosts, '/remote/path', 'blah', my_opts )
+    end
+  end
+
+  describe '#run_script_on' do
+    it 'scps the script to a tmpdir and executes it on host(s)' do
+      subject.should_receive( :scp_to )
+      subject.should_receive( :on )
+      subject.run_script_on( 'host', '~/.bin/make-enterprisy' )
+    end
+  end
+
+    #let(:host_param)    { @host_param || Array.new }
+    #let(:logger_param)  { double('logger').as_null_object }
+    #let(:config_param)  { Hash.new }
+    #let(:options_param) { Hash.new }
+    #let(:path_param)    { '/file/path/string' }
+    #let(:test_case) do
+    #  TestCase.new( host_param, logger_param, config_param, options_param, path_param )
+    #end
+
+    describe 'confine' do
+      let(:logger) { double.as_null_object }
+      before do
+        subject.should_receive( :logger ).any_number_of_times.and_return( logger )
+      end
+
+      it 'skips the test if there are no applicable hosts' do
+        subject.should_receive( :hosts ).any_number_of_times.and_return( [] )
+        subject.should_receive( :hosts= ).any_number_of_times
+        logger.should_receive( :warn )
+        subject.should_receive( :skip_test ).
+          with( 'No suitable hosts found' )
+
+        subject.confine( :to, {} )
+      end
+
+      it 'raises when given mode is not :to or :except' do
+        subject.should_receive( :hosts ).any_number_of_times
+        subject.should_receive( :hosts= ).any_number_of_times
+
+        expect {
+          subject.confine( :regardless, {:thing => 'value'} )
+        }.to raise_error( 'Unknown option regardless' )
+      end
+
+      it 'rejects hosts that do not meet simple hash criteria' do
+        hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'} ]
+
+        subject.should_receive( :hosts ).and_return( hosts )
+        subject.should_receive( :hosts= ).
+          with( [ {'thing' => 'foo'} ] )
+
+        subject.confine :to, :thing => 'foo'
+      end
+
+      it 'rejects hosts that match a list of criteria' do
+        hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'}, {'thing' => 'baz'} ]
+
+        subject.should_receive( :hosts ).and_return( hosts )
+        subject.should_receive( :hosts= ).
+          with( [ {'thing' => 'bar'} ] )
+
+        subject.confine :except, :thing => ['foo', 'baz']
+      end
+
+      it 'rejects hosts when a passed block returns true' do
+        host1 = {'platform' => 'solaris'}
+        host2 = {'platform' => 'solaris'}
+        host3 = {'platform' => 'windows'}
+        ret1 = (Struct.new('Result1', :stdout)).new(':global')
+        ret2 = (Struct.new('Result2', :stdout)).new('a_zone')
+        hosts = [ host1, host2, host3 ]
+
+        subject.should_receive( :hosts ).and_return( hosts )
+        subject.should_receive( :on ).
+          with( host1, '/sbin/zonename' ).
+          and_return( ret1 )
+        subject.should_receive( :on ).
+          with( host1, '/sbin/zonename' ).
+          and_return( ret2 )
+
+        subject.should_receive( :hosts= ).with( [ host1 ] )
+
+        subject.confine :to, :platform => 'solaris' do |host|
+          subject.on( host, '/sbin/zonename' ).stdout =~ /:global/
+        end
+      end
+    end
+
+  describe '#apply_manifest_on' do
+    it 'allows acceptable exit codes through :catch_failures' do
+      subject.should_receive( :puppet ).
+        with( 'apply', '--verbose', '--trace', '--detailed-exitcodes' ).
+        and_return( 'puppet_command' )
+
+      subject.should_receive( :on ).
+        with( 'my_host', 'puppet_command',
+              :acceptable_exit_codes => [4,0,2],
+              :stdin => "class { \"boo\": }\n" )
+
+      subject.apply_manifest_on( 'my_host',
+                                'class { "boo": }',
+                                :acceptable_exit_codes => [4],
+                                :trace => true,
+                                :catch_failures => true )
+    end
+  end
+
+  describe '#stub_hosts_on' do
+    it 'executes puppet on the host passed and ensures it is reverted' do
+      logger = double.as_null_object
+
+      subject.should_receive( :logger ).any_number_of_times.and_return( logger )
+      subject.should_receive( :on ).twice
+      subject.should_receive( :teardown ).and_yield
+      subject.should_receive( :puppet ).once.
+        with( 'resource', 'host',
+              'puppetlabs.com',
+              'ensure=present', 'ip=127.0.0.1' )
+      subject.should_receive( :puppet ).once.
+        with( 'resource', 'host',
+              'puppetlabs.com',
+              'ensure=absent' )
+
+      subject.stub_hosts_on( 'my_host', 'puppetlabs.com' => '127.0.0.1' )
+    end
+  end
+
+  describe '#stub_forge_on' do
+    it 'stubs forge.puppetlabs.com with the value of `forge`' do
+      subject.should_receive( :forge ).and_return( 'my_forge.example.com' )
+      Resolv.should_receive( :getaddress ).
+        with( 'my_forge.example.com' ).and_return( '127.0.0.1' )
+      subject.should_receive( :stub_hosts_on ).
+        with( 'my_host', 'forge.puppetlabs.com' => '127.0.0.1' )
+
+      subject.stub_forge_on( 'my_host' )
+    end
+  end
+end