beaker 4.41.2 → 5.0.0

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

@@ -5,89 +5,85 @@ class MacGroupTest
 end
 
 describe MacGroupTest do
-  let( :puppet1 ) do <<-EOS
-name: puppet1
-password: *
-gid: 55
+  let(:puppet1) do
+    <<~EOS
+      name: puppet1
+      password: *
+      gid: 55
 
-EOS
+    EOS
   end
-  let( :puppet2 ) do <<-EOS
-name: puppet2
-password: *
-gid: 56
+  let(:puppet2) do
+    <<~EOS
+      name: puppet2
+      password: *
+      gid: 56
 
-EOS
+    EOS
   end
-  let( :dscacheutil_list ) do <<-EOS
-#{puppet1}
-#{puppet2}
-EOS
+  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 ) }
+  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']
+      expect(subject).to receive(:execute).and_yield(result)
+      expect(subject.group_list).to be === %w[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
-      }
+      expect(subject).to receive(:execute).and_yield(result)
+      subject.group_list do |result|
+        expect(result.stdout).to be === dscacheutil_list
+      end
     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}")
+      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)
+      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'
+      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
+      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)
-      expect( subject ).not_to receive( :gid_next )
-      subject.group_present( 'puppet1' )
+      expect(subject).to receive(:execute).once.and_yield(result)
+      expect(subject).not_to receive(:gid_next)
+      subject.group_present('puppet1')
     end
 
     it 'runs correct create command if group does not exist' do
@@ -95,40 +91,35 @@ EOS
       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 )
+      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
 
     it 'makes the correct call to dscacheutil' do
       result.stdout = puppet1
-      expect( subject ).to receive( :execute ).with(
-        /^dscacheutil\ \-q\ group\ \-a\ name\ /
+      expect(subject).to receive(:execute).with(
+        /^dscacheutil\ \-q\ group\ \-a\ name\ /,
       ).once.and_yield(result)
-      expect( subject ).not_to receive( :gid_next )
-      subject.group_present( 'puppet1' )
+      expect(subject).not_to receive(:gid_next)
+      subject.group_present('puppet1')
     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 )
+      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
+      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

@@ -5,83 +5,81 @@ class MacUserTest
 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
+  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
+  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
+  let(:dscacheutil_list) do
+    <<~EOS
+      #{puppet1}
+      #{puppet2}
+    EOS
   end
-  let( :etc_passwd_line ) do
+  let(:etc_passwd_line) do
     "puppet1:*:67:234::0:0:puppet1:/Users/puppet1:/bin/sh"
   end
-  let( :command )  { 'ls' }
-  let( :host ) { double.as_null_object }
-  let( :result ) { Beaker::Result.new( host, command ) }
+  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']
+      expect(subject).to receive(:execute).and_yield(result)
+      expect(subject.user_list).to be === %w[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
-      }
+      expect(subject).to receive(:execute).and_yield(result)
+      subject.user_list do |result|
+        expect(result.stdout).to be === dscacheutil_list
+      end
     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}")
+      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 'yields correctly with the result object' do
       result.stdout = etc_passwd_line
-      expect( subject ).to receive( :execute ).and_yield(result)
+      expect(subject).to receive(:execute).and_yield(result)
       subject.user_get('puppet1') do |result|
-        expect( result.stdout ).to be === etc_passwd_line
+        expect(result.stdout).to be === etc_passwd_line
       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' )
+      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
@@ -90,42 +88,35 @@ EOS
       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 )
+      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 )
+      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
+      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
+      expect(subject).to receive(:execute).and_return("#{n}")
+      expect(subject.gid_next).to be === n + 1
     end
-
   end
 end

data/spec/beaker/host/pswindows/exec_spec.rb

@@ -17,15 +17,13 @@ module Beaker
       def to_s
         "me"
       end
-
     end
 
     let(:opts)     { @opts || {} }
-    let(:logger)   { double( 'logger' ).as_null_object }
+    let(:logger)   { double('logger').as_null_object }
     let(:instance) { PSWindowsExecTest.new(opts, logger) }
 
     context "rm" do
-
       it "deletes" do
         path = '/path/to/delete'
         corrected_path = '\\path\\to\\delete'
@@ -45,8 +43,8 @@ module Beaker
       end
 
       it 'does not rm' do
-        expect( instance ).to receive(:execute).with("move /y #{origin.tr('/', '\\')} #{destination.tr('/', '\\')}").and_return(0)
-        expect( instance.mv(origin, destination, false) ).to be === 0
+        expect(instance).to receive(:execute).with("move /y #{origin.tr('/', '\\')} #{destination.tr('/', '\\')}").and_return(0)
+        expect(instance.mv(origin, destination, false)).to be === 0
       end
     end
 
