chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/functional/resource/env_spec.rb

@@ -131,12 +131,12 @@ describe Chef::Resource::Env, :windows_only do
         let!(:env_path_before) { ENV['PATH'] }
 
         it 'should expand PATH' do
-          path_before.should_not include(env_val)
+          expect(path_before).not_to include(env_val)
           test_resource.key_name('PATH')
           test_resource.value("#{path_before};#{env_val}")
           test_resource.run_action(:create)
-          ENV['PATH'].should_not include(env_val)
-          ENV['PATH'].should include("#{random_name}")
+          expect(ENV['PATH']).not_to include(env_val)
+          expect(ENV['PATH']).to include("#{random_name}")
         end
 
         after(:each) do

data/spec/functional/resource/execute_spec.rb

@@ -18,96 +18,130 @@
 
 require 'spec_helper'
 require 'functional/resource/base'
+require 'timeout'
 
 describe Chef::Resource::Execute do
-  let(:execute_resource) {
-    exec_resource = Chef::Resource::Execute.new("foo_resource", run_context)
-
-    exec_resource.environment(resource_environment) if resource_environment
-    exec_resource.cwd(resource_cwd) if resource_cwd
-    exec_resource.command("echo hello")
-    if guard
-      if guard_options
-        exec_resource.only_if(guard, guard_options)
-      else
-        exec_resource.only_if(guard)
-      end
-    end
-    exec_resource
+  let(:resource) {
+    resource = Chef::Resource::Execute.new("foo_resource", run_context)
+    resource.command("echo hello")
+    resource
   }
 
-  let(:resource_environment) { nil }
-  let(:resource_cwd) { nil }
-  let(:guard) { nil }
-  let(:guard_options) { nil }
-
   describe "when guard is ruby block" do
     it "guard can still run" do
-      execute_resource.only_if do
-        true
-      end
-      execute_resource.run_action(:run)
-      execute_resource.should be_updated_by_last_action
+      resource.only_if { true }
+      resource.run_action(:run)
+      expect(resource).to be_updated_by_last_action
     end
   end
 
-  describe "when parent resource sets :cwd" do
-    let(:resource_cwd) { CHEF_SPEC_DATA }
+  describe "when why_run is enabled" do
+    before do
+      Chef::Config[:why_run] = true
+    end
+
+    let(:guard) { "ruby -e 'exit 0'" }
+    let!(:guard_resource) {
+      interpreter = Chef::GuardInterpreter::ResourceGuardInterpreter.new(resource, guard, nil)
+      interpreter.send(:get_interpreter_resource, resource)
+    }
+
+    it "executes the guard and not the regular resource" do
+      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:get_interpreter_resource).and_return(guard_resource)
+
+      # why_run mode doesn't disable the updated_by_last_action logic, so we really have to look at the provider action
+      # to see if why_run correctly disabled the resource.  It should shell_out! for the guard but not the resource.
+      expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out!).once
 
+      resource.only_if guard
+      resource.run_action(:run)
+
+      expect(resource).to be_updated_by_last_action
+      expect(guard_resource).to be_updated_by_last_action
+    end
+  end
+
+  describe "when parent resource sets :cwd" do
     let(:guard) { %{ruby -e 'exit 1 unless File.exists?("./big_json_plus_one.json")'} }
 
-    it "guard inherits :cwd from resource" do
-      execute_resource.run_action(:run)
-      execute_resource.should be_updated_by_last_action
+    it "guard inherits :cwd from resource and runs" do
+      resource.cwd CHEF_SPEC_DATA
+      resource.only_if guard
+      resource.run_action(:run)
+      expect(resource).to be_updated_by_last_action
+    end
+
+    it "guard inherits :cwd from resource and does not run" do
+      resource.cwd CHEF_SPEC_DATA
+      resource.not_if guard
+      resource.run_action(:run)
+      expect(resource).not_to be_updated_by_last_action
     end
   end
 
