beaker 1.21.0 → 2.0.0

data/spec/beaker/host/unix/pkg_spec.rb

@@ -25,67 +25,83 @@ module Beaker
 
     context "check_for_package" do
 
-      it "runs the correctly on sles" do
+      it "checks correctly on sles" do
         @opts = {'platform' => 'sles-is-me'}
         pkg = 'sles_package'
-        Beaker::Command.should_receive(:new).with("zypper se -i --match-exact #{pkg}").and_return('')
-        instance.should_receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive(:new).with("zypper se -i --match-exact #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
         expect( instance.check_for_package(pkg) ).to be === true
       end
  
-      it "runs the correctly on fedora" do
+      it "checks correctly on fedora" do
         @opts = {'platform' => 'fedora-is-me'}
         pkg = 'fedora_package'
-        Beaker::Command.should_receive(:new).with("rpm -q #{pkg}").and_return('')
-        instance.should_receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive(:new).with("rpm -q #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
         expect( instance.check_for_package(pkg) ).to be === true
       end
 
-      it "runs the correctly on centos" do
+      it "checks correctly on centos" do
         @opts = {'platform' => 'centos-is-me'}
         pkg = 'centos_package'
-        Beaker::Command.should_receive(:new).with("rpm -q #{pkg}").and_return('')
-        instance.should_receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive(:new).with("rpm -q #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
         expect( instance.check_for_package(pkg) ).to be === true
       end
 
-      it "runs the correctly on el-" do
+      it "checks correctly on EOS" do
+        @opts = {'platform' => 'eos-is-me'}
+        pkg = 'eos-package'
+        expect( Beaker::Command ).to receive(:new).with("rpm -q #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( instance.check_for_package(pkg) ).to be === true
+      end
+
+      it "checks correctly on el-" do
         @opts = {'platform' => 'el-is-me'}
         pkg = 'el_package'
-        Beaker::Command.should_receive(:new).with("rpm -q #{pkg}").and_return('')
-        instance.should_receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive(:new).with("rpm -q #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
         expect( instance.check_for_package(pkg) ).to be === true
       end
 
-      it "runs the correctly on debian" do
+      it "checks correctly on debian" do
         @opts = {'platform' => 'debian-is-me'}
         pkg = 'debian_package'
-        Beaker::Command.should_receive(:new).with("dpkg -s #{pkg}").and_return('')
-        instance.should_receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive(:new).with("dpkg -s #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
         expect( instance.check_for_package(pkg) ).to be === true
       end
 
-      it "runs the correctly on ubuntu" do
+      it "checks correctly on ubuntu" do
         @opts = {'platform' => 'ubuntu-is-me'}
         pkg = 'ubuntu_package'
-        Beaker::Command.should_receive(:new).with("dpkg -s #{pkg}").and_return('')
-        instance.should_receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive(:new).with("dpkg -s #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( instance.check_for_package(pkg) ).to be === true
+      end
+
+      it "checks correctly on cumulus" do
+        @opts = {'platform' => 'cumulus-is-me'}
+        pkg = 'cumulus_package'
+        expect( Beaker::Command ).to receive(:new).with("dpkg -s #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
         expect( instance.check_for_package(pkg) ).to be === true
       end
 
-      it "runs the correctly on solaris-11" do
+      it "checks correctly on solaris-11" do
         @opts = {'platform' => 'solaris-11-is-me'}
         pkg = 'solaris-11_package'
-        Beaker::Command.should_receive(:new).with("pkg info #{pkg}").and_return('')
-        instance.should_receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive(:new).with("pkg info #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
         expect( instance.check_for_package(pkg) ).to be === true
       end
 
-      it "runs the correctly on solaris-10" do
+      it "checks correctly on solaris-10" do
         @opts = {'platform' => 'solaris-10-is-me'}
         pkg = 'solaris-10_package'
-        Beaker::Command.should_receive(:new).with("pkginfo #{pkg}").and_return('')
-        instance.should_receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive(:new).with("pkginfo #{pkg}").and_return('')
+        expect( instance ).to receive(:exec).with('', :acceptable_exit_codes => (0...127)).and_return(generate_result("hello", {:exit_code => 0}))
         expect( instance.check_for_package(pkg) ).to be === true
       end
 

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

@@ -29,7 +29,7 @@ Name=#{group_name}
     end
 
     before(:each) do
-      instance.should_receive(:execute).with(/wmic group where/).and_yield(result)
+      expect( instance ).to receive(:execute).with(/wmic group where/).and_yield(result)
     end
 
     it "gets a group_list" do

data/spec/beaker/host_prebuilt_steps_spec.rb

@@ -19,8 +19,7 @@ describe Beaker do
                            hosts[1][:roles] = ['master', 'dashboard', 'agent', 'database']
                            hosts[2][:roles] = ['agent']
                            hosts }
-  let( :dummy_class )    { Class.new { include Beaker::HostPrebuiltSteps
-                                       include Beaker::DSL::Patterns } }
+  let( :dummy_class )    { Class.new { include Beaker::HostPrebuiltSteps } }
 
   context 'timesync' do
 
@@ -29,25 +28,25 @@ describe Beaker do
     it "can sync time on unix hosts" do
       hosts = make_hosts( { :platform => 'unix' } )
 
-      Beaker::Command.should_receive( :new ).with("ntpdate -t 20 #{ntpserver}").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("ntpdate -t 20 #{ntpserver}").exactly( 3 ).times
 
       subject.timesync( hosts, options )
     end
 
     it "can retry on failure on unix hosts" do
       hosts = make_hosts( { :platform => 'unix', :exit_code => [1, 0] } )
-      subject.stub( :sleep ).and_return(true)
+      allow( subject ).to receive( :sleep ).and_return(true)
 
-      Beaker::Command.should_receive( :new ).with("ntpdate -t 20 #{ntpserver}").exactly( 6 ).times
+      expect( Beaker::Command ).to receive( :new ).with("ntpdate -t 20 #{ntpserver}").exactly( 6 ).times
 
       subject.timesync( hosts, options )
     end
 
     it "eventually gives up and raises an error when unix hosts can't be synched" do
       hosts = make_hosts( { :platform => 'unix', :exit_code => 1 } )
-      subject.stub( :sleep ).and_return(true)
+      allow( subject ).to receive( :sleep ).and_return(true)
 
-      Beaker::Command.should_receive( :new ).with("ntpdate -t 20 #{ntpserver}").exactly( 5 ).times
+      expect( Beaker::Command ).to receive( :new ).with("ntpdate -t 20 #{ntpserver}").exactly( 5 ).times
 
       expect{ subject.timesync( hosts, options ) }.to raise_error
     end
@@ -55,10 +54,10 @@ describe Beaker do
     it "can sync time on windows hosts" do
       hosts = make_hosts( { :platform => 'windows' } )
 
-      Beaker::Command.should_receive( :new ).with("w32tm /register").exactly( 3 ).times
-      Beaker::Command.should_receive( :new ).with("net start w32time").exactly( 3 ).times
-      Beaker::Command.should_receive( :new ).with("w32tm /config /manualpeerlist:#{ntpserver} /syncfromflags:manual /update").exactly( 3 ).times
-      Beaker::Command.should_receive( :new ).with("w32tm /resync").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("w32tm /register").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("net start w32time").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("w32tm /config /manualpeerlist:#{ntpserver} /syncfromflags:manual /update").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("w32tm /resync").exactly( 3 ).times
 
       subject.timesync( hosts, options )
 
@@ -67,7 +66,7 @@ describe Beaker do
     it "can sync time on Sles hosts" do
       hosts = make_hosts( { :platform => 'sles-13.1-x64' } )
 
-      Beaker::Command.should_receive( :new ).with("sntp #{ntpserver}").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("sntp #{ntpserver}").exactly( 3 ).times
 
       subject.timesync( hosts, options )
 
@@ -76,7 +75,7 @@ describe Beaker do
     it "can set time server on unix hosts" do
       hosts = make_hosts( { :platform => 'unix' } )
 
-      Beaker::Command.should_receive( :new ).with("ntpdate -t 20 #{ntpserver_set}").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("ntpdate -t 20 #{ntpserver_set}").exactly( 3 ).times
 
       subject.timesync( hosts, options_ntp )
     end
@@ -84,10 +83,10 @@ describe Beaker do
     it "can set time server on windows hosts" do
       hosts = make_hosts( { :platform => 'windows' } )
 
-      Beaker::Command.should_receive( :new ).with("w32tm /register").exactly( 3 ).times
-      Beaker::Command.should_receive( :new ).with("net start w32time").exactly( 3 ).times
-      Beaker::Command.should_receive( :new ).with("w32tm /config /manualpeerlist:#{ntpserver_set} /syncfromflags:manual /update").exactly( 3 ).times
-      Beaker::Command.should_receive( :new ).with("w32tm /resync").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("w32tm /register").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("net start w32time").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("w32tm /config /manualpeerlist:#{ntpserver_set} /syncfromflags:manual /update").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("w32tm /resync").exactly( 3 ).times
 
       subject.timesync( hosts, options_ntp )
 
@@ -96,7 +95,7 @@ describe Beaker do
     it "can set time server on Sles hosts" do
       hosts = make_hosts( { :platform => 'sles-13.1-x64' } )
 
-      Beaker::Command.should_receive( :new ).with("sntp #{ntpserver_set}").exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with("sntp #{ntpserver_set}").exactly( 3 ).times
 
       subject.timesync( hosts, options_ntp )
 
@@ -134,7 +133,7 @@ describe Beaker do
     it "can perform apt-get on ubuntu hosts" do
       host = make_host( 'testhost', { :platform => 'ubuntu' } )
 
-      Beaker::Command.should_receive( :new ).with("apt-get update").once
+      expect( Beaker::Command ).to receive( :new ).with("apt-get update").once
 
       subject.apt_get_update( host )
 
@@ -143,16 +142,25 @@ describe Beaker do
     it "can perform apt-get on debian hosts" do
       host = make_host( 'testhost', { :platform => 'debian' } )
 
-      Beaker::Command.should_receive( :new ).with("apt-get update").once
+      expect( Beaker::Command ).to receive( :new ).with("apt-get update").once
 
       subject.apt_get_update( host )
 
     end
 
-    it "does nothing on non debian/ubuntu hosts" do
+    it "can perform apt-get on cumulus hosts" do
+      host = make_host( 'testhost', { :platform => 'cumulus' } )
+
+      expect( Beaker::Command ).to receive( :new ).with("apt-get update").once
+
+      subject.apt_get_update( host )
+
+    end
+
+    it "does nothing on non debian/ubuntu/cumulus hosts" do
       host = make_host( 'testhost', { :platform => 'windows' } )
 
-      Beaker::Command.should_receive( :new ).never
+      expect( Beaker::Command ).to receive( :new ).never
 
       subject.apt_get_update( host )
 
@@ -169,13 +177,13 @@ describe Beaker do
       filepath = "/path/to/file"
       host = make_host( 'testhost', { :platform => 'windows' })
       tempfile = double( 'tempfile' )
-      tempfile.stub( :path ).and_return( tempfilepath )
-      Tempfile.stub( :open ).and_yield( tempfile )
+      allow( tempfile ).to receive( :path ).and_return( tempfilepath )
+      allow( Tempfile ).to receive( :open ).and_yield( tempfile )
       file = double( 'file' )
-      File.stub( :open ).and_yield( file )
+      allow( File ).to receive( :open ).and_yield( file )
 
-      file.should_receive( :puts ).with( content ).once
-      host.should_receive( :do_scp_to ).with( tempfilepath, filepath, subject.instance_variable_get( :@options ) ).once
+      expect( file ).to receive( :puts ).with( content ).once
+      expect( host ).to receive( :do_scp_to ).with( tempfilepath, filepath, subject.instance_variable_get( :@options ) ).once
 
       subject.copy_file_to_remote(host, filepath, content)
 
@@ -189,10 +197,10 @@ describe Beaker do
     it "correctly configures ubuntu hosts" do
       hosts = make_hosts( { :platform => 'ubuntu', :exit_code => 1 } )
 
-      Beaker::Command.should_receive( :new ).with( "if test -f /etc/apt/apt.conf; then mv /etc/apt/apt.conf /etc/apt/apt.conf.bk; fi" ).exactly( 3 )
+      expect( Beaker::Command ).to receive( :new ).with( "if test -f /etc/apt/apt.conf; then mv /etc/apt/apt.conf /etc/apt/apt.conf.bk; fi" ).exactly( 3 )
       hosts.each do |host|
-        subject.should_receive( :copy_file_to_remote ).with( host, '/etc/apt/apt.conf', apt_cfg ).once
-        subject.should_receive( :apt_get_update ).with( host ).once
+        expect( subject ).to receive( :copy_file_to_remote ).with( host, '/etc/apt/apt.conf', apt_cfg ).once
+        expect( subject ).to receive( :apt_get_update ).with( host ).once
       end
 
       subject.proxy_config( hosts, options )
@@ -202,10 +210,23 @@ describe Beaker do
     it "correctly configures debian hosts" do
       hosts = make_hosts( { :platform => 'debian' } )
 
-      Beaker::Command.should_receive( :new ).with( "if test -f /etc/apt/apt.conf; then mv /etc/apt/apt.conf /etc/apt/apt.conf.bk; fi" ).exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with( "if test -f /etc/apt/apt.conf; then mv /etc/apt/apt.conf /etc/apt/apt.conf.bk; fi" ).exactly( 3 ).times
+      hosts.each do |host|
+        expect( subject ).to receive( :copy_file_to_remote ).with( host, '/etc/apt/apt.conf', apt_cfg ).once
+        expect( subject ).to receive( :apt_get_update ).with( host ).once
+      end
+
+      subject.proxy_config( hosts, options )
+
+    end
+
+    it "correctly configures cumulus hosts" do
+      hosts = make_hosts( { :platform => 'cumulus' } )
+
+      expect( Beaker::Command ).to receive( :new ).with( "if test -f /etc/apt/apt.conf; then mv /etc/apt/apt.conf /etc/apt/apt.conf.bk; fi" ).exactly( 3 ).times
       hosts.each do |host|
-        subject.should_receive( :copy_file_to_remote ).with( host, '/etc/apt/apt.conf', apt_cfg ).once
-        subject.should_receive( :apt_get_update ).with( host ).once
+        expect( subject ).to receive( :copy_file_to_remote ).with( host, '/etc/apt/apt.conf', apt_cfg ).once
+        expect( subject ).to receive( :apt_get_update ).with( host ).once
       end
 
       subject.proxy_config( hosts, options )
@@ -215,19 +236,19 @@ describe Beaker do
     it "correctly configures solaris-11 hosts" do
       hosts = make_hosts( { :platform => 'solaris-11' } )
 
-      Beaker::Command.should_receive( :new ).with( "/usr/bin/pkg unset-publisher solaris || :" ).exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with( "/usr/bin/pkg unset-publisher solaris || :" ).exactly( 3 ).times
       hosts.each do |host|
-        Beaker::Command.should_receive( :new ).with( "/usr/bin/pkg set-publisher -g %s solaris" % ips_pkg_repo ).once
+        expect( Beaker::Command ).to receive( :new ).with( "/usr/bin/pkg set-publisher -g %s solaris" % ips_pkg_repo ).once
       end
 
       subject.proxy_config( hosts, options )
 
     end
 
-    it "does nothing for non ubuntu/debian/solaris-11 hosts" do
+    it "does nothing for non ubuntu/debian/cumulus/solaris-11 hosts" do
       hosts = make_hosts( { :platform => 'windows' } )
-      
-      Beaker::Command.should_receive( :new ).never
+
+      expect( Beaker::Command ).to receive( :new ).never
 
       subject.proxy_config( hosts, options )
 
@@ -238,16 +259,21 @@ describe Beaker do
     subject { dummy_class.new }
 
     it "add extras for el-5/6 hosts" do
-      hosts = make_hosts( { :platform => Beaker::Platform.new('el-5-arch'), :exit_code => 1 } )
-      hosts[0][:platform] = Beaker::Platform.new('el-6-arch')
 
-      Beaker::Command.should_receive( :new ).with("rpm -qa | grep epel-release").exactly( 3 ).times
-      Beaker::Command.should_receive( :new ).with("rpm -i http://mirrors.kernel.org/fedora-epel/6/i386/epel-release-6-8.noarch.rpm").exactly( 1 ).times
-      Beaker::Command.should_receive( :new ).with("rpm -i http://mirrors.kernel.org/fedora-epel/5/i386/epel-release-5-4.noarch.rpm").exactly( 2 ).times
-      Beaker::Command.should_receive( :new ).with("sed -i -e 's;#baseurl.*$;baseurl=http://mirrors\\.kernel\\.org/fedora\\-epel/6/$basearch;' /etc/yum.repos.d/epel.repo").exactly( 1 ).times
-      Beaker::Command.should_receive( :new ).with("sed -i -e 's;#baseurl.*$;baseurl=http://mirrors\\.kernel\\.org/fedora\\-epel/5/$basearch;' /etc/yum.repos.d/epel.repo").exactly( 2 ).times
-      Beaker::Command.should_receive( :new ).with("sed -i -e '/mirrorlist/d' /etc/yum.repos.d/epel.repo").exactly( 3 ).times
-      Beaker::Command.should_receive( :new ).with("yum clean all && yum makecache").exactly( 3 ).times
+      hosts = make_hosts( { :platform => Beaker::Platform.new('el-5-arch'), :exit_code => 1 }, 6 )
+      hosts[0][:platform] = Beaker::Platform.new('el-6-arch')
+      hosts[1][:platform] = Beaker::Platform.new('centos-6-arch')
+      hosts[2][:platform] = Beaker::Platform.new('scientific-6-arch')
+      hosts[3][:platform] = Beaker::Platform.new('redhat-6-arch')
+      hosts[4][:platform] = Beaker::Platform.new('oracle-5-arch')
+
+      expect( Beaker::Command ).to receive( :new ).with("rpm -qa | grep epel-release").exactly( 6 ).times
+      expect( Beaker::Command ).to receive( :new ).with("rpm -i http://mirrors.kernel.org/fedora-epel/6/i386/epel-release-6-8.noarch.rpm").exactly( 4 ).times
+      expect( Beaker::Command ).to receive( :new ).with("rpm -i http://mirrors.kernel.org/fedora-epel/5/i386/epel-release-5-4.noarch.rpm").exactly( 2 ).times
+      expect( Beaker::Command ).to receive( :new ).with("sed -i -e 's;#baseurl.*$;baseurl=http://mirrors\\.kernel\\.org/fedora\\-epel/6/$basearch;' /etc/yum.repos.d/epel.repo").exactly( 4 ).times
+      expect( Beaker::Command ).to receive( :new ).with("sed -i -e 's;#baseurl.*$;baseurl=http://mirrors\\.kernel\\.org/fedora\\-epel/5/$basearch;' /etc/yum.repos.d/epel.repo").exactly( 2 ).times
+      expect( Beaker::Command ).to receive( :new ).with("sed -i -e '/mirrorlist/d' /etc/yum.repos.d/epel.repo").exactly( 6 ).times
+      expect( Beaker::Command ).to receive( :new ).with("yum clean all && yum makecache").exactly( 6 ).times
 
       subject.add_el_extras( hosts, options )
 
@@ -256,7 +282,7 @@ describe Beaker do
     it "should do nothing for non el-5/6 hosts" do
       hosts = make_hosts( { :platform => Beaker::Platform.new('windows-version-arch') } )
 
-      Beaker::Command.should_receive( :new ).never
+      expect( Beaker::Command ).to receive( :new ).never
 
       subject.add_el_extras( hosts, options )
 
@@ -269,7 +295,18 @@ describe Beaker do
     it "can sync keys on a solaris host" do
       @platform = 'solaris'
 
-      Beaker::Command.should_receive( :new ).with( sync_cmd % "bash" ).exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with( sync_cmd % "| bash" ).exactly( 3 ).times
+
+      subject.sync_root_keys( hosts, options )
+
+    end
+
+    it "can sync keys on an eos host" do
+      @platform = 'eos'
+
+      expect( Beaker::Command ).to receive( :new ).with( sync_cmd % "> manage_root_authorized_keys" ).exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with( "sed -i 's|mv -f $SSH_HOME/authorized_keys.tmp $SSH_HOME/authorized_keys|cp -f $SSH_HOME/authorized_keys.tmp $SSH_HOME/authorized_keys|' manage_root_authorized_keys" ).exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with( "bash manage_root_authorized_keys" ).exactly( 3 ).times
 
       subject.sync_root_keys( hosts, options )
 
@@ -277,7 +314,7 @@ describe Beaker do
 
     it "can sync keys on a non-solaris host" do
 
-      Beaker::Command.should_receive( :new ).with( sync_cmd % "env PATH=/usr/gnu/bin:$PATH bash" ).exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with( sync_cmd % "| env PATH=/usr/gnu/bin:$PATH bash" ).exactly( 3 ).times
 
       subject.sync_root_keys( hosts, options )
 
@@ -292,8 +329,8 @@ describe Beaker do
 
       hosts.each do |host|
         unix_only_pkgs.each do |pkg|
-          host.should_receive( :check_for_package ).with( pkg ).once.and_return( false )
-          host.should_receive( :install_package ).with( pkg ).once
+          expect( host ).to receive( :check_for_package ).with( pkg ).once.and_return( false )
+          expect( host ).to receive( :install_package ).with( pkg ).once
         end
       end
 
@@ -306,8 +343,8 @@ describe Beaker do
 
       hosts.each do |host|
         windows_pkgs.each do |pkg|
-          host.should_receive( :check_for_package ).with( pkg ).once.and_return( false )
-          host.should_receive( :install_package ).with( pkg ).once
+          expect( host ).to receive( :check_for_package ).with( pkg ).once.and_return( false )
+          expect( host ).to receive( :install_package ).with( pkg ).once
         end
       end
 
@@ -320,8 +357,8 @@ describe Beaker do
 
       hosts.each do |host|
         sles_only_pkgs.each do |pkg|
-          host.should_receive( :check_for_package).with( pkg ).once.and_return( false )
-          host.should_receive( :install_package ).with( pkg ).once
+          expect( host ).to receive( :check_for_package).with( pkg ).once.and_return( false )
+          expect( host ).to receive( :install_package ).with( pkg ).once
         end
 
       end
@@ -337,7 +374,7 @@ describe Beaker do
     it "can find the domain for a host" do
       host = make_host('name', { :stdout => "domain labs.lan d.labs.net dc1.labs.net labs.com\nnameserver 10.16.22.10\nnameserver 10.16.22.11" } )
 
-      Beaker::Command.should_receive( :new ).with( "cat /etc/resolv.conf" ).once
+      expect( Beaker::Command ).to receive( :new ).with( "cat /etc/resolv.conf" ).once
 
       expect( subject.get_domain_name( host ) ).to be === "labs.lan"
 
@@ -346,7 +383,7 @@ describe Beaker do
     it "can find the search for a host" do
       host = make_host('name', { :stdout => "search labs.lan d.labs.net dc1.labs.net labs.com\nnameserver 10.16.22.10\nnameserver 10.16.22.11" } )
 
-      Beaker::Command.should_receive( :new ).with( "cat /etc/resolv.conf" ).once
+      expect( Beaker::Command ).to receive( :new ).with( "cat /etc/resolv.conf" ).once
 
       expect( subject.get_domain_name( host ) ).to be === "labs.lan"
 
@@ -359,7 +396,7 @@ describe Beaker do
     it "can exec the get_ip command" do
       host = make_host('name', { :stdout => "192.168.2.130\n" } )
 
-      Beaker::Command.should_receive( :new ).with( "ip a|awk '/global/{print$2}' | cut -d/ -f1 | head -1" ).once
+      expect( Beaker::Command ).to receive( :new ).with( "ip a|awk '/global/{print$2}' | cut -d/ -f1 | head -1" ).once
 
       expect( subject.get_ip( host ) ).to be === "192.168.2.130"
 
@@ -374,8 +411,8 @@ describe Beaker do
       host = make_host('name', {})
       etc_hosts = "127.0.0.1  localhost\n192.168.2.130 pe-ubuntu-lucid\n192.168.2.128 pe-centos6\n192.168.2.131 pe-debian6"
 
-      Beaker::Command.should_receive( :new ).with( "echo '#{etc_hosts}' > /etc/hosts" ).once
-      host.should_receive( :exec ).once
+      expect( Beaker::Command ).to receive( :new ).with( "echo '#{etc_hosts}' > /etc/hosts" ).once
+      expect( host ).to receive( :exec ).once
 
       subject.set_etc_hosts(host, etc_hosts)
     end
@@ -387,23 +424,112 @@ describe Beaker do
     subject { dummy_class.new }
     proxyurl = "http://192.168.2.100:3128"
 
-    it "can set proxy config on a debian/ubuntu host" do
-      host = make_host('name', { :platform => 'ubuntu' } )
+    it "can set proxy config on a debian/ubuntu/cumulus host" do
+      host = make_host('name', { :platform => 'cumulus' } )
 
-      Beaker::Command.should_receive( :new ).with( "echo 'Acquire::http::Proxy \"#{proxyurl}/\";' >> /etc/apt/apt.conf.d/10proxy" ).once
-      host.should_receive( :exec ).once
+      expect( Beaker::Command ).to receive( :new ).with( "echo 'Acquire::http::Proxy \"#{proxyurl}/\";' >> /etc/apt/apt.conf.d/10proxy" ).once
+      expect( host ).to receive( :exec ).once
 
       subject.package_proxy(host, options.merge( {'package_proxy' => proxyurl}) )
     end
 
-    it "can set proxy config on a redhat/centos host" do
+    it "can set proxy config on a centos host" do
       host = make_host('name', { :platform => 'centos' } )
 
-      Beaker::Command.should_receive( :new ).with( "echo 'proxy=#{proxyurl}/' >> /etc/yum.conf" ).once
-      host.should_receive( :exec ).once
+      expect( Beaker::Command ).to receive( :new ).with( "echo 'proxy=#{proxyurl}/' >> /etc/yum.conf" ).once
+      expect( host ).to receive( :exec ).once
 
       subject.package_proxy(host, options.merge( {'package_proxy' => proxyurl}) )
+    end
+
+  end
+
+  context "set_env" do
+    subject { dummy_class.new }
+
+    it "can set the environment on a windows host" do
+      commands = [
+        "echo 'PermitUserEnvironment yes' >> /etc/sshd_config",
+        "cygrunsrv -E sshd",
+        "cygrunsrv -S sshd"
+      ]
+      set_env_helper('windows', commands)
+    end
+
+    it "can set the environment on an OS X host" do
+      commands = [
+        "echo 'PermitUserEnvironment yes' >> /etc/sshd_config",
+        "launchctl unload /System/Library/LaunchDaemons/ssh.plist",
+        "launchctl load /System/Library/LaunchDaemons/ssh.plist"
+      ]
+      set_env_helper('osx', commands)
+    end
+
+    it "can set the environment on an ssh-based linux host" do
+      commands = [
+        "echo 'PermitUserEnvironment yes' >> /etc/ssh/sshd_config",
+        "service ssh restart"
+      ]
+      set_env_helper('ubuntu', commands)
+    end
+
+    it "can set the environment on an sshd-based linux host" do
+      commands = [
+          "echo 'PermitUserEnvironment yes' >> /etc/ssh/sshd_config",
+          "service sshd restart"
+      ]
+      set_env_helper('eos', commands)
+    end
+
+    it "can set the environment on an sles host" do
+      commands = [
+        "echo 'PermitUserEnvironment yes' >> /etc/ssh/sshd_config",
+        "rcsshd restart"
+      ]
+      set_env_helper('sles', commands)
+    end
+
+    it "can set the environment on a solaris host" do
+      commands = [
+        "echo 'PermitUserEnvironment yes' >> /etc/ssh/sshd_config",
+        "svcadm restart svc:/network/ssh:default"
+      ]
+      set_env_helper('solaris', commands)
+    end
+
+    it "can set the environment on an aix host" do
+      commands = [
+        "echo 'PermitUserEnvironment yes' >> /etc/ssh/sshd_config",
+        "stopsrc -g ssh",
+        "startsrc -g ssh"
+      ]
+      set_env_helper('aix', commands)
+    end
+
+    def set_env_helper(platform_name, host_specific_commands_array)
+      host = make_host('name', {
+          :platform     => platform_name,
+          :ssh_env_file => 'ssh_env_file'
+      } )
+      opts = {
+          :env1_key => :env1_value,
+          :env2_key => :env2_value
+      }
+
+      expect( subject ).to receive( :construct_env ).and_return( opts )
+      host_specific_commands_array.each do |command|
+        expect( Beaker::Command ).to receive( :new ).with( command ).once
+      end
+      expect( Beaker::Command ).to receive( :new ).with( "touch #{host[:ssh_env_file]}" ).once
+      expect( host ).to receive( :add_env_var ).with( 'RUBYLIB', '$RUBYLIB' ).once
+      expect( host ).to receive( :add_env_var ).with( 'PATH', '$PATH' ).once
+      opts.each_pair do |key, value|
+        expect( host ).to receive( :add_env_var ).with( key, value ).once
+      end
+      expect( host ).to receive( :add_env_var ).with( 'CYGWIN', 'nodosfilewarning' ).once if platform_name =~ /windows/
+      expect( host ).to receive( :exec ).exactly( host_specific_commands_array.length + 1 ).times
 
+      subject.set_env(host, options.merge( opts ))
     end
 
   end