@@ -62,7 +60,7 @@ module Beaker
           file = 'C:\path\to\file'
           expect(instance).to receive(:execute).with("powershell Test-Path #{file} -PathType Leaf")
           expect(instance).to receive(:execute).with(
-            "powershell (gci C:\\path\\to\\file).LastWriteTime = Get-Date -Year '1970'-Month '1'-Day '1'-Hour '0'-Minute '0'-Second '0'"
+            "powershell (gci C:\\path\\to\\file).LastWriteTime = Get-Date -Year '1970'-Month '1'-Day '1'-Hour '0'-Minute '0'-Second '0'",
           )
           instance.modified_at(file, '197001010000')
         end
@@ -76,7 +74,7 @@ module Beaker
           expect(instance).to receive(:execute).with("powershell Test-Path #{file} -PathType Leaf")
           expect(instance).to receive(:execute).with("powershell New-Item -ItemType file #{file}")
           expect(instance).to receive(:execute).with(
-            "powershell (gci C:\\path\\to\\file).LastWriteTime = Get-Date -Year '1970'-Month '1'-Day '1'-Hour '0'-Minute '0'-Second '0'"
+            "powershell (gci C:\\path\\to\\file).LastWriteTime = Get-Date -Year '1970'-Month '1'-Day '1'-Hour '0'-Minute '0'-Second '0'",
           )
           instance.modified_at(file, '197001010000')
         end
@@ -84,27 +82,27 @@ module Beaker
     end
 
     describe '#environment_string' do
-      let(:host) { {'pathseparator' => ':'} }
+      let(:host) { { 'pathseparator' => ':' } }
 
       it 'returns a blank string if theres no env' do
-        expect( instance.environment_string( {} ) ).to be == ''
+        expect(instance.environment_string({})).to be == ''
       end
 
       it 'takes an env hash with var_name/value pairs' do
-        expect( instance.environment_string( {:HOME => '/', :http_proxy => 'http://foo'} ) ).
-          to be == 'set "HOME=/" && set "http_proxy=http://foo" && set "HTTP_PROXY=http://foo" && '
+        expect(instance.environment_string({ :HOME => '/', :http_proxy => 'http://foo' }))
+          .to be == 'set "HOME=/" && set "http_proxy=http://foo" && set "HTTP_PROXY=http://foo" && '
       end
 
       it 'takes an env hash with var_name/value[Array] pairs' do
-        expect( instance.environment_string( {:LD_PATH => ['/', '/tmp']}) ).
-          to be == "set \"LD_PATH=/:/tmp\" && "
+        expect(instance.environment_string({ :LD_PATH => ['/', '/tmp'] }))
+          .to be == "set \"LD_PATH=/:/tmp\" && "
       end
     end
 
     describe '#which' do
       before do
         allow(instance).to receive(:execute)
-                               .with(where_command, :accept_all_exit_codes => true).and_return(result)
+          .with(where_command, :accept_all_exit_codes => true).and_return(result)
       end
 
       let(:where_command) { "cmd /C \"where ruby\"" }
@@ -132,28 +130,28 @@ module Beaker
     end
 
     describe '#mkdir_p' do
-        let(:dir_path) { "C:\\tmpdir\\my_dir" }
-        let(:beaker_command) { instance_spy(Beaker::Command) }
-        let(:command) {"-Command New-Item -Path '#{dir_path}' -ItemType 'directory'"}
-        let(:result) { instance_spy(Beaker::Result) }
-
-        before do
-          allow(Beaker::Command).to receive(:new).
-              with('powershell.exe', array_including(command)).and_return(beaker_command)
-          allow(instance).to receive(:exec).with(beaker_command, :acceptable_exit_codes => [0, 1]).and_return(result)
-        end
+      let(:dir_path) { "C:\\tmpdir\\my_dir" }
+      let(:beaker_command) { instance_spy(Beaker::Command) }
+      let(:command) { "-Command New-Item -Path '#{dir_path}' -ItemType 'directory'" }
+      let(:result) { instance_spy(Beaker::Result) }
 
-        it 'returns true and creates folder structure' do
-          allow(result).to receive(:exit_code).and_return(0)
+      before do
+        allow(Beaker::Command).to receive(:new)
+          .with('powershell.exe', array_including(command)).and_return(beaker_command)
+        allow(instance).to receive(:exec).with(beaker_command, :acceptable_exit_codes => [0, 1]).and_return(result)
+      end
 
-          expect(instance.mkdir_p(dir_path)).to be(true)
-        end
+      it 'returns true and creates folder structure' do
+        allow(result).to receive(:exit_code).and_return(0)
 
-        it 'returns false if failed to create directory structure' do
-          allow(result).to receive(:exit_code).and_return(1)
+        expect(instance.mkdir_p(dir_path)).to be(true)
+      end
 
-          expect(instance.mkdir_p(dir_path)).to be(false)
-        end
+      it 'returns false if failed to create directory structure' do
+        allow(result).to receive(:exit_code).and_return(1)
+
+        expect(instance.mkdir_p(dir_path)).to be(false)
       end
+    end
   end
 end

data/spec/beaker/host/pswindows/file_spec.rb

