beaker 0.0.0 → 1.0.0

data/spec/beaker/dsl/install_utils_spec.rb

@@ -3,21 +3,37 @@ require 'spec_helper'
 class ClassMixedWithDSLInstallUtils
   include Beaker::DSL::InstallUtils
   include Beaker::DSL::Structure
+  include Beaker::DSL::Roles
 end
 
 describe ClassMixedWithDSLInstallUtils do
+   let(:basic_hosts)   { make_hosts( { :pe_ver => '3.0',
+                                        :platform => 'linux',
+                                        :roles => [ 'agent' ] } ) }
+   let(:hosts)         { basic_hosts[0][:roles] = ['master', 'database', 'dashboard']
+                          basic_hosts[1][:platform] = 'windows'
+                          basic_hosts  }
+   let(:winhost)       { make_host( 'winhost', { :platform => 'windows',
+                                                 :pe_ver => '3.0',
+                                                 :working_dir => '/tmp' } ) }
+   let(:unixhost)      { make_host( 'unixhost', { :platform => 'linux',
+                                                  :pe_ver => '3.0',
+                                                  :working_dir => '/tmp',
+                                                  :dist => 'puppet-enterprise-3.1.0-rc0-230-g36c9e5c-debian-7-i386' } ) }
+
+
   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'}