+  # We use ruby command so that we don't need to deal with platform specific
+  # commands while testing execute resource. We set it so that the resource
+  # will be updated if the ENV variable is set to what we are intending
+  #
+  # FIXME: yeah, but invoking ruby is slow...
   describe "when parent resource sets :environment" do
-    let(:resource_environment) do
-      {
+    before do
+      resource.environment({
         "SAWS_SECRET"  => "supersecret",
-        "SAWS_KEY"     => "qwerty"
-      }
+        "SAWS_KEY"     => "qwerty",
+      })
     end
 
-    # We use ruby command so that we don't need to deal with platform specific
-    # commands while testing execute resource. We set it so that the resource
-    # will be updated if the ENV variable is set to what we are intending
-    let(:guard) { %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] != "supersecret"'} }
-
-    it "guard inherits :environment value from resource" do
-      execute_resource.run_action(:run)
-      execute_resource.should be_updated_by_last_action
+    it "guard inherits :environment value from resource and runs" do
+      resource.only_if %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] != "supersecret"'}
+      resource.run_action(:run)
+      expect(resource).to be_updated_by_last_action
     end
 
-    describe "when guard sets additional values in the :environment" do
-      let(:guard) { %{ruby -e 'exit 1 if ENV["SGCE_SECRET"] != "regularsecret"'} }
+    it "guard inherits :environment value from resource and does not run" do
+      resource.only_if %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] == "supersecret"'}
+      resource.run_action(:run)
+      expect(resource).not_to be_updated_by_last_action
+    end
 
-      let(:guard_options) do
-        {
-          :environment => { 'SGCE_SECRET' => "regularsecret" }
-        }
-      end
+    it "guard adds additional values in its :environment and runs" do
+      resource.only_if %{ruby -e 'exit 1 if ENV["SGCE_SECRET"] != "regularsecret"'}, {
+        :environment => { 'SGCE_SECRET' => "regularsecret" }
+      }
+      resource.run_action(:run)
+      expect(resource).to be_updated_by_last_action
+    end
 
-      it "guard sees merged value for in its ENV" do
-        execute_resource.run_action(:run)
-        execute_resource.should be_updated_by_last_action
-      end
+    it "guard adds additional values in its :environment and does not run" do
+      resource.only_if %{ruby -e 'exit 1 if ENV["SGCE_SECRET"] == "regularsecret"'}, {
+        :environment => { 'SGCE_SECRET' => "regularsecret" }
+      }
+      resource.run_action(:run)
+      expect(resource).not_to be_updated_by_last_action
     end
 
-    describe "when guard sets same value in the :environment" do
-      let(:guard) { %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] != "regularsecret"'} }
+    it "guard overwrites value with its :environment and runs" do
+      resource.only_if %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] != "regularsecret"'}, {
+        :environment => { 'SAWS_SECRET' => "regularsecret" }
+      }
+      resource.run_action(:run)
+      expect(resource).to be_updated_by_last_action
+    end
 
-      let(:guard_options) do
-        {
-          :environment => { 'SAWS_SECRET' => "regularsecret" }
-        }
-      end
+    it "guard overwrites value with its :environment and does not runs" do
+      resource.only_if %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] == "regularsecret"'}, {
+        :environment => { 'SAWS_SECRET' => "regularsecret" }
+      }
+      resource.run_action(:run)
+      expect(resource).not_to be_updated_by_last_action
+    end
+  end
 
-      it "guard sees value from guard options in its ENV" do
-        execute_resource.run_action(:run)
-        execute_resource.should be_updated_by_last_action
-      end
+  it "times out when a timeout is set on the resource" do
+    Timeout::timeout(5) do
+      resource.command %{ruby -e 'sleep 600'}
+      resource.timeout 0.1
+      expect { resource.run_action(:run) }.to raise_error(Mixlib::ShellOut::CommandTimeout)
     end
   end
 end

data/spec/functional/resource/file_spec.rb

@@ -77,11 +77,11 @@ describe Chef::Resource::File do
 
     context "and the target file does not exist" do
       it "creates the file" do
