chef 13.6.4 → 13.7.16

data/spec/unit/provider/service/solaris_smf_service_spec.rb

@@ -118,6 +118,7 @@ describe Chef::Provider::Service::Solaris do
       it "should create a current resource with the name of the new resource" do
         expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
         expect(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
+        expect(@provider.maintenance).to be_falsey
         @provider.load_current_resource
       end
 
@@ -162,7 +163,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm enable -s chef" do
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", @current_resource.service_name).and_return(@success)
         @provider.load_current_resource
@@ -172,7 +173,7 @@ describe Chef::Provider::Service::Solaris do
       end
 
       it "should call svcadm enable -s chef for start_service" do
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", @current_resource.service_name).and_return(@success)
         @provider.load_current_resource
@@ -182,7 +183,7 @@ describe Chef::Provider::Service::Solaris do
 
       it "should call svcadm clear chef for start_service when state maintenance" do
         # we are in maint mode
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@maintenance_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@maintenance_svc_status)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name).and_return(@success)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", @current_resource.service_name).and_return(@success)
 
@@ -205,7 +206,7 @@ describe Chef::Provider::Service::Solaris do
 
       it "should call svcadm enable -s -r chef" do
         @new_resource.options("-r")
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", "-r", @current_resource.service_name).and_return(@success)
         @provider.load_current_resource
@@ -215,7 +216,7 @@ describe Chef::Provider::Service::Solaris do
 
       it "should call svcadm enable -s -r -t chef when passed an array of options" do
         @new_resource.options(["-r", "-t"])
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
+        expect(@provider).to receive(:shell_out!).twice.with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@enabled_svc_status)
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", "-r", "-t", @current_resource.service_name).and_return(@success)
         @provider.load_current_resource

data/spec/unit/provider/user/dscl_spec.rb

@@ -213,6 +213,32 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
     end
   end
 
+  describe "current_home_exists?" do
+    let(:current_resource) do
+      new_resource.dup
+    end
+
+    before do
+      provider.current_resource = current_resource
+    end
+
+    it "returns false for nil home dir" do
+      current_resource.home nil
+      expect(provider.current_home_exists?).to be_falsey
+    end
+
+    it "is false for empty string" do
+      current_resource.home ""
+      expect(provider.current_home_exists?).to be_falsey
+    end
+
+    it "is true for existing directory" do
+      current_resource.home "/Users/blah"
+      allow(::File).to receive(:exist?).with("/Users/blah").and_return(true)
+      expect(provider.current_home_exists?).to be_truthy
+    end
+  end
+
   describe "when modifying the home directory" do
     let(:current_resource) do
       new_resource.dup

data/spec/unit/provider/windows_task_spec.rb

@@ -40,7 +40,7 @@ describe Chef::Provider::WindowsTask do
       :LastRunTime => "3/30/2017 2:27:00 PM",
       :LastResult => "1",
       :Author => "Administrator",
-      :TaskToRun => "chef-client",
+      :TaskToRun => "chef-client -L C:\\tmp\\",
       :StartIn => "N/A",
       :Comment => "N/A",
       :ScheduledTaskState => "Enabled",
@@ -91,7 +91,7 @@ describe Chef::Provider::WindowsTask do
       allow(provider).to receive(:load_task_hash).and_return(task_hash)
       current_resource = provider.load_current_resource
       expect(current_resource.exists).to be(true)
-      expect(current_resource.command).to eq("chef-client")
+      expect(current_resource.command).to eq("chef-client -L C:\\tmp\\")
       expect(current_resource.user).to eq("SYSTEM")
       expect(current_resource.run_level).to eq(:highest)
       expect(current_resource.frequency).to eq(:minute)
@@ -110,6 +110,49 @@ describe Chef::Provider::WindowsTask do
       expect(new_resource).not_to be_updated_by_last_action
     end
 
