beaker 1.21.0 → 2.0.0

data/spec/beaker/dsl/outcomes_spec.rb

@@ -6,11 +6,11 @@ end
 
 describe ClassMixedWithDSLOutcomes do
   let(:logger) { double }
-  before { subject.stub( :logger ).and_return( logger ) }
+  before { allow( subject ).to receive( :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( logger ).to receive( :notify ).with( /blah/ )
       expect { subject.pass_test('blah') }.
         to raise_error Beaker::DSL::Outcomes::PassTest
     end
@@ -18,7 +18,7 @@ describe ClassMixedWithDSLOutcomes do
 
   describe '#skip_test' do
     it "logs the notification passed to it and raises SkipTest" do
-      logger.should_receive( :notify ).with( /blah/ )
+      expect( logger ).to receive( :notify ).with( /blah/ )
       expect { subject.skip_test('blah') }.
         to raise_error Beaker::DSL::Outcomes::SkipTest
     end
@@ -26,7 +26,7 @@ describe ClassMixedWithDSLOutcomes do
 
   describe '#pending_test' do
     it "logs the notification passed to it and raises PendingTest" do
-      logger.should_receive( :warn ).with( /blah/ )
+      expect( logger ).to receive( :warn ).with( /blah/ )
       expect { subject.pending_test('blah') }.
         to raise_error Beaker::DSL::Outcomes::PendingTest
     end
@@ -34,8 +34,8 @@ describe ClassMixedWithDSLOutcomes do
 
   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( logger ).to receive( :warn )
+      expect( logger ).to receive( :pretty_backtrace )
       expect { subject.fail_test('blah') }.
         to raise_error Beaker::DSL::Outcomes::FailTest
     end

data/spec/beaker/dsl/roles_spec.rb

@@ -21,76 +21,76 @@ describe ClassMixedWithDSLRoles do
   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 ).to 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 ).to 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 ).to 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 ).exactly( 1 ).times.and_return( hosts )
+      expect( subject ).to receive( :hosts ).exactly( 1 ).times.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 ).to 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 ).to 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 ).to 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 ).to 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 ).to 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 ).to receive( :hosts ).and_return( hosts )
       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( 1  ).times.and_return( hosts )
+      expect( subject ).to receive( :hosts ).exactly( 1  ).times.and_return( hosts )
       expect( subject.default ).to be == default
     end
     it 'raises an error if there is more than one default' do
       @hosts = [ db, monolith, default, default ]
-      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :hosts ).and_return( hosts )
       expect { subject.database }.to raise_error Beaker::DSL::FailTest
     end
     it 'and raises an error if there is no default' do
       @hosts = [ agent1, agent2, custom ]
-      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :hosts ).and_return( hosts )
       expect { subject.database }.to raise_error Beaker::DSL::FailTest
     end
   end
@@ -107,26 +107,35 @@ describe ClassMixedWithDSLRoles do
     it 'creates new method for role "role_correct!"' do
       test_role = "role_correct!"
       subject.add_role_def( test_role )
-      subject.should respond_to test_role
+      expect( subject ).to respond_to test_role
       subject.class.send( :undef_method, test_role )
     end
     it 'returns a single node for a new method for a role defined in a single node' do
       @hosts = [ agent1, agent2, monolith ]
-      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :hosts ).and_return( hosts )
       test_role = "custom_role"
       subject.add_role_def( test_role )
-      subject.should respond_to test_role
+      expect( subject ).to respond_to test_role
       expect( subject.send( test_role )).to be == @hosts[2]
       subject.class.send( :undef_method, test_role )
     end
     it 'returns an array of nodes for a new method for a role defined in multiple nodes' do
       @hosts = [ agent1, agent2, monolith, custom ]
-      subject.should_receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :hosts ).and_return( hosts )
       test_role = "custom_role"
       subject.add_role_def( test_role )
-      subject.should respond_to test_role
+      expect( subject ).to respond_to test_role
       expect( subject.send( test_role )).to be == [@hosts[2], @hosts[3]]
       subject.class.send( :undef_method, test_role )
     end
   end