-        File.should exist(path)
+        expect(File).to exist(path)
       end
 
       it "is marked updated by last action" do
-        resource_without_content.should be_updated_by_last_action
+        expect(resource_without_content).to be_updated_by_last_action
       end
     end
   end
@@ -106,11 +106,11 @@ describe Chef::Resource::File do
       end
 
       it "it creates the file" do
-        File.should exist(path)
+        expect(File).to exist(path)
       end
 
       it "is marked updated by last action" do
-        resource.should be_updated_by_last_action
+        expect(resource).to be_updated_by_last_action
       end
     end
 
@@ -128,15 +128,15 @@ describe Chef::Resource::File do
       end
 
       it "updates the mtime of the file" do
-        File.stat(path).mtime.should > @expected_mtime
+        expect(File.stat(path).mtime).to be > @expected_mtime
       end
 
       it "does not change the content" do
-        sha256_checksum(path).should == @expected_checksum
+        expect(sha256_checksum(path)).to eq(@expected_checksum)
       end
 
       it "is marked as updated by last action" do
-        resource.should be_updated_by_last_action
+        expect(resource).to be_updated_by_last_action
       end
     end
   end

data/spec/functional/resource/git_spec.rb

@@ -92,7 +92,7 @@ E
 
   before(:all) do
     @ohai = Ohai::System.new
-    @ohai.all_plugins("os")
+    @ohai.all_plugins(["platform", "os"])
   end
 
   context "working with pathes with special characters" do
@@ -130,10 +130,10 @@ E
     it "checks out the revision pointed to by the tag commit, not the tag commit itself" do
       basic_git_resource.run_action(:sync)
       head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
-      head_rev.should == v1_commit
+      expect(head_rev).to eq(v1_commit)
       # also verify the tag commit itself is what we expect as an extra sanity check
       rev = shell_out!('git rev-parse v1.0.0', :cwd => deploy_directory, :returns => [0]).stdout.strip
-      rev.should == v1_tag
+      expect(rev).to eq(v1_tag)
     end
 
     it "doesn't update if up-to-date" do
@@ -141,10 +141,10 @@ E
       # properly to the pointed to commit.
       basic_git_resource.run_action(:sync)
       head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
-      head_rev.should == v1_commit
+      expect(head_rev).to eq(v1_commit)
 
       copy_git_resource.run_action(:sync)
-      copy_git_resource.should_not be_updated
+      expect(copy_git_resource).not_to be_updated
     end
   end
 
@@ -167,25 +167,25 @@ E
       basic_git_resource.revision rev_foo
       basic_git_resource.run_action(:sync)
       head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
-      head_rev.should == rev_foo
+      expect(head_rev).to eq(rev_foo)
     end
 
     it "doesn't update if up-to-date" do
       basic_git_resource.revision rev_foo
       basic_git_resource.run_action(:sync)
       head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
-      head_rev.should == rev_foo
+      expect(head_rev).to eq(rev_foo)
 
       copy_git_resource.revision rev_foo
       copy_git_resource.run_action(:sync)
-      copy_git_resource.should_not be_updated
+      expect(copy_git_resource).not_to be_updated
     end
 
     it "checks out the expected revision 972d" do
       basic_git_resource.revision rev_testing
       basic_git_resource.run_action(:sync)
       head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
-      head_rev.should == rev_testing
+      expect(head_rev).to eq(rev_testing)
     end
   end
 
@@ -200,7 +200,7 @@ E
     it "checks out the expected revision" do
       basic_git_resource.run_action(:sync)
       head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
-      head_rev.should == rev_head
+      expect(head_rev).to eq(rev_head)
     end
   end
 
@@ -215,7 +215,7 @@ E
     it "checks out HEAD as the default revision" do
       basic_git_resource.run_action(:sync)
       head_rev = shell_out!('git rev-parse HEAD', :cwd => deploy_directory, :returns => [0]).stdout.strip
-      head_rev.should == rev_head
+      expect(head_rev).to eq(rev_head)
     end
   end
 