+    it "sets the start_time in 24hr format while updating an existing task" do
+      # task_hash has start_time = "1:12:00 PM"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      allow(provider).to receive(:task_need_update?).and_return(true)
+      allow(provider).to receive(:convert_system_date_to_mm_dd_yyyy).and_return("03/30/2017")
+      allow(provider).to receive(:run_schtasks)
+      provider.run_action(:create)
+      # start_time gets set in 24hr format for new_resource
+      expect(new_resource.start_time).to eq("13:12")
+      expect(new_resource).to be_updated_by_last_action
+    end
+
+    it "sets the start_day in mm/dd/yyyy format while updating an existing task" do
+      # start_day in yyyy-MM-dd format
+      task_hash[:StartDate] = "2017-03-30"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      current_resource = provider.load_current_resource
+      allow(provider).to receive(:task_need_update?).and_return(true)
+      allow(provider).to receive(:convert_system_date_format_to_ruby_date_format).and_return("%Y-%m-%d")
+      allow(provider).to receive(:run_schtasks)
+      provider.run_action(:create)
+      # start_day gets set in mm/dd/yyyy format for new_resource
+      expect(new_resource.start_day).to eq("03/30/2017")
+      expect(new_resource).to be_updated_by_last_action
+    end
+
+    context "when start_day and start_time are N/A for frequency :on_logon" do
+      it "doesn't update the start_day and start_time of new_resource" do
+        task_hash[:on_logon] = true
+        task_hash[:StartDate] = "N/A"
+        task_hash[:StartTime] = "N/A"
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        current_resource = provider.load_current_resource
+        allow(provider).to receive(:task_need_update?).and_return(true)
+        allow(provider).to receive(:run_schtasks)
+        expect(provider).not_to receive(:convert_system_date_to_mm_dd_yyyy)
+        expect(DateTime).not_to receive(:parse)
+        expect(new_resource.start_day).to eq(nil)
+        expect(new_resource.start_time).to eq(nil)
+      end
+    end
+
     context "when task is not existing" do
       before do
         allow(provider).to receive(:load_task_hash)
@@ -285,7 +328,7 @@ describe Chef::Provider::WindowsTask do
     before do
       @task_action = "CREATE"
       @options = { "F" => "", "SC" => :minute, "MO" => 15, "TR" => "chef-client", "RU" => "SYSTEM", "RL" => "HIGHEST" }
-      @cmd = "schtasks /CREATE /TN \"sample_task\" /F /SC \"minute\" /MO \"15\" /TR \"chef-client\" /RU \"SYSTEM\" /RL \"HIGHEST\" "
+      @cmd = "schtasks /CREATE /TN \"sample_task\" /F /SC \"minute\" /MO \"15\" /RU \"SYSTEM\" /RL \"HIGHEST\" /TR \"chef-client \" "
     end
 
     it "forms the command properly from the given options" do
@@ -336,7 +379,7 @@ describe Chef::Provider::WindowsTask do
         allow(provider).to receive(:get_system_short_date_format).and_return("MM/dd/yyyy")
         provider.load_current_resource
 
-        new_resource.command "chef-client"
+        new_resource.command "chef-client -L C:\\tmp\\"
         new_resource.run_level :highest
         new_resource.frequency :minute
         new_resource.frequency_modifier 15
@@ -379,6 +422,13 @@ describe Chef::Provider::WindowsTask do
           expect(provider.send(:task_need_update?)).to be(true)
         end
       end
+
+      context "when command updated" do
+        it "return true" do
+          new_resource.command "chef-client"
+          expect(provider.send(:task_need_update?)).to be(true)
+        end
+      end
     end
   end
 
@@ -570,4 +620,98 @@ describe Chef::Provider::WindowsTask do
       expect(provider.send(:frequency_modifier_allowed)).to be(false)
     end
   end