+  describe '#any_hosts_as?' do
+    it 'returns true if a host exists, false otherwise' do
+      @hosts = [ agent1, agent2 ]
+      # expect( subject ).to receive( :hosts ).and_return( hosts )
+      expect( subject ).to receive( :hosts ).exactly( 2 ).times.and_return( hosts )
+      expect( subject.any_hosts_as?( "agent" )).to be == true
+      expect( subject.any_hosts_as?( "custom_role" )).to be == false
+    end
+  end
 end

data/spec/beaker/dsl/structure_spec.rb

@@ -12,15 +12,15 @@ describe ClassMixedWithDSLStructure do
     end
 
     it 'notifies the logger' do
-      subject.should_receive( :logger ).and_return( logger )
-      logger.should_receive( :notify )
+      expect( subject ).to receive( :logger ).and_return( logger )
+      expect( logger ).to 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 )
+      expect( subject ).to receive( :logger ).and_return( logger )
+      expect( logger ).to receive( :notify )
+      expect( subject ).to receive( :foo )
       subject.step 'blah' do
         subject.foo
       end
@@ -33,15 +33,15 @@ describe ClassMixedWithDSLStructure do
     end
 
     it 'notifies the logger' do
-      subject.should_receive( :logger ).and_return( logger )
-      logger.should_receive( :notify )
+      expect( subject ).to receive( :logger ).and_return( logger )
+      expect( logger ).to 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 )
+      expect( subject ).to receive( :logger ).and_return( logger )
+      expect( logger ).to receive( :notify )
+      expect( subject ).to receive( :foo )
       subject.test_name 'blah' do
         subject.foo
       end
@@ -53,7 +53,7 @@ describe ClassMixedWithDSLStructure do
       teardown_array = double
       subject.instance_variable_set :@teardown_procs, teardown_array
       block = lambda { 'blah' }
-      teardown_array.should_receive( :<< ).with( block )
+      expect( teardown_array ).to receive( :<< ).with( block )
       subject.teardown &block
     end
   end

data/spec/beaker/dsl/wrappers_spec.rb

@@ -5,30 +5,38 @@ class ClassMixedWithDSLWrappers
 end
 
 describe ClassMixedWithDSLWrappers do
-  let(:opts)  { {'ENV' => default_opts} }
-  let(:default_opts) { Beaker::Command::DEFAULT_GIT_ENV }
+  let(:opts)       { {'ENV' => { :HOME => "/"}, :cmdexe => true } }
+  let(:empty_opts) { {'ENV' => {}, :cmdexe => true } }
+
   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)
+      expect( Beaker::Command ).to receive( :new ).
+        with('facter', [ '-p' ], empty_opts)
       subject.facter( '-p' )
     end
   end
 