@@ -244,7 +244,7 @@ E
       head_rev = shell_out!('git rev-parse HEAD',
                             :cwd => deploy_directory,
                             :returns => [0]).stdout.strip
-      head_rev.should == rev_head
+      expect(head_rev).to eq(rev_head)
     end
 
     it "checks out the (master) HEAD revision when no revision is specified (ignores tag)" do
@@ -252,7 +252,7 @@ E
       head_rev = shell_out!('git rev-parse HEAD',
                             :cwd => deploy_directory,
                             :returns => [0]).stdout.strip
-      head_rev.should == rev_head
+      expect(head_rev).to eq(rev_head)
     end
 
   end

data/spec/functional/resource/group_spec.rb

@@ -19,12 +19,15 @@
 
 require 'spec_helper'
 require 'functional/resource/base'
+require 'chef/mixin/shell_out'
 
 # Chef::Resource::Group are turned off on Mac OS X 10.6 due to caching
 # issues around Etc.getgrnam() not picking up the group membership
 # changes that are done on the system. Etc.endgrent is not functioning
 # correctly on certain 10.6 boxes.
 describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supported_on_mac_osx_106 do
+  include Chef::Mixin::ShellOut
+
   def group_should_exist(group)
     case ohai[:platform_family]
     when "debian", "fedora", "rhel", "suse", "gentoo", "slackware", "arch"
@@ -108,7 +111,7 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
       temp_resource.append(true)
       temp_resource.run_action(:modify)
       members.each do |member|
-        user_exist_in_group?(member).should == true
+        expect(user_exist_in_group?(member)).to eq(true)
       end
     end
 
@@ -119,7 +122,7 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
       temp_resource.run_action(:create)
       group_should_exist(group_name)
       included_members.each do |member|
-        user_exist_in_group?(member).should == false
+        expect(user_exist_in_group?(member)).to eq(false)
       end
     end
 
@@ -149,8 +152,8 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
       it "should remove the existing users and add the new users to the group" do
         group_resource.run_action(tested_action)
 
-        user_exist_in_group?(spec_members[1]).should == true
-        user_exist_in_group?(spec_members[0]).should == false
+        expect(user_exist_in_group?(spec_members[1])).to eq(true)
+        expect(user_exist_in_group?(spec_members[0])).to eq(false)
       end
     end
 
@@ -176,10 +179,10 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
           group_resource.run_action(tested_action)
 
           included_members.each do |member|
-            user_exist_in_group?(member).should == true
+            expect(user_exist_in_group?(member)).to eq(true)
           end
           excluded_members.each do |member|
-            user_exist_in_group?(member).should == false
+            expect(user_exist_in_group?(member)).to eq(false)
           end
         end
 
@@ -192,10 +195,10 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
             group_resource.run_action(tested_action)
 
             included_members.each do |member|
-              user_exist_in_group?(member).should == true
+              expect(user_exist_in_group?(member)).to eq(true)
             end
             excluded_members.each do |member|
-              user_exist_in_group?(member).should == false
+              expect(user_exist_in_group?(member)).to eq(false)
             end
           end
         end
@@ -204,13 +207,13 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
       describe "when the users doesn't exist" do
         describe "when append is not set" do
           it "should raise an error" do
-            lambda { @grp_resource.run_action(tested_action) }.should raise_error
+            expect { @grp_resource.run_action(tested_action) }.to raise_error
           end
         end
 
         describe "when append is set" do
           it "should raise an error" do
-            lambda { @grp_resource.run_action(tested_action) }.should raise_error
+            expect { @grp_resource.run_action(tested_action) }.to raise_error
           end
         end
       end
@@ -231,24 +234,24 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
     describe "when updating membership" do
       it "raises an error for a non well-formed domain name" do
         group_resource.members [invalid_domain_user_name]