+
+  # In windows_task resource sec_to_dur method converts seconds to duration in format 60 == 'PT60S'
+  # random_delay_updated? method use the value return by sec_to_dur as input for comparison for new_resource.random_delay mocking the same here
+  describe "#random_delay_updated?" do
+    before do
+      new_resource.command "chef-client"
+      new_resource.run_level :highest
+      new_resource.frequency :minute
+      new_resource.frequency_modifier 15
+      new_resource.user "SYSTEM"
+    end
+
+    it "returns false if current_resource.random_delay = nil & random_delay is set to '0' seconds" do
+      task_hash[:random_delay] = nil
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.random_delay = "PT0S"
+      expect(provider.send(:random_delay_updated?)).to be(false)
+    end
+
+    it "returns false if current_resource.random_delay = 'P7D' & random_delay is set to '604800' seconds " do
+      task_hash[:random_delay] = "P7D"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.random_delay = "PT604800S"
+      expect(provider.send(:random_delay_updated?)).to be(false)
+    end
+
+    it "returns false if current_resource.random_delay = 'P7DT1S' & random_delay is set to '604801' seconds" do
+      task_hash[:random_delay] = "P7DT1S"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.random_delay = "PT604801S"
+      expect(provider.send(:random_delay_updated?)).to be(false)
+    end
+
+    it "returns true if current_resource.random_delay = 'PT1S' & random_delay is set to '3600' seconds" do
+      task_hash[:random_delay] = "PT1S"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.random_delay = "PT3600S"
+      expect(provider.send(:random_delay_updated?)).to be(true)
+    end
+
+    it "returns false if current_resource.random_delay = 'P2Y1MT2H' & random_delay is set to '65707200' seconds" do
+      task_hash[:random_delay] = "P2Y1MT2H"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.random_delay = "PT65707200S"
+      expect(provider.send(:random_delay_updated?)).to be(false)
+    end
+  end
+
+  describe "#execution_time_limit_updated?" do
+    before do
+      new_resource.command "chef-client"
+      new_resource.run_level :highest
+      new_resource.frequency :minute
+      new_resource.frequency_modifier 15
+      new_resource.user "SYSTEM"
+    end
+
+    it "returns false if current_resource.execution_time_limit = 'P7D' & execution_time_limit is set to 604800 seconds " do
+      task_hash[:execution_time_limit] = "P7D"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.execution_time_limit = "PT604800S"
+      expect(provider.send(:execution_time_limit_updated?)).to be(false)
+    end
+
+    it "returns false if current_resource.execution_time_limit = 'P7DT1S' & execution_time_limit is set to 604801 seconds" do
+      task_hash[:execution_time_limit] = "P7DT1S"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.execution_time_limit = "PT604801S"
+      expect(provider.send(:execution_time_limit_updated?)).to be(false)
+    end
+
+    it "returns true if current_resource.execution_time_limit = 'PT1S' & execution_time_limit is set to '3600' seconds" do
+      task_hash[:execution_time_limit] = "PT1S"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.execution_time_limit = "PT3600S"
+      expect(provider.send(:execution_time_limit_updated?)).to be(true)
+    end
+
+    it "returns false if current_resource.execution_time_limit = 'P2Y1MT2H' & execution_time_limit is set to '65707200' seconds" do
+      task_hash[:execution_time_limit] = "P2Y1MT2H"
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      new_resource.execution_time_limit = "PT65707200S"
+      expect(provider.send(:execution_time_limit_updated?)).to be(false)
+    end
+  end
 end

data/spec/unit/provider_spec.rb

@@ -197,7 +197,7 @@ describe Chef::Provider do
 
   context "when using use_inline_resources" do
     it "should log a deprecation warning" do
-      pending Chef::VERSION.start_with?("13.6")
+      pending Chef::VERSION.start_with?("14.1")
       expect(Chef).to receive(:deprecated).with(:use_inline_resources, kind_of(String))
       Class.new(described_class) { use_inline_resources }
     end

data/spec/unit/resource/apt_package_spec.rb

@@ -31,7 +31,7 @@ describe Chef::Resource::AptPackage, "initialize" do
 
   let(:resource) { Chef::Resource::AptPackage.new("foo") }
 
-  it "should support default_release" do
+  it "supports default_release" do
     resource.default_release("lenny-backports")
     expect(resource.default_release).to eql("lenny-backports")
   end

data/spec/unit/resource/bash_spec.rb

@@ -20,21 +20,19 @@ require "spec_helper"
 
 describe Chef::Resource::Bash do
 
-  before(:each) do
-    @resource = Chef::Resource::Bash.new("fakey_fakerton")
-  end
+  let(:resource) { Chef::Resource::Bash.new("fakey_fakerton") }
 
-  it "should create a new Chef::Resource::Bash" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Bash)
+  it "creates a new Chef::Resource::Bash" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Bash)
   end
 
-  it "should have a resource name of :bash" do
-    expect(@resource.resource_name).to eql(:bash)
+  it "has a resource name of :bash" do
+    expect(resource.resource_name).to eql(:bash)
   end
 
-  it "should have an interpreter of bash" do
-    expect(@resource.interpreter).to eql("bash")
+  it "has an interpreter of bash" do
+    expect(resource.interpreter).to eql("bash")
   end
 
 end

data/spec/unit/resource/batch_spec.rb

