beaker 0.0.0

data/spec/beaker/dsl/install_utils_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLInstallUtils
+  include Beaker::DSL::InstallUtils
+  include Beaker::DSL::Structure
+end
+
+describe ClassMixedWithDSLInstallUtils do
+  context 'extract_repo_info_from' do
+    [{:protocol => 'git', :path => 'git://github.com/puppetlabs/project.git'},
+     {:protocol => 'ssh', :path => 'git@github.com:puppetlabs/project.git'},
+     {:protocol => 'https', :path => 'https://github.com:puppetlabs/project'},
+     {:protocol => 'file', :path => 'file:///home/example/project'}
+    ].each do |type|
+      it "handles #{type[:protocol]} uris" do
+        uri = "#{type[:path]}#master"
+        repo_info = subject.extract_repo_info_from uri
+        expect(repo_info[:name]).to be == 'project'
+        expect(repo_info[:path]).to be ==  type[:path]
+        expect(repo_info[:rev]).to  be == 'master'
+      end
+    end
+  end
+
+  context 'order_packages' do
+    it 'orders facter, hiera before puppet, before anything else' do
+      named_repos = [
+        {:name => 'puppet_plugin'}, {:name => 'puppet'}, {:name => 'facter'}
+      ]
+      ordered_repos = subject.order_packages named_repos
+      expect( ordered_repos[0][:name] ).to be == 'facter'
+      expect( ordered_repos[1][:name] ).to be == 'puppet'
+      expect( ordered_repos[2][:name] ).to be == 'puppet_plugin'
+    end
+  end
+
+  context 'find_git_repo_versions' do
+    it 'returns a hash of :name => version' do
+      host        = stub('Host')
+      repository  = {:name => 'name'}
+      path        = '/path/to/repo'
+      cmd         = 'cd /path/to/repo/name && git describe || true'
+      logger = double.as_null_object
+
+      subject.should_receive( :logger ).and_return( logger )
+      subject.should_receive( :on ).with(host, cmd).and_yield
+      subject.should_receive( :stdout ).and_return( '2' )
+
+      version = subject.find_git_repo_versions(host, path, repository)
+
+      expect(version).to be == {'name' => '2'}
+    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
+
+      subject.should_receive( :logger ).any_number_of_times.and_return( logger )
+      subject.should_receive( :on ).exactly( 4 ).times
+
+      subject.install_from_git( host, path, repo )
+    end
+  end
+end

data/spec/beaker/dsl/outcomes_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLOutcomes
+  include Beaker::DSL::Outcomes
+end
+
+describe ClassMixedWithDSLOutcomes do
+  let(:logger) { double }
+  before { subject.stub( :logger ).and_return( logger ) }
+
+  describe '#pass_test' do
+    it "logs the notification passed to it and raises PassTest" do
+      logger.should_receive( :notify ).with( /blah/ )
+      expect { subject.pass_test('blah') }.
+        to raise_error Beaker::DSL::Outcomes::PassTest
+    end
+  end
+
+  describe '#skip_test' do
+    it "logs the notification passed to it and raises SkipTest" do
+      logger.should_receive( :notify ).with( /blah/ )
+      expect { subject.skip_test('blah') }.
+        to raise_error Beaker::DSL::Outcomes::SkipTest
+    end
+  end
+
+  describe '#pending_test' do
+    it "logs the notification passed to it and raises PendingTest" do
+      logger.should_receive( :warn ).with( /blah/ )
+      expect { subject.pending_test('blah') }.
+        to raise_error Beaker::DSL::Outcomes::PendingTest
+    end
+  end
+
+  describe '#fail_test' do
+    it "logs the notification passed to it and raises FailTest" do
+      logger.should_receive( :warn )
+      logger.should_receive( :pretty_backtrace )
+      expect { subject.fail_test('blah') }.
+        to raise_error Beaker::DSL::Outcomes::FailTest
+    end
+  end
+end

data/spec/beaker/dsl/roles_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+
+class ClassMixedWithDSLRoles
+  include Beaker::DSL::Roles
+  include Beaker::DSL::Outcomes
+end
+
+describe ClassMixedWithDSLRoles do
+
+  let(:hosts)      { @hosts || Hash.new                     }
+  let(:agent1)     { {'roles' => [ 'agent' ] }              }
+  let(:agent2)     { {'roles' => [ 'agent' ] }              }
+  let(:a_and_dash) { {'roles' => [ 'agent', 'dashboard' ] } }
+  let(:custom)     { {'roles' => [ 'custome_role' ] }       }
+  let(:db)         { {'roles' => [ 'database' ] }           }
+  let(:master)     { {'roles' => [ 'master', 'agent' ] }    }
+  let(:monolith) do
+    {'roles' => [ 'agent', 'dashboard', 'database', 'master', 'custom_role' ] }
+  end
+
+  describe '#agents' do
+    it 'returns an array of hosts that are agents' do
+      @hosts = [ agent1, agent2, master ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject.agents ).to be == [ agent1, agent2, master ]
+    end
+
+    it 'and an empty array when none match' do
+      @hosts = [ db, custom ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject.agents ).to be == []
+    end
+  end
+  describe '#master' do
+    it 'returns the master if there is one' do
+      @hosts = [ master, agent1 ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject.master ).to be == master
+    end
+    it 'raises an error if there is more than one master' do
+      @hosts = [ master, monolith ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect { subject.master }.to raise_error Beaker::DSL::FailTest
+    end
+    it 'and raises an error if there is no master' do
+      @hosts = [ agent1, agent2, custom ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect { subject.master }.to raise_error Beaker::DSL::FailTest
+    end
+  end
+  describe '#dashboard' do
+    it 'returns the dashboard if there is one' do
+      @hosts = [ a_and_dash, agent1 ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject.dashboard ).to be == a_and_dash
+    end
+    it 'raises an error if there is more than one dashboard' do
+      @hosts = [ a_and_dash, monolith ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect { subject.dashboard }.to raise_error Beaker::DSL::FailTest
+    end
+    it 'and raises an error if there is no dashboard' do
+      @hosts = [ agent1, agent2, custom ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect { subject.dashboard }.to raise_error Beaker::DSL::FailTest
+    end
+  end
+  describe '#database' do
+    it 'returns the database if there is one' do
+      @hosts = [ db, agent1 ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject.database ).to be == db
+    end
+    it 'raises an error if there is more than one database' do
+      @hosts = [ db, monolith ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect { subject.database }.to raise_error Beaker::DSL::FailTest
+    end
+    it 'and raises an error if there is no database' do
+      @hosts = [ agent1, agent2, custom ]
+      subject.should_receive( :hosts ).and_return( hosts )
+      expect { subject.database }.to raise_error Beaker::DSL::FailTest
+    end
+  end
+end

data/spec/beaker/dsl/structure_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLStructure
+  include Beaker::DSL::Structure
+end
+
+describe ClassMixedWithDSLStructure do
+  let(:logger) { Object.new }
+  describe '#step' do
+    it 'requires a name' do
+      expect { subject.step do; end }.to raise_error ArgumentError
+    end
+
+    it 'notifies the logger' do
+      subject.should_receive( :logger ).and_return( logger )
+      logger.should_receive( :notify )
+      subject.step 'blah'
+    end
+
+    it 'yields if a block is given' do
+      subject.should_receive( :logger ).and_return( logger )
+      logger.should_receive( :notify )
+      subject.should_receive( :foo )
+      subject.step 'blah' do
+        subject.foo
+      end
+    end
+  end
+
+  describe '#test_name' do
+    it 'requires a name' do
+      expect { subject.test_name do; end }.to raise_error ArgumentError
+    end
+
+    it 'notifies the logger' do
+      subject.should_receive( :logger ).and_return( logger )
+      logger.should_receive( :notify )
+      subject.test_name 'blah'
+    end
+
+    it 'yields if a block is given' do
+      subject.should_receive( :logger ).and_return( logger )
+      logger.should_receive( :notify )
+      subject.should_receive( :foo )
+      subject.test_name 'blah' do
+        subject.foo
+      end
+    end
+  end
+
+  describe '#teardown' do
+    it 'append a block to the @teardown var' do
+      teardown_array = double
+      subject.instance_variable_set :@teardown_procs, teardown_array
+      block = lambda { 'blah' }
+      teardown_array.should_receive( :<< ).with( block )
+      subject.teardown &block
+    end
+  end
+end

data/spec/beaker/dsl/wrappers_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLWrappers
+  include Beaker::DSL::Wrappers
+end
+
+describe ClassMixedWithDSLWrappers do
+  let(:opts)  { {'ENV' => default_opts} }
+  let(:default_opts) { Beaker::Command::DEFAULT_GIT_ENV }
+  describe '#facter' do
+    it 'should split out the options and pass "facter" as first arg to Command' do
+      Beaker::Command.should_receive( :new ).
+        with('facter', [ '-p' ], opts)
+      subject.facter( '-p' )
+    end
+  end
+
+  describe '#hiera' do
+    it 'should split out the options and pass "hiera" as first arg to Command' do
+      Beaker::Command.should_receive( :new ).
+        with('hiera', [ '-p' ], opts)
+      subject.hiera( '-p' )
+    end
+  end
+
+  describe '#puppet' do
+    it 'should split out the options and pass "puppet <blank>" to Command' do
+      merged_opts = {}
+      merged_opts['ENV'] = {:HOME => '/'}.merge( default_opts )
+      merged_opts[:server] = 'master'
+      Beaker::Command.should_receive( :new ).
+        with('puppet agent', [ '-tv' ], merged_opts)
+      subject.puppet( 'agent', '-tv', :server => 'master', 'ENV' => {:HOME => '/'})
+    end
+  end
+
+  describe '#host_command' do
+    it 'delegates to HostCommand.new' do
+      Beaker::HostCommand.should_receive( :new ).with( 'blah' )
+      subject.host_command( 'blah' )
+    end
+  end
+
+  describe 'deprecated puppet wrappers' do
+    %w( resource doc kick cert apply master agent filebucket ).each do |sub|
+      it "#{sub} delegates the proper info to #puppet" do
+        subject.should_receive( :puppet ).with( sub, 'blah' )
+        subject.send( "puppet_#{sub}", 'blah')
+      end
+    end
+  end
+end

data/spec/beaker/host_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module Beaker
+  describe Host do
+    let :config do
+      MockConfig.new({}, {'name' => {'platform' => @platform}}, @pe)
+    end
+
+    let(:options) { @options || Hash.new                  }
+    let(:host)    { Host.create 'name', options, config   }
+
+    it 'creates a windows host given a windows config' do
+      @platform = 'windows'
+      expect( host ).to be_a_kind_of Windows::Host
+    end
+
+    it( 'defaults to a unix host' ) { expect( host ).to be_a_kind_of Unix::Host }
+
+    it 'can be read like a hash' do
+      expect { host['value'] }.to_not raise_error NoMethodError
+    end
+
+    it 'can be written like a hash' do
+      host['value'] = 'blarg'
+      expect( host['value'] ).to be === 'blarg'
+    end
+
+
+    # it takes a command object and a hash of options,
+    # it acts on the host's logger and connection object
+    # it receives a result object from the connection#execute
+    # (which it's really just a confusing wrapper for)
+    # it controls the result objects logging and fails a test for TestCase
+    #   if the exit_code doesn't match
+    # it returns the result object
+    it 'EXEC!'
+
+    # it takes a location and a destination
+    # it basically proxies that to the connection object
+    it 'do_scp_to logs info and proxies to the connection' do
+      logger = mock(:logger)
+      conn = mock(:connection)
+      @options = { :logger => logger }
+      host.instance_variable_set :@connection, conn
+      args = [ 'source', 'target', {} ]
+
+      logger.should_receive(:debug)
+      conn.should_receive(:scp_to).with(*args)
+
+      host.do_scp_to *args
+    end
+
+    it 'do_scp_from logs info and proxies to the connection' do
+      logger = mock(:logger)
+      conn = mock(:connection)
+      @options = { :logger => logger }
+      host.instance_variable_set :@connection, conn
+      args = [ 'source', 'target', {} ]
+
+      logger.should_receive(:debug)
+      conn.should_receive(:scp_from).with(*args)
+
+      host.do_scp_from *args
+    end
+    it 'interpolates to its "name"' do
+      expect( "#{host}" ).to be === 'name'
+    end
+
+
+    context 'merging defaults' do
+      it 'knows the difference between foss and pe' do
+        @pe = true
+        expect( host['puppetpath'] ).to be === '/etc/puppetlabs/puppet'
+      end
+
+      it 'correctly merges network configs over defaults?' do
+        overridden_config = MockConfig.new( {'puppetpath'=> '/i/do/what/i/want'},
+                                            {'name' => {} },
+                                              false )
+        merged_host = Host.create 'name', options, overridden_config
+        expect( merged_host['puppetpath'] ).to be === '/i/do/what/i/want'
+      end
+
+      it 'correctly merges host specifics over defaults' do
+        overriding_config = MockConfig.new( {},
+                                            {'name' => {
+                                              'puppetpath' => '/utter/awesomeness'}
+                                            }, true )
+
+        merged_host = Host.create 'name', options, overriding_config
+        expect( merged_host['puppetpath'] ).to be === '/utter/awesomeness'
+      end
+    end
+  end
+end

data/spec/beaker/logger_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+module Beaker
+  describe Logger, :use_fakefs => true do
+    let(:my_io)  { MockIO.new                         }
+    let(:logger) { Logger.new(my_io, :quiet => true)  }
+
+
+    context 'new' do
+      it 'does not duplicate STDOUT when directly passed to it' do
+        stdout_logger = Logger.new STDOUT
+        expect( stdout_logger ).to have(1).destinations
+      end
+
+
+      context 'default for' do
+        its(:destinations)  { should include(STDOUT)  }
+        its(:color)         { should be_nil           }
+        its(:log_level)     { should be :normal       }
+      end
+    end
+
+
+    context 'it can' do
+      it 'open/create a file when a string is given to add_destination' do
+        logger.add_destination 'my_tmp_file'
+        expect( File.exists?( 'my_tmp_file' ) ).to be_true
+
+        io = logger.destinations.select {|d| d.respond_to? :path }.first
+        expect( io.path ).to match /my_tmp_file/
+      end
+
+      it 'remove destinations with the remove_destinations method' do
+        logger.add_destination 'my_file'
+
+        logger.remove_destination my_io
+        logger.remove_destination 'my_file'
+
+        expect( logger.destinations ).to be_empty
+      end
+
+      it 'strip colors from arrays of input' do
+        stripped = logger.strip_colors_from [ "\e[00;30m text! \e[00;00m" ]
+        expect( stripped ).to be === [ ' text! ' ]
+      end
+
+      it 'colors strings if @color is set' do
+        colorized_logger = Logger.new my_io, :color => true, :quiet => true
+
+        my_io.should_receive( :print ).with "\e[00;30m"
+        my_io.should_receive( :print )
+        my_io.should_receive( :puts ).with 'my string'
+
+        colorized_logger.optionally_color "\e[00;30m", 'my string'
+      end
+
+
+      context 'at debug log_level' do
+        subject( :debug_logger )  { Logger.new( my_io,
+                                              :debug => true,
+                                              :quiet => true,
+                                              :color => true )
+                                  }
+
+        its( :is_debug? ) { should be_true }
+        its( :is_warn? )  { should be_true }
+
+
+        context 'successfully print' do
+          before do
+            my_io.stub :puts
+            my_io.should_receive( :print ).at_least :twice
+          end
+
+          it( 'warnings' )    { debug_logger.warn 'IMA WARNING!'        }
+          it( 'debugs' )      { debug_logger.debug 'IMA DEBUGGING!'     }
+          it( 'successes' )   { debug_logger.success 'SUCCESS!'         }
+          it( 'errors' )      { debug_logger.error 'ERROR!'             }
+          it( 'host_output' ) { debug_logger.host_output 'ERROR!'       }
+        end
+      end
+
+      context 'at normal log_level' do
+        subject( :normal_logger ) { Logger.new( my_io,
+                                              :quiet => true,
+                                              :color => true )
+                                  }
+
+        its( :is_debug? ) { should be_false }
+        its( :is_warn? )  { should be_false }
+
+
+        context 'skip' do
+          before do
+            my_io.should_not_receive :puts
+            my_io.should_not_receive :print
+          end
+
+          it( 'warnings' )  { normal_logger.warn 'NOT A WARNING!'  }
+          it( 'debugs' )    { normal_logger.debug 'NOT DEBUGGING!' }
+        end
+
+
+        context 'but print' do
+          before do
+            my_io.should_receive :puts
+            my_io.should_receive( :print ).twice
+          end
+
+          it( 'successes' )     { normal_logger.success 'SUCCESS!'  }
+          it( 'notifications' ) { normal_logger.notify 'NOTFIY!'    }
+          it( 'errors' )        { normal_logger.error 'ERROR!'      }
+        end
+      end
+    end
+  end
+end