-        lambda { group_resource.run_action(tested_action) }.should raise_error Chef::Exceptions::Win32APIError
+        expect { group_resource.run_action(tested_action) }.to raise_error Chef::Exceptions::Win32APIError
       end
 
       it "raises an error for a nonexistent domain" do
         group_resource.members [nonexistent_domain_user_name]
-        lambda { group_resource.run_action(tested_action) }.should raise_error Chef::Exceptions::Win32APIError
+        expect { group_resource.run_action(tested_action) }.to raise_error Chef::Exceptions::Win32APIError
       end
     end
 
     describe "when removing members" do
       it "raises an error for a non well-formed domain name" do
         group_resource.excluded_members [invalid_domain_user_name]
-        lambda { group_resource.run_action(tested_action) }.should raise_error Chef::Exceptions::Win32APIError
+        expect { group_resource.run_action(tested_action) }.to raise_error Chef::Exceptions::Win32APIError
       end
 
       it "raises an error for a nonexistent domain" do
         group_resource.excluded_members [nonexistent_domain_user_name]
-        lambda { group_resource.run_action(tested_action) }.should raise_error Chef::Exceptions::Win32APIError
+        expect { group_resource.run_action(tested_action) }.to raise_error Chef::Exceptions::Win32APIError
       end
     end
   end
@@ -264,7 +267,7 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
   }
 
   it "append should be false by default" do
-    group_resource.append.should == false
+    expect(group_resource.append).to eq(false)
   end
 
   describe "group create action" do
@@ -297,7 +300,7 @@ theoldmanwalkingdownthestreetalwayshadagoodsmileonhisfacetheoldmanwalking\
 downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
 
       it "should not create a group" do
-        lambda { group_resource.run_action(:create) }.should raise_error
+        expect { group_resource.run_action(:create) }.to raise_error
         group_should_not_exist(group_name)
       end
     end
@@ -308,7 +311,7 @@ downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
         invalid_resource = group_resource.dup
         invalid_resource.members(["Jack"])
         invalid_resource.excluded_members(["Jack"])
-        lambda { invalid_resource.run_action(:create)}.should raise_error(Chef::Exceptions::ConflictingMembersInGroup)
+        expect { invalid_resource.run_action(:create)}.to raise_error(Chef::Exceptions::ConflictingMembersInGroup)
       end
     end
   end
@@ -342,7 +345,7 @@ downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
 
     describe "when there is no group" do
       it "should raise an error" do
-        lambda { group_resource.run_action(:modify) }.should raise_error
+        expect { group_resource.run_action(:modify) }.to raise_error
       end
     end
 
@@ -370,11 +373,11 @@ downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
 
     describe "when there is no group" do
       it "raises an error on modify" do
-        lambda { group_resource.run_action(:modify) }.should raise_error
+        expect { group_resource.run_action(:modify) }.to raise_error
       end
 
       it "does not raise an error on manage" do
-        lambda { group_resource.run_action(:manage) }.should_not raise_error
+        expect { group_resource.run_action(:manage) }.not_to raise_error
       end
     end
 
@@ -399,15 +402,15 @@ downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
       let(:excluded_members) { ["Anthony"] }
 
       it ":manage should raise an error" do
-        lambda {group_resource.run_action(:manage) }.should raise_error
+        expect {group_resource.run_action(:manage) }.to raise_error
       end
 
       it ":modify should raise an error" do
-        lambda {group_resource.run_action(:modify) }.should raise_error
+        expect {group_resource.run_action(:modify) }.to raise_error
       end
 
       it ":create should raise an error" do
-        lambda {group_resource.run_action(:create) }.should raise_error
+        expect {group_resource.run_action(:create) }.to raise_error
       end
     end
 
@@ -419,11 +422,11 @@ downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
       end
 
       it ":manage should raise an error" do
-        lambda {group_resource.run_action(:manage) }.should raise_error
+        expect {group_resource.run_action(:manage) }.to raise_error
       end
 
       it ":modify should raise an error" do
-        lambda {group_resource.run_action(:modify) }.should raise_error
+        expect {group_resource.run_action(:modify) }.to raise_error
       end
     end
   end