@@ -33,7 +33,7 @@ describe Chef::Resource::Batch do
 
   end
 
-  it "should create a new Chef::Resource::Batch" do
+  it "creates a new Chef::Resource::Batch" do
     expect(@resource).to be_a_kind_of(Chef::Resource::Batch)
   end
 

data/spec/unit/resource/cab_package_spec.rb

@@ -32,7 +32,25 @@ describe Chef::Resource::CabPackage do
     expect(resource.resource_name).to eql(:cab_package)
   end
 
-  it "coerce its name to a package_name" do
+  it "sets the default action as :install" do
+    expect(resource.action).to eql([:install])
+  end
+
+  it "coerces name property to package_name property" do
     expect(resource.package_name).to eql("test_pkg")
   end
+
+  it "coerces name property to a source property if source not provided" do
+    expect(resource.source).to end_with("test_pkg")
+  end
+
+  it "coerces name property to a source property if source not provided and package_name is" do
+    resource.package_name("package.cab")
+    expect(resource.source).to end_with("package.cab")
+  end
+
+  it "coerces source property if it does not looks like a path" do
+    resource.source("package.cab")
+    expect(resource.source).not_to eq("package.cab")
+  end
 end

data/spec/unit/resource/chef_gem_spec.rb

@@ -34,15 +34,15 @@ end
 describe Chef::Resource::ChefGem, "gem_binary" do
   let(:resource) { Chef::Resource::ChefGem.new("foo") }
 
-  it "should raise an exception when gem_binary is set" do
+  it "raises an exception when gem_binary is set" do
     expect { resource.gem_binary("/lol/cats/gem") }.to raise_error(ArgumentError)
   end
 
-  it "should set the gem_binary based on computing it from RbConfig" do
+  it "sets the gem_binary based on computing it from RbConfig" do
     expect(resource.gem_binary).to eql("#{RbConfig::CONFIG['bindir']}/gem")
   end
 
-  it "should set compile_time to false by default" do
+  it "sets compile_time to false by default" do
     expect(resource.compile_time).to be false
   end
 

data/spec/unit/resource/chocolatey_package_spec.rb

@@ -22,50 +22,50 @@ describe Chef::Resource::ChocolateyPackage do
 
   let(:resource) { Chef::Resource::ChocolateyPackage.new("fakey_fakerton") }
 
-  it "should create a new Chef::Resource::ChocolateyPackage" do
+  it "creates a new Chef::Resource::ChocolateyPackage" do
     expect(resource).to be_a_kind_of(Chef::Resource)
     expect(resource).to be_a_kind_of(Chef::Resource::Package)
     expect(resource).to be_a_instance_of(Chef::Resource::ChocolateyPackage)
   end
 
-  it "should have a resource name of :python" do
+  it "has a resource name of :python" do
     expect(resource.resource_name).to eql(:chocolatey_package)
   end
 
-  it "should coerce its name to a package_name array" do
+  it "coerces its name to a package_name array" do
     expect(resource.package_name).to eql(["fakey_fakerton"])
   end
 
-  it "the package_name setter should coerce to arrays" do
+  it "the package_name setter coerces to arrays" do
     resource.package_name("git")
     expect(resource.package_name).to eql(["git"])
   end
 
-  it "the package_name setter should accept arrays" do
+  it "the package_name setter accepts arrays" do
     resource.package_name(%w{git unzip})
     expect(resource.package_name).to eql(%w{git unzip})
   end
 
-  it "the name should accept arrays" do
+  it "the name accepts arrays" do
     resource = Chef::Resource::ChocolateyPackage.new(%w{git unzip})
     expect(resource.package_name).to eql(%w{git unzip})
   end
 
-  it "the default version should be nil" do
+  it "the default version is nil" do
     expect(resource.version).to eql(nil)
   end
 
-  it "the version setter should coerce to arrays" do
+  it "the version setter coerces to arrays" do
     resource.version("1.2.3")
     expect(resource.version).to eql(["1.2.3"])
   end
 
-  it "the version setter should accept arrays" do
+  it "the version setter accepts arrays" do
     resource.version(["1.2.3", "4.5.6"])
     expect(resource.version).to eql(["1.2.3", "4.5.6"])
   end
 
-  it "the default returns should be 0" do
+  it "the default returns is 0" do
     expect(resource.returns).to eql([0])
   end