+    [{ :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"
+      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'
+        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
@@ -25,7 +41,7 @@ describe ClassMixedWithDSLInstallUtils do
   context 'order_packages' do
     it 'orders facter, hiera before puppet, before anything else' do
       named_repos = [
-        {:name => 'puppet_plugin'}, {:name => 'puppet'}, {:name => 'facter'}
+        { :name => 'puppet_plugin' }, { :name => 'puppet' }, { :name => 'facter' }
       ]
       ordered_repos = subject.order_packages named_repos
       expect( ordered_repos[0][:name] ).to be == 'facter'
@@ -36,19 +52,19 @@ describe ClassMixedWithDSLInstallUtils do
 
   context 'find_git_repo_versions' do
     it 'returns a hash of :name => version' do
-      host        = stub('Host')
-      repository  = {:name => 'name'}
+      host        = double( '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( :on ).with( host, cmd ).and_yield
       subject.should_receive( :stdout ).and_return( '2' )
 
-      version = subject.find_git_repo_versions(host, path, repository)
+      version = subject.find_git_repo_versions( host, path, repository )
 
-      expect(version).to be == {'name' => '2'}
+      expect( version ).to be == { 'name' => '2' }
     end
   end
 
@@ -61,10 +77,243 @@ describe ClassMixedWithDSLInstallUtils do
       host = { 'platform' => 'debian' }
       logger = double.as_null_object
 
-      subject.should_receive( :logger ).any_number_of_times.and_return( logger )
+      subject.should_receive( :logger ).exactly( 3 ).times.and_return( logger )
       subject.should_receive( :on ).exactly( 4 ).times
 
       subject.install_from_git( host, path, repo )
     end
+   end
+
+  describe 'sorted_hosts' do
+    it 'can reorder so that the master comes first' do
+      subject.stub( :hosts ).and_return( [ hosts[1], hosts[0], hosts[2] ] )
+      expect( subject.sorted_hosts ).to be === hosts
+    end
+
+    it 'leaves correctly ordered hosts alone' do
+      subject.stub( :hosts ).and_return( hosts )
+      expect( subject.sorted_hosts ).to be === hosts 
+    end
+  end
+
+  describe 'version_is_less' do
+
+    it 'reports 3.0.0-160-gac44cfb is not less than 3.0.0' do
+      expect( subject.version_is_less( '3.0.0-160-gac44cfb', '3.0.0' ) ).to be === false
+    end
+
+    it 'reports 3.0.0-160-gac44cfb is not less than 2.8.2' do
+      expect( subject.version_is_less( '3.0.0-160-gac44cfb', '2.8.2' ) ).to be === false
+    end
+
+    it 'reports 3.0.0 is less than 3.0.0-160-gac44cfb' do
+      expect( subject.version_is_less( '3.0.0', '3.0.0-160-gac44cfb' ) ).to be === true
+    end
+
+    it 'reports 2.8.2 is less than 3.0.0-160-gac44cfb' do
+      expect( subject.version_is_less( '2.8.2', '3.0.0-160-gac44cfb' ) ).to be === true
+    end
+
+    it 'reports 2.8 is less than 3.0.0-160-gac44cfb' do
+      expect( subject.version_is_less( '2.8', '3.0.0-160-gac44cfb' ) ).to be === true
+    end
+
+    it 'reports 2.8 is less than 2.9' do
+      expect( subject.version_is_less( '2.8', '2.9' ) ).to be === true
+    end
+  end
+
+  describe 'installer_cmd' do
+
+    it 'generates a windows PE install command for a windows host' do
+      expect( subject.installer_cmd( winhost, {} ) ).to be === "cd /tmp && msiexec.exe /qn /i puppet-enterprise-3.0.msi"
+    end
+
+    it 'generates a unix PE install command for a unix host' do
+      expect( subject.installer_cmd( unixhost, { :installer => 'puppet-enterprise-installer' } ) ).to be === "cd /tmp/puppet-enterprise-3.1.0-rc0-230-g36c9e5c-debian-7-i386 && ./puppet-enterprise-installer"
+    end
+  end
+
+  describe 'fetch_puppet' do
+
+    it 'can push a local PE .tar.gz to a host and unpack it' do
+      File.stub( :directory? ).and_return( true ) #is local
+      File.stub( :exists? ).and_return( true ) #is a .tar.gz
+      unixhost['pe_dir'] = '/local/file/path'
+      subject.stub( :scp_to ).and_return( true )
+
+      path = unixhost['pe_dir']
+      filename = "#{ unixhost['dist'] }"
+      extension = '.tar.gz'
+      subject.should_receive( :scp_to ).with( unixhost, "#{ path }/#{ filename }#{ extension }", "#{ unixhost['working_dir'] }/#{ filename }#{ extension }" ).once
+      subject.should_receive( :on ).with( unixhost, /gunzip/ ).once
+      subject.should_receive( :on ).with( unixhost, /tar -xvf/ ).once
+      subject.fetch_puppet( [unixhost], {} )
+    end
+
+    it 'can download a PE .tar from a URL to a host and unpack it' do
+      File.stub( :directory? ).and_return( false ) #is not local
+      unixhost['pe_dir'] = 'http://www.path.com/dir/'
+      subject.stub( :link_exists? ) do |arg|
+        if arg =~ /.tar.gz/ #there is no .tar.gz link, only a .tar
+          false
+        else          
+          true
+        end
+      end
+      subject.stub( :on ).and_return( true )
+
+      path = unixhost['pe_dir']
+      filename = "#{ unixhost['dist'] }"
+      extension = '.tar'
+      subject.should_receive( :on ).with( unixhost, "cd #{ unixhost['working_dir'] }; curl #{ path }/#{ filename }#{ extension } -o #{ filename }#{ extension }" ).once
+      subject.should_receive( :on ).with( unixhost, /tar -xvf/ ).once
+      subject.fetch_puppet( [unixhost], {} )
+    end
+
+    it 'can download a PE .tar.gz from a URL to a host and unpack it' do
+      File.stub( :directory? ).and_return( false ) #is not local
+      unixhost['pe_dir'] = 'http://www.path.com/dir/'
+      subject.stub( :link_exists? ).and_return( true ) #is a tar.gz
+      subject.stub( :on ).and_return( true )
+
+      path = unixhost['pe_dir']
+      filename = "#{ unixhost['dist'] }"
+      extension = '.tar.gz'
+      subject.should_receive( :on ).with( unixhost, "cd #{ unixhost['working_dir'] }; curl #{ path }/#{ filename }#{ extension } -o #{ filename }#{ extension }" ).once
+      subject.should_receive( :on ).with( unixhost, /gunzip/ ).once
+      subject.should_receive( :on ).with( unixhost, /tar -xvf/ ).once
+      subject.fetch_puppet( [unixhost], {} )
+    end
+     
+    it 'can push a local PE package to a windows host' do
+      File.stub( :directory? ).and_return( true ) #is local
+      File.stub( :exists? ).and_return( true ) #is present
+      winhost['pe_dir'] = '/local/file/path'
+      subject.stub( :scp_to ).and_return( true )
+
+      path = winhost['pe_dir']
+      filename = "puppet-enterprise-#{ winhost['pe_ver'] }"
+      extension = '.msi'
+      subject.should_receive( :scp_to ).with( winhost, "#{ path }/#{ filename }#{ extension }", "#{ winhost['working_dir'] }/#{ filename }#{ extension }" ).once
+      subject.fetch_puppet( [winhost], {} )
+
+    end
+  end
+
+  describe 'do_install' do
+    it 'can preform a simple installation' do
+      subject.stub( :on ).and_return( Beaker::Result.new( {}, '' ) )
+      subject.stub( :fetch_puppet ).and_return( true )
+      subject.stub( :create_remote_file ).and_return( true )
+      subject.stub( :sign_certificate_for ).and_return( true )
+      subject.stub( :stop_agent_on ).and_return( true )
+      subject.stub( :sleep_until_puppetdb_started ).and_return( true )
+      subject.stub( :wait_for_host_in_dashboard ).and_return( true )
+      subject.stub( :puppet_agent ).and_return( "puppet agent" )
+
+      subject.stub( :hosts ).and_return( hosts )
+      #determine mastercert
+      subject.should_receive( :on ).with( hosts[0], /uname/ ).once
+      #create working dirs per-host
+      subject.should_receive( :on ).with( hosts[0], /mkdir/ ).once
+      subject.should_receive( :on ).with( hosts[1], /mkdir/ ).once
+      subject.should_receive( :on ).with( hosts[2], /mkdir/ ).once
+      #create answers file per-host, except windows
+      subject.should_receive( :create_remote_file ).with( hosts[0], /answers/, /q/ ).once
+      subject.should_receive( :create_remote_file ).with( hosts[2], /answers/, /q/ ).once
+      #run installer on all hosts
+      subject.should_receive( :on ).with( hosts[0], /puppet-enterprise-installer/ ).once
+      subject.should_receive( :on ).with( hosts[1], /msiexec.exe/ ).once
+      subject.should_receive( :on ).with( hosts[2], /puppet-enterprise-installer/ ).once
+      #sign certificate per-host
+      subject.should_receive( :sign_certificate_for ).with( hosts[0] ).once
+      subject.should_receive( :sign_certificate_for ).with( hosts[1] ).once
+      subject.should_receive( :sign_certificate_for ).with( hosts[2] ).once
+      #stop puppet agent on all hosts
+      subject.should_receive( :stop_agent_on ).with( hosts[0] ).once
+      subject.should_receive( :stop_agent_on ).with( hosts[1] ).once
+      subject.should_receive( :stop_agent_on ).with( hosts[2] ).once
+      #wait for puppetdb to start
+      subject.should_receive( :sleep_until_puppetdb_started ).with( hosts[0] ).once
+      #run each puppet agent once
+      subject.should_receive( :on ).with( hosts[0], /puppet agent/, :acceptable_exit_codes => [0,2] ).once
+      subject.should_receive( :on ).with( hosts[1], /puppet agent/, :acceptable_exit_codes => [0,2] ).once
+      subject.should_receive( :on ).with( hosts[2], /puppet agent/, :acceptable_exit_codes => [0,2] ).once
+      #run rake task on dashboard
+      subject.should_receive( :on ).with( hosts[0], /\/opt\/puppet\/bin\/rake -sf \/opt\/puppet\/share\/puppet-dashboard\/Rakefile .* RAILS_ENV=production/ ).once
+      #wait for all hosts to appear in the dashboard
+      subject.should_receive( :wait_for_host_in_dashboard ).with( hosts[0] ).once
+      subject.should_receive( :wait_for_host_in_dashboard ).with( hosts[1] ).once
+      subject.should_receive( :wait_for_host_in_dashboard ).with( hosts[2] ).once
+      #run puppet agent now that installation is complete
+      subject.should_receive( :on ).with( hosts, /puppet agent/, :acceptable_exit_codes => [0,2] ).once
+      subject.do_install( hosts )
+    end
+  end
+
+  describe 'install_pe' do
+
+    it 'calls do_install with sorted hosts' do
+      subject.stub( :hosts ).and_return( [ hosts[1], hosts[0], hosts[2] ] )
+      subject.stub( :do_install ).and_return( true )
+      subject.should_receive( :do_install ).with( hosts )
+      subject.install_pe
+    end
+
+    it 'fills in missing pe_ver' do
+      hosts.each do |h|
+        h['pe_ver'] = nil
+      end
+      Beaker::Options::PEVersionScraper.stub( :load_pe_version ).and_return( '2.8' )
+      subject.stub( :hosts ).and_return( [ hosts[1], hosts[0], hosts[2] ] )
+      subject.stub( :options ).and_return( {} )
+      subject.stub( :do_install ).and_return( true )
+      subject.should_receive( :do_install ).with( hosts )
+      subject.install_pe
+      hosts.each do |h|
+        expect( h['pe_ver'] ).to be === '2.8'
+      end
+    end
+  end
+
+  describe 'upgrade_pe' do
+
+    it 'calls puppet-enterprise-upgrader for pre 3.0 upgrades' do
+      Beaker::Options::PEVersionScraper.stub( :load_pe_version ).and_return( '2.8' )
+      Beaker::Options::PEVersionScraper.stub( :load_pe_version_win ).and_return( '2.8' )
+      subject.stub( :hosts ).and_return( [ hosts[1], hosts[0], hosts[2] ] )
+      subject.stub( :options ).and_return( {} )
+      version = version_win = '2.8'
+      path = "/path/to/upgradepkg"
+      subject.should_receive( :do_install ).with( hosts, { :type => :upgrade, :pe_dir => path, :pe_ver => version, :pe_ver_win => version_win, :installer => 'puppet-enterprise-upgrader' } )
+      subject.upgrade_pe( path )
+    end
+
+    it 'uses standard upgrader for post 3.0 upgrades' do
+      Beaker::Options::PEVersionScraper.stub( :load_pe_version ).and_return( '3.1' )
+      Beaker::Options::PEVersionScraper.stub( :load_pe_version_win ).and_return( '3.1' )
+      subject.stub( :hosts ).and_return( [ hosts[1], hosts[0], hosts[2] ]  )
+      subject.stub( :options ).and_return( {} )
+      version = version_win = '3.1'
+      path = "/path/to/upgradepkg"
+      subject.should_receive( :do_install ).with( hosts, { :type => :upgrade, :pe_dir => path, :pe_ver => version, :pe_ver_win => version_win } )
+      subject.upgrade_pe( path )
+    end
+
+    it 'updates pe_ver post upgrade' do
+      Beaker::Options::PEVersionScraper.stub( :load_pe_version ).and_return( '2.8' )
+      Beaker::Options::PEVersionScraper.stub( :load_pe_version_win ).and_return( '2.8' )
+      subject.stub( :hosts ).and_return( [ hosts[1], hosts[0], hosts[2] ] )
+      subject.stub( :options ).and_return( {} )
+      version = version_win = '2.8'
+      path = "/path/to/upgradepkg"
+      subject.should_receive( :do_install ).with( hosts, { :type => :upgrade, :pe_dir => path, :pe_ver => version, :pe_ver_win => version_win, :installer => 'puppet-enterprise-upgrader' } )
+      subject.upgrade_pe( path )
+      hosts.each do |h|
+        expect( h['pe_ver'] ).to be === '2.8'
+      end
+    end
+
   end
 end

data/spec/beaker/dsl/roles_spec.rb

@@ -8,16 +8,15 @@ 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
+  let( :hosts )      { @hosts || Hash.new }
+  let( :agent1 )     { make_host( 'agent1',     { :roles => [ 'agent' ] } ) }
+  let( :agent2 )     { make_host( 'agent2',     { :roles => [ 'agent' ] } ) }
+  let( :a_and_dash ) { make_host( 'a_and_dash', { :roles => [ 'agent', 'dashboard' ] } ) }
+  let( :custom )     { make_host( 'custom',     { :roles => [ 'custome_role' ] } ) }
+  let( :db )         { make_host( 'db',         { :roles => [ 'database' ] } ) }
+  let( :master )     { make_host( 'master',     { :roles => [ 'master', 'agent' ] } ) }
+  let( :default )    { make_host( 'default',    { :roles => [ 'default'] } ) }
+  let( :monolith )   { make_host( 'monolith',   { :roles => [ 'agent', 'dashboard', 'database', 'master', 'custom_role'] } ) }
 
   describe '#agents' do
     it 'returns an array of hosts that are agents' do
@@ -83,4 +82,26 @@ describe ClassMixedWithDSLRoles do
       expect { subject.database }.to raise_error Beaker::DSL::FailTest
     end
   end
+  describe '#default' do
+    it 'returns the default host when one is specified' do
+      @hosts = [ db, agent1, agent2, default, master]
+      subject.should_receive( :hosts ).exactly( 3 ).times.and_return( hosts )
+      expect( subject.default ).to be == default
+    end
+    it 'returns the master if no default host is set' do
+      @hosts = [ db, agent1, agent2, master]
+      subject.should_receive( :hosts ).exactly( 4 ).times.and_return( hosts )
+      expect( subject.default ).to be == master
+    end
+    it 'returns the only host when only a single host is defined' do
+      @hosts = [ agent1 ]
+      subject.should_receive( :hosts ).exactly( 2 ).times.and_return( hosts )
+      expect( subject.default ).to be == agent1
+    end
+    it 'raises an error when there is no default (no default, no master, no single host)'  do
+      @hosts = [ agent1, agent2 ]
+      subject.should_receive( :hosts ).exactly( 3 ).times.and_return( hosts )
+      expect{ subject.default }.to raise_error Beaker::DSL::FailTest
+    end
+  end
 end

data/spec/beaker/host/windows/group_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Beaker
+  describe Windows::Group do
+    class WindowsGroupTest
+      include Windows::Group
+    end
+
+    let(:instance) { WindowsGroupTest.new }
+    let(:result) { double(:result, :stdout => group_list_output) }
+    let(:group_list_output) do <<-EOS
+
+
+Name=Foo
+
+
+Name=Bar6
+
+
+      EOS
+    end
+
+    def add_group(group_name)
+      group_list_output << <<-EOS
+Name=#{group_name}
+
+
+      EOS
+    end
+
+    before(:each) do
+      instance.should_receive(:execute).with(/wmic group where/).and_yield(result)
+    end
+
+    it "gets a group_list" do
+      expect(instance.group_list).to eql(["Foo", "Bar6"])
+    end
+
+    it "gets groups with spaces" do
+      add_group("With Spaces")
+      expect(instance.group_list).to eql(["Foo", "Bar6", "With Spaces"])
+    end
+
+
+    it "gets groups with dashes" do
+      add_group("With-Dashes")
+      expect(instance.group_list).to eql(["Foo", "Bar6", "With-Dashes"])
+    end
+
+    it "gets groups with underscores" do
+      add_group("With_Underscores")
+      expect(instance.group_list).to eql(["Foo", "Bar6", "With_Underscores"])
+    end
+  end
+end

data/spec/beaker/host_spec.rb

@@ -2,22 +2,21 @@ 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   }
+    let(:options)  { @options ? @options : {} }
+    let(:platform) { @platform ? { :platform => @platform } : {} }
+    let(:host)    { make_host( 'name', options.merge(platform) ) }
 
     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 'defaults to a unix host' do 
+      expect( host ).to be_a_kind_of Unix::Host 
+    end
 
     it 'can be read like a hash' do
-      expect { host['value'] }.to_not raise_error NoMethodError
+      expect{ host['value'] }.to_not raise_error
     end
 
     it 'can be written like a hash' do
@@ -25,40 +24,148 @@ module Beaker
       expect( host['value'] ).to be === 'blarg'
     end
 
+    describe "windows hosts" do
+      describe "install_package" do
+        let(:cygwin) { 'setup-x86.exe' }
+        let(:cygwin64) { 'setup-x86_64.exe' }
+        let(:package) { 'foo' }
+
+        before(:each) do
+          @platform = 'windows'
+          host.stub(:check_for_package).and_return(true)
+        end
+
+        context "testing osarchitecture" do
+
+          before(:each) do
+            host.should_receive(:execute).with(/wmic os get osarchitecture/, anything).and_yield(success_osarch_check)
+          end
+
+          context "32 bit" do
+            let(:success_osarch_check) { double(:success, :exit_code => 0, :stdout => '32-bit') }
+
+            it "uses 32 bit cygwin" do
+              host.should_receive(:execute).with(/#{cygwin}.*#{package}/)
+              host.install_package(package)
+            end
+          end
+
+          context "64 bit" do
+            let(:success_osarch_check) { double(:success, :exit_code => 0, :stdout => '64-bit') }
+
+            it "uses 64 bit cygwin" do
+              host.should_receive(:execute).with(/#{cygwin64}.*#{package}/)
+              host.install_package(package)
+            end
+          end
+        end
+
+        context "testing os name" do
+          let(:failed_osarch_check) { double(:failed, :exit_code => 1) }
+
+          before(:each) do
+            host.should_receive(:execute).with(/wmic os get osarchitecture/, anything).and_yield(failed_osarch_check)
+            host.should_receive(:execute).with(/wmic os get name/, anything).and_yield(name_check)
+          end
+
+          context "32 bit" do
+            let(:name_check) { double(:failure, :exit_code => 1) }
+
+            it "uses 32 bit cygwin" do
+              host.should_receive(:execute).with(/#{cygwin}.*#{package}/)
+              host.install_package(package)
+            end
+          end
+
+          context "64 bit" do
+            let(:name_check) { double(:success, :exit_code => 0) }
+
+            it "uses 64 bit cygwin" do
+              host.should_receive(:execute).with(/#{cygwin64}.*#{package}/)
+              host.install_package(package)
+            end
+          end
+        end
+      end
+    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!'
+    describe "executing commands" do
+      let(:command) { Beaker::Command.new('ls') }
+      let(:host) { Beaker::Host.create('host', make_host_opts('host', options.merge(platform))) }
+      let(:result) { Beaker::Result.new(host, 'ls') }
+
+      before :each do
+        result.stdout = 'stdout'
+        result.stderr = 'stderr'
+
+        logger = double(:logger)
+        logger.stub(:host_output)
+        logger.stub(:debug)
+        host.instance_variable_set :@logger, logger
+        conn = double(:connection)
+        conn.stub(:execute).and_return(result)
+        host.instance_variable_set :@connection, conn
+      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'
+      it "returns the result object"
+
+      context "controls the result objects logging" do
+        it "and passes a test if the exit_code doesn't match the default :acceptable_exit_codes of 0" do
+          result.exit_code = 0
+          expect{ host.exec(command,{}) }.to_not raise_error
+        end
+        it "and fails a test if the exit_code doesn't match the default :acceptable_exit_codes of 0" do
+          result.exit_code = 1
+          expect{ host.exec(command,{}) }.to raise_error
+        end
+        it "and passes a test if the exit_code matches :acceptable_exit_codes" do
+          result.exit_code = 0
+          expect{ host.exec(command,{:acceptable_exit_codes => 0}) }.to_not raise_error
+        end
+        it "and fails a test if the exit_code doesn't match :acceptable_exit_codes" do
+          result.exit_code = 0
+          expect{ host.exec(command,{:acceptable_exit_codes => 1}) }.to raise_error
+        end
+        it "and passes a test if the exit_code matches one of the :acceptable_exit_codes" do
+          result.exit_code = 127
+          expect{ host.exec(command,{:acceptable_exit_codes => [1,127]}) }.to_not raise_error
+        end
+        it "and passes a test if the exit_code matches one of the range of :acceptable_exit_codes" do
+          result.exit_code = 1
+          expect{ host.exec(command,{:acceptable_exit_codes => (0..127)}) }.to_not raise_error
+        end
+      end
+    end
 
     # 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)
+      logger = host[:logger]
+      conn = double(:connection)
       @options = { :logger => logger }
       host.instance_variable_set :@connection, conn
       args = [ 'source', 'target', {} ]
+      conn_args = args + [ nil ]
 
       logger.should_receive(:debug)
-      conn.should_receive(:scp_to).with(*args)
+      conn.should_receive(:scp_to).with( *conn_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)
+      logger = host[:logger]
+      conn = double(:connection)
       @options = { :logger => logger }
       host.instance_variable_set :@connection, conn
       args = [ 'source', 'target', {} ]
+      conn_args = args + [ nil ]
 
       logger.should_receive(:debug)
-      conn.should_receive(:scp_from).with(*args)
+      conn.should_receive(:scp_from).with( *conn_args )
 
       host.do_scp_from *args
     end
@@ -69,27 +176,10 @@ module Beaker
 
     context 'merging defaults' do
       it 'knows the difference between foss and pe' do
-        @pe = true
+        @options = { :type => 'pe' }
         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