+  describe '#cfacter' do
+    it 'should split out the options and pass "cfacter" as first arg to Command' do
+      expect( Beaker::Command ).to receive( :new ).
+        with('cfacter', [ '-p' ], empty_opts)
+      subject.cfacter( '-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)
+      expect( Beaker::Command ).to receive( :new ).
+        with('hiera', [ '-p' ], empty_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 = opts
       merged_opts[:server] = 'master'
-      Beaker::Command.should_receive( :new ).
+      expect( Beaker::Command ).to receive( :new ).
         with('puppet agent', [ '-tv' ], merged_opts)
       subject.puppet( 'agent', '-tv', :server => 'master', 'ENV' => {:HOME => '/'})
     end
@@ -36,7 +44,7 @@ describe ClassMixedWithDSLWrappers do
 
   describe '#host_command' do
     it 'delegates to HostCommand.new' do
-      Beaker::HostCommand.should_receive( :new ).with( 'blah' )
+      expect( Beaker::HostCommand ).to receive( :new ).with( 'blah' )
       subject.host_command( 'blah' )
     end
   end
@@ -44,9 +52,25 @@ describe ClassMixedWithDSLWrappers do
   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' )
+        expect( subject ).to receive( :puppet ).with( sub, 'blah' )
         subject.send( "puppet_#{sub}", 'blah')
       end
     end
   end
+
+  describe '#powershell' do
+    it 'should pass "powershell.exe <args> -Command <command>" to Command' do
+      command = subject.powershell("Set-Content -path 'fu.txt' -value 'fu'")
+      expect(command.command ).to be === 'powershell.exe'
+      expect( command.args).to be === ' -ExecutionPolicy Bypass -InputFormat None -NoLogo -NoProfile -NonInteractive -Command "Set-Content -path \'fu.txt\' -value \'fu\'"'
+      expect( command.options ).to be === {}
+    end
+
+    it 'should merge the arguments provided with the defaults' do
+      command = subject.powershell("Set-Content -path 'fu.txt' -value 'fu'", {'ExecutionPolicy' => 'Unrestricted'})
+      expect( command.command).to be === 'powershell.exe'
+      expect( command.args ).to be === ' -ExecutionPolicy Unrestricted -InputFormat None -NoLogo -NoProfile -NonInteractive -Command "Set-Content -path \'fu.txt\' -value \'fu\'"'
+      expect( command.options ).to be === {}
+    end
+  end
 end

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

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+class MacGroupTest
+  include Mac::Group
+end
+
+describe MacGroupTest do
+  let( :puppet1 ) do <<-EOS
+name: puppet1
+password: *
+gid: 55
+
+EOS
+  end
+  let( :puppet2 ) do <<-EOS
+name: puppet2
+password: *
+gid: 56
+
+EOS
+  end
+  let( :dscacheutil_list ) do <<-EOS
+#{puppet1}
+#{puppet2}
+EOS
+  end
+  let( :command )  { 'ls' }
+  let( :host ) { double.as_null_object }
+  let( :result ) { Beaker::Result.new( host, command ) }
+
+  describe '#group_list' do
+
+    it 'returns group names list correctly' do
+      result.stdout = dscacheutil_list
+      expect( subject ).to receive( :execute ).and_yield(result)
+      expect( subject.group_list ).to be === ['puppet1', 'puppet2']
+    end
+
+    it 'yields correctly with the result object' do
+      result.stdout = dscacheutil_list
+      expect( subject ).to receive( :execute ).and_yield(result)
+      subject.group_list { |result|
+        expect( result.stdout ).to be === dscacheutil_list
+      }
+    end
+
+  end
+
+  describe '#group_get' do
+
+    it 'fails if a name line isn\'t included' do
+      result.stdout = ''
+      group_name = 'any_name'
+      expect( subject ).to receive( :execute ).and_yield(result)
+      expect { subject.group_get(group_name) }.to raise_error(MiniTest::Assertion, "failed to get group #{group_name}")
+    end
+
+    it 'parses mac dscacheutil output into /etc/group format correctly' do
+      result.stdout = puppet1
+      expect( subject ).to receive( :execute ).and_yield(result)
+      subject.group_get('puppet1') do |answer|
+        expect(answer).to be === 'puppet1:*:55'
+      end
+    end
+
+  end
+
+  describe '#group_gid' do
+
+    it 'parses mac dscacheutil output into the gid correctly' do
+      result.stdout = puppet1
+      expect( subject ).to receive( :execute ).and_yield(result)
+      expect( subject.group_gid(puppet1) ).to be === '55'
+    end
+
+    it 'returns -1 if gid not found' do
+      result.stdout = ''
+      expect( subject ).to receive( :execute ).and_yield(result)
+      expect( subject.group_gid(puppet1) ).to be === -1
+    end
+
+  end
+
+  describe '#group_present' do
+
+    it 'returns group existence without running create command if it already exists' do
+      result.stdout = puppet1
+      expect( subject ).to receive( :execute ).once.and_yield(result)
+      subject.group_present( 'puppet1' )
+    end
+
+    it 'runs correct create command if group does not exist' do
+      result.stdout = ''
+      gid = 512
+      name = "madeup_group"
+
+      expect( subject ).to receive( :gid_next ).and_return(gid)
+      expect( subject ).to receive( :execute ).once.ordered.and_yield(result)
+      expect( subject ).to receive( :execute ).with("dscl . create /Groups/#{name} && dscl . create /Groups/#{name} PrimaryGroupID #{gid}").once.ordered
+      subject.group_present( name )
+    end
+
+  end
+
+  describe '#group_absent' do
+
+    it 'calls execute to run logic' do
+      name = "main_one"
+      expect( subject ).to receive( :execute ).once.with("if dscl . -list /Groups/#{name}; then dscl . -delete /Groups/#{name}; fi", {})
+      subject.group_absent( name )
+    end
+
+  end
+
+  describe '#gid_next' do
+
+    it 'returns the next ID given' do
+      n = 10
+      expect( subject ).to receive( :execute ).and_return("#{n}")
+      expect( subject.gid_next ).to be === n + 1
+    end
+
+  end
+end

data/spec/beaker/host/mac/user_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+class MacUserTest
+  include Mac::User
+end
+
+describe MacUserTest do
+  let( :puppet1 ) do <<-EOS
+name: puppet1
+password: *
+uid: 67
+gid: 234
+dir: /Users/puppet1
+shell: /bin/bash
+gecos: Unprivileged User
+
+EOS
+  end
+  let( :puppet2 ) do <<-EOS
+name: puppet2
+password: *
+uid: 68
+gid: 235
+dir: /Users/puppet2
+shell: /bin/sh
+gecos: puppet
+
+EOS
+  end
+  let( :dscacheutil_list ) do <<-EOS
+#{puppet1}
+#{puppet2}
+EOS
+  end
+  let( :command )  { 'ls' }
+  let( :host ) { double.as_null_object }
+  let( :result ) { Beaker::Result.new( host, command ) }
+
+  describe '#user_list' do
+
+    it 'returns user names list correctly' do
+      result.stdout = dscacheutil_list
+      expect( subject ).to receive( :execute ).and_yield(result)
+      expect( subject.user_list ).to be === ['puppet1', 'puppet2']
+    end
+
+    it 'yields correctly with the result object' do
+      result.stdout = dscacheutil_list
+      expect( subject ).to receive( :execute ).and_yield(result)
+      subject.user_list { |result|
+        expect( result.stdout ).to be === dscacheutil_list
+      }
+    end
+
+  end
+
+  describe '#user_get' do
+
+    it 'fails if a name line isn\'t included' do
+      result.stdout = ''
+      user_name = 'any_name'
+      expect( subject ).to receive( :execute ).and_yield(result)
+      expect { subject.user_get(user_name) }.to raise_error(MiniTest::Assertion, "failed to get user #{user_name}")
+    end
+
+    it 'parses mac dscacheutil output into /etc/passwd format correctly' do
+      result.stdout = puppet1
+      expect( subject ).to receive( :execute ).and_yield(result)
+      expect( subject.user_get('puppet1') ).to be === "puppet1:*:67:234:puppet1:/Users/puppet1:/bin/bash"
+    end
+
+    it 'yields correctly with the result object' do
+      result.stdout = puppet1
+      expect( subject ).to receive( :execute ).and_yield(result)
+      subject.user_get('puppet1') do |result|
+        expect( result.stdout ).to be === puppet1
+      end
+    end
+
+  end
+
+  describe '#user_present' do
+
+    it 'returns user existence without running create command if it already exists' do
+      result.stdout = puppet1
+      expect( subject ).to receive( :execute ).once.and_yield(result)
+      subject.user_present( 'puppet1' )
+    end
+
+    it 'runs correct create command if group does not exist' do
+      result.stdout = ''
+      uid = 512
+      gid = 1007
+      name = "madeup_user"
+
+      expect( subject ).to receive( :uid_next ).and_return(uid)
+      expect( subject ).to receive( :gid_next ).and_return(gid)
+      expect( subject ).to receive( :execute ).once.ordered.and_yield(result)
+      expect( subject ).to receive( :execute ).once.ordered
+      subject.user_present( name )
+    end
+
+  end
+
+  describe '#user_absent' do
+
+    it 'calls execute to run logic' do
+      name = "main_one"
+      expect( subject ).to receive( :execute ).once.with("if dscl . -list /Users/#{name}; then dscl . -delete /Users/#{name}; fi", {})
+      subject.user_absent( name )
+    end
+
+  end
+
+  describe '#uid_next' do
+
+    it 'returns the next ID given' do
+      n = 117
+      expect( subject ).to receive( :execute ).and_return("#{n}")
+      expect( subject.uid_next ).to be === n + 1
+    end
+
+  end
+
+  describe '#gid_next' do
+
+    it 'returns the next ID given' do
+      n = 843
+      expect( subject ).to receive( :execute ).and_return("#{n}")
+      expect( subject.gid_next ).to be === n + 1
+    end
+
+  end
+end