@@ -21,7 +21,7 @@ module Beaker
     end
 
     let(:opts)     { @opts || {} }
-    let(:logger)   { double( 'logger' ).as_null_object }
+    let(:logger)   { double('logger').as_null_object }
     let(:instance) { PSWindowsFileTest.new(opts, logger) }
 
     describe '#cat' do
@@ -67,14 +67,14 @@ module Beaker
         let(:name) { 'my_dir' }
 
         it 'returns the path to my_dir' do
-          expect(Beaker::Command).to receive(:new).
-            with('powershell.exe', array_including('-Command [System.IO.Path]::GetTempPath()')).
-            and_return(fake_command)
+          expect(Beaker::Command).to receive(:new)
+            .with('powershell.exe', array_including('-Command [System.IO.Path]::GetTempPath()'))
+            .and_return(fake_command)
           expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(double(stdout: tmp_path))
 
-          expect(Beaker::Command).to receive(:new).
-            with('powershell.exe', array_including("-Command New-Item -Path '#{tmp_path}' -Force -Name '#{name}' -ItemType 'directory'")).
-            and_return(fake_command)
+          expect(Beaker::Command).to receive(:new)
+            .with('powershell.exe', array_including("-Command New-Item -Path '#{tmp_path}' -Force -Name '#{name}' -ItemType 'directory'"))
+            .and_return(fake_command)
           expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(true)
 
           expect(instance.tmpdir(name)).to eq(File.join(tmp_path, name))
@@ -86,19 +86,19 @@ module Beaker
         let(:random_dir) { 'dirname' }
 
         it 'returns the path to random name dir' do
-          expect(Beaker::Command).to receive(:new).
-            with('powershell.exe', array_including('-Command [System.IO.Path]::GetTempPath()')).
-            and_return(fake_command)
+          expect(Beaker::Command).to receive(:new)
+            .with('powershell.exe', array_including('-Command [System.IO.Path]::GetTempPath()'))
+            .and_return(fake_command)
           expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(double(stdout: tmp_path))
 
-          expect(Beaker::Command).to receive(:new).
-            with('powershell.exe', array_including('-Command [System.IO.Path]::GetRandomFileName()')).
-            and_return(fake_command)
+          expect(Beaker::Command).to receive(:new)
+            .with('powershell.exe', array_including('-Command [System.IO.Path]::GetRandomFileName()'))
+            .and_return(fake_command)
           expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(double(stdout: random_dir))
 
-          expect(Beaker::Command).to receive(:new).
-            with('powershell.exe', array_including("-Command New-Item -Path '#{tmp_path}' -Force -Name '#{random_dir}' -ItemType 'directory'")).
-            and_return(fake_command)
+          expect(Beaker::Command).to receive(:new)
+            .with('powershell.exe', array_including("-Command New-Item -Path '#{tmp_path}' -Force -Name '#{random_dir}' -ItemType 'directory'"))
+            .and_return(fake_command)
           expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(true)
 
           expect(instance.tmpdir).to eq(File.join(tmp_path, random_dir))

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

@@ -5,66 +5,60 @@ class PSWindowsUserTest
 end
 
 describe PSWindowsUserTest do
-  let( :wmic_output ) do <<-EOS
+  let(:wmic_output) do
+    <<~EOS
+      Name=Administrator
 
 
 
 
-Name=Administrator
 
+      Name=bob foo
 
 
 
 
-Name=bob foo
 
+      Name=bob-dash
 
 
 
 
-Name=bob-dash
 
+      Name=bob.foo
 
 
 
 
-Name=bob.foo
 
+      Name=cyg_server
 
 
 
 
-Name=cyg_server
 
 
 
 
-
-
-
-
-EOS
+    EOS
   end
-  let( :command )  { 'cmd /c echo "" | wmic useraccount where localaccount="true" get name /format:value' }
-  let( :host ) { double.as_null_object }
-  let( :result ) { Beaker::Result.new( host, command ) }
+  let(:command) { 'cmd /c echo "" | wmic useraccount where localaccount="true" get name /format:value' }
+  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 = wmic_output
-      expect( subject ).to receive( :execute ).with( command ).and_yield(result)
-      expect( subject.user_list ).to be === ['Administrator', 'bob foo', 'bob-dash', 'bob.foo', 'cyg_server']
+      expect(subject).to receive(:execute).with(command).and_yield(result)
+      expect(subject.user_list).to be === ['Administrator', 'bob foo', 'bob-dash', 'bob.foo', 'cyg_server']
     end
 
     it 'yields correctly with the result object' do
       result.stdout = wmic_output
-      expect( subject ).to receive( :execute ).and_yield(result)
-      subject.user_list { |result|
-        expect( result.stdout ).to be === wmic_output
-      }
+      expect(subject).to receive(:execute).and_yield(result)
+      subject.user_list do |result|
+        expect(result.stdout).to be === wmic_output
+      end
     end
-
   end
-
 end