chef 13.6.4-universal-mingw32 → 13.7.16-universal-mingw32

data/spec/unit/resource/template_spec.rb

@@ -19,76 +19,73 @@
 require "spec_helper"
 
 describe Chef::Resource::Template do
-
-  before(:each) do
-    @resource = Chef::Resource::Template.new("fakey_fakerton")
-  end
+  let(:resource) { Chef::Resource::Template.new("fakey_fakerton") }
 
   describe "initialize" do
-    it "should create a new Chef::Resource::Template" do
-      expect(@resource).to be_a_kind_of(Chef::Resource)
-      expect(@resource).to be_a_kind_of(Chef::Resource::File)
-      expect(@resource).to be_a_kind_of(Chef::Resource::Template)
+    it "creates a new Chef::Resource::Template" do
+      expect(resource).to be_a_kind_of(Chef::Resource)
+      expect(resource).to be_a_kind_of(Chef::Resource::File)
+      expect(resource).to be_a_kind_of(Chef::Resource::Template)
     end
   end
 
   describe "source" do
-    it "should accept a string for the template source" do
-      @resource.source "something"
-      expect(@resource.source).to eql("something")
+    it "accepts a string for the template source" do
+      resource.source "something"
+      expect(resource.source).to eql("something")
     end
 
-    it "should have a default based on the param name with .erb appended" do
-      expect(@resource.source).to eql("fakey_fakerton.erb")
+    it "has a default based on the param name with .erb appended" do
+      expect(resource.source).to eql("fakey_fakerton.erb")
     end
 
-    it "should use only the basename of the file as the default" do
+    it "uses only the basename of the file as the default" do
       r = Chef::Resource::Template.new("/tmp/obit/fakey_fakerton")
       expect(r.source).to eql("fakey_fakerton.erb")
     end
   end
 
   describe "variables" do
-    it "should accept a hash for the variable list" do
-      @resource.variables({ :reluctance => :awkward })
-      expect(@resource.variables).to eq({ :reluctance => :awkward })
+    it "accepts a hash for the variable list" do
+      resource.variables({ :reluctance => :awkward })
+      expect(resource.variables).to eq({ :reluctance => :awkward })
     end
   end
 
   describe "cookbook" do
-    it "should accept a string for the cookbook name" do
-      @resource.cookbook("foo")
-      expect(@resource.cookbook).to eq("foo")
+    it "accepts a string for the cookbook name" do
+      resource.cookbook("foo")
+      expect(resource.cookbook).to eq("foo")
     end
 
-    it "should default to nil" do
-      expect(@resource.cookbook).to eq(nil)
+    it "defaults to nil" do
+      expect(resource.cookbook).to eq(nil)
     end
   end
 
   describe "local" do
-    it "should accept a boolean for whether a template is local or remote" do
-      @resource.local(true)
-      expect(@resource.local).to eq(true)
+    it "accepts a boolean for whether a template is local or remote" do
+      resource.local(true)
+      expect(resource.local).to eq(true)
     end
 
-    it "should default to false" do
-      expect(@resource.local).to eq(false)
+    it "defaults to false" do
+      expect(resource.local).to eq(false)
     end
   end
 
   describe "when it has a path, owner, group, mode, and checksum" do
     before do
-      @resource.path("/tmp/foo.txt")
-      @resource.owner("root")
-      @resource.group("wheel")
-      @resource.mode("0644")
-      @resource.checksum("1" * 64)
+      resource.path("/tmp/foo.txt")
+      resource.owner("root")
+      resource.group("wheel")
+      resource.mode("0644")
+      resource.checksum("1" * 64)
     end
 
     context "on unix", :unix_only do
       it "describes its state" do
-        state = @resource.state_for_resource_reporter
+        state = resource.state_for_resource_reporter
         expect(state[:owner]).to eq("root")
         expect(state[:group]).to eq("wheel")
         expect(state[:mode]).to eq("0644")
@@ -102,7 +99,7 @@ describe Chef::Resource::Template do
     end
 
     it "returns the file path as its identity" do
-      expect(@resource.identity).to eq("/tmp/foo.txt")
+      expect(resource.identity).to eq("/tmp/foo.txt")
     end
   end
 
@@ -115,16 +112,16 @@ describe Chef::Resource::Template do
     end
 
     it "collects helper method bodies as blocks" do
-      @resource.helper(:example_1) { "example_1" }
-      @resource.helper(:example_2) { "example_2" }
-      expect(@resource.inline_helper_blocks[:example_1].call).to eq("example_1")
-      expect(@resource.inline_helper_blocks[:example_2].call).to eq("example_2")
+      resource.helper(:example_1) { "example_1" }
+      resource.helper(:example_2) { "example_2" }
+      expect(resource.inline_helper_blocks[:example_1].call).to eq("example_1")
+      expect(resource.inline_helper_blocks[:example_2].call).to eq("example_2")
     end
 
     it "compiles helper methods into a module" do
-      @resource.helper(:example_1) { "example_1" }
-      @resource.helper(:example_2) { "example_2" }
-      modules = @resource.helper_modules
+      resource.helper(:example_1) { "example_1" }
+      resource.helper(:example_2) { "example_2" }
+      modules = resource.helper_modules
       expect(modules.size).to eq(1)
       o = Object.new
       modules.each { |m| o.extend(m) }
@@ -133,38 +130,38 @@ describe Chef::Resource::Template do
     end
 
     it "compiles helper methods with arguments into a module" do
-      @resource.helper(:shout) { |quiet| quiet.upcase }
-      modules = @resource.helper_modules
+      resource.helper(:shout) { |quiet| quiet.upcase }
+      modules = resource.helper_modules
       o = Object.new
       modules.each { |m| o.extend(m) }
       expect(o.shout("shout")).to eq("SHOUT")
     end
 
     it "raises an error when attempting to define a helper method without a method body" do
-      expect { @resource.helper(:example) }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { resource.helper(:example) }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
 
     it "raises an error when attempting to define a helper method with a non-Symbod method name" do
-      expect { @resource.helper("example") { "fail" } }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { resource.helper("example") { "fail" } }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
 
     it "collects helper module bodies as blocks" do
-      @resource.helpers do
+      resource.helpers do
         def example_1
           "example_1"
         end
       end
-      module_body = @resource.inline_helper_modules.first
+      module_body = resource.inline_helper_modules.first
       expect(module_body).to be_a(Proc)
     end
 
     it "compiles helper module bodies into modules" do
-      @resource.helpers do
+      resource.helpers do
         def example_1
           "example_1"
         end
       end
-      modules = @resource.helper_modules
+      modules = resource.helper_modules
       expect(modules.size).to eq(1)
       o = Object.new
       modules.each { |m| o.extend(m) }
@@ -172,39 +169,37 @@ describe Chef::Resource::Template do
     end
 
     it "raises an error when no block or module name is given for helpers definition" do
-      expect { @resource.helpers() }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { resource.helpers() }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
 
     it "raises an error when a non-module is given for helpers definition" do
-      expect { @resource.helpers("NotAModule") }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { resource.helpers("NotAModule") }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
 
     it "raises an error when a module name and block are both given for helpers definition" do
-      expect { @resource.helpers(ExampleHelpers) { module_code } }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { resource.helpers(ExampleHelpers) { module_code } }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
 
     it "collects helper modules" do
-      @resource.helpers(ExampleHelpers)
-      expect(@resource.helper_modules).to include(ExampleHelpers)
+      resource.helpers(ExampleHelpers)
+      expect(resource.helper_modules).to include(ExampleHelpers)
     end
 
     it "combines all helpers into a set of compiled modules" do
-      @resource.helpers(ExampleHelpers)
-      @resource.helpers do
+      resource.helpers(ExampleHelpers)
+      resource.helpers do
         def inline_module
           "inline_module"
         end
       end
-      @resource.helper(:inline_method) { "inline_method" }
-      expect(@resource.helper_modules.size).to eq(3)
+      resource.helper(:inline_method) { "inline_method" }
+      expect(resource.helper_modules.size).to eq(3)
 
       o = Object.new
-      @resource.helper_modules.each { |m| o.extend(m) }
+      resource.helper_modules.each { |m| o.extend(m) }
       expect(o.static_example).to eq("static_example")
       expect(o.inline_module).to eq("inline_module")
       expect(o.inline_method).to eq("inline_method")
     end
-
   end
-
 end

data/spec/unit/resource/user_spec.rb

@@ -19,115 +19,109 @@
 require "spec_helper"
 
 describe Chef::Resource::User, "initialize" do
-  before(:each) do
-    @resource = Chef::Resource::User.new("adam")
-  end
+  let(:resource) { Chef::Resource::User.new("adam") }
 
-  it "should create a new Chef::Resource::User" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::User)
+  it "creates a new Chef::Resource::User" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::User)
   end
 
-  it "should set the resource_name to :user" do
-    expect(@resource.resource_name).to eql(:user_resource_abstract_base_class)
+  it "sets the resource_name to :user" do
+    expect(resource.resource_name).to eql(:user_resource_abstract_base_class)
   end
 
-  it "should set the username equal to the argument to initialize" do
-    expect(@resource.username).to eql("adam")
+  it "sets the username equal to the argument to initialize" do
+    expect(resource.username).to eql("adam")
   end
 
   %w{comment uid gid home shell password}.each do |attrib|
-    it "should set #{attrib} to nil" do
-      expect(@resource.send(attrib)).to eql(nil)
+    it "sets #{attrib} to nil" do
+      expect(resource.send(attrib)).to eql(nil)
     end
   end
 
-  it "should set action to :create" do
-    expect(@resource.action).to eql([:create])
+  it "sets action to :create" do
+    expect(resource.action).to eql([:create])
   end
 
-  it "should set manage_home to false" do
-    expect(@resource.manage_home).to eql(false)
+  it "sets manage_home to false" do
+    expect(resource.manage_home).to eql(false)
   end
 
-  it "should set non_unique to false" do
-    expect(@resource.non_unique).to eql(false)
+  it "sets non_unique to false" do
+    expect(resource.non_unique).to eql(false)
   end
 
-  it "should set force to false" do
-    expect(@resource.force).to eql(false)
+  it "sets force to false" do
+    expect(resource.force).to eql(false)
   end
 
   %w{create remove modify manage lock unlock}.each do |action|
-    it "should allow action #{action}" do
-      expect(@resource.allowed_actions.detect { |a| a == action.to_sym }).to eql(action.to_sym)
+    it "allows action #{action}" do
+      expect(resource.allowed_actions.detect { |a| a == action.to_sym }).to eql(action.to_sym)
     end
   end
 
-  it "should accept domain users (@ or \ separator) on non-windows" do
-    expect { @resource.username "domain\@user" }.not_to raise_error
-    expect(@resource.username).to eq("domain\@user")
-    expect { @resource.username "domain\\user" }.not_to raise_error
-    expect(@resource.username).to eq("domain\\user")
+  it "accepts domain users (@ or \ separator) on non-windows" do
+    expect { resource.username "domain\@user" }.not_to raise_error
+    expect(resource.username).to eq("domain\@user")
+    expect { resource.username "domain\\user" }.not_to raise_error
+    expect(resource.username).to eq("domain\\user")
   end
 end
 
 %w{username comment home shell password}.each do |attrib|
   describe Chef::Resource::User, attrib do
-    before(:each) do
-      @resource = Chef::Resource::User.new("adam")
-    end
+    let(:resource) { Chef::Resource::User.new("adam") }
 
-    it "should allow a string" do
-      @resource.send(attrib, "adam")
-      expect(@resource.send(attrib)).to eql("adam")
+    it "allows a string" do
+      resource.send(attrib, "adam")
+      expect(resource.send(attrib)).to eql("adam")
     end
 
-    it "should not allow a hash" do
-      expect { @resource.send(attrib, { :woot => "i found it" }) }.to raise_error(ArgumentError)
+    it "does not allow a hash" do
+      expect { resource.send(attrib, { :woot => "i found it" }) }.to raise_error(ArgumentError)
     end
   end
 end
 
 %w{uid gid}.each do |attrib|
   describe Chef::Resource::User, attrib do
-    before(:each) do
-      @resource = Chef::Resource::User.new("adam")
-    end
+    let(:resource) { Chef::Resource::User.new("adam") }
 
-    it "should allow a string" do
-      @resource.send(attrib, "100")
-      expect(@resource.send(attrib)).to eql("100")
+    it "allows a string" do
+      resource.send(attrib, "100")
+      expect(resource.send(attrib)).to eql("100")
     end
 
-    it "should allow an integer" do
-      @resource.send(attrib, 100)
-      expect(@resource.send(attrib)).to eql(100)
+    it "allows an integer" do
+      resource.send(attrib, 100)
+      expect(resource.send(attrib)).to eql(100)
     end
 
-    it "should not allow a hash" do
-      expect { @resource.send(attrib, { :woot => "i found it" }) }.to raise_error(ArgumentError)
+    it "does not allow a hash" do
+      expect { resource.send(attrib, { :woot => "i found it" }) }.to raise_error(ArgumentError)
     end
   end
 
   describe "when it has uid, gid, and home" do
+    let(:resource) { Chef::Resource::User.new("root") }
+
     before do
-      @resource = Chef::Resource::User.new("root")
-      @resource.uid(123)
-      @resource.gid(456)
-      @resource.home("/usr/local/root/")
+      resource.uid(123)
+      resource.gid(456)
+      resource.home("/usr/local/root/")
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:uid]).to eq(123)
       expect(state[:gid]).to eq(456)
       expect(state[:home]).to eq("/usr/local/root/")
     end
 
     it "returns the username as its identity" do
-      expect(@resource.identity).to eq("root")
+      expect(resource.identity).to eq("root")
     end
   end
-
 end

data/spec/unit/resource/windows_package_spec.rb

@@ -88,7 +88,7 @@ describe Chef::Resource::WindowsPackage, "initialize" do
     let(:resource_source) { "https://foo.bar/solitare.msi" }
     let(:resource) { Chef::Resource::WindowsPackage.new(resource_source) }
 
-    it "should return the source unmodified" do
+    it "returns the source unmodified" do
       expect(resource.source).to eq(resource_source)
     end
   end

data/spec/unit/resource/windows_path_spec.rb

@@ -19,20 +19,23 @@
 require "spec_helper"
 
 describe Chef::Resource::WindowsPath do
-  subject { Chef::Resource::WindowsPath.new("some_path") }
-
-  it { is_expected.to be_a_kind_of(Chef::Resource) }
-  it { is_expected.to be_a_instance_of(Chef::Resource::WindowsPath) }
+  let(:resource) { Chef::Resource::WindowsPath.new("some_path") }
 
   it "sets resource name as :windows_path" do
-    expect(subject.resource_name).to eql(:windows_path)
+    expect(resource.resource_name).to eql(:windows_path)
   end
 
-  it "sets the path as it's name" do
-    expect(subject.path).to eql("some_path")
+  it "sets the path as its name" do
+    expect(resource.path).to eql("some_path")
   end
 
   it "sets the default action as :add" do
-    expect(subject.action).to eql(:add)
+    expect(resource.action).to eql([:add])
+  end
+
+  it "supports :add and :remove actions" do
+    expect { resource.action :add }.not_to raise_error
+    expect { resource.action :remove }.not_to raise_error
+    expect { resource.action :delete }.to raise_error(ArgumentError)
   end
 end

data/spec/unit/resource/windows_task_spec.rb

@@ -30,12 +30,12 @@ describe Chef::Resource::WindowsTask do
     expect(resource.resource_name).to eql(:windows_task)
   end
 
-  it "sets the task_name as it's name" do
+  it "sets the task_name as its name" do
     expect(resource.task_name).to eql("sample_task")
   end
 
   it "sets the default action as :create" do
-    expect(resource.action).to eql(:create)
+    expect(resource.action).to eql([:create])
   end
 
   it "sets the default user as System" do
@@ -62,39 +62,86 @@ describe Chef::Resource::WindowsTask do
     expect(resource.frequency).to eql(:hourly)
   end
 
+  context "when user is set but password is not" do
+    it "raises an error if the user is a non-system user" do
+      resource.user "bob"
+      expect { resource.after_created }.to raise_error(ArgumentError, %q{Cannot specify a user other than the system users without specifying a password!. Valid passwordless users: 'NT AUTHORITY\SYSTEM', 'SYSTEM', 'NT AUTHORITY\LOCALSERVICE', 'NT AUTHORITY\NETWORKSERVICE', 'BUILTIN\USERS', 'USERS'})
+    end
+
+    it "does not raise an error if the user is a system user" do
+      resource.user 'NT AUTHORITY\SYSTEM'
+      expect { resource.after_created }.to_not raise_error
+    end
+
+    it "does not raise an error if the user is a system user even if lowercase" do
+      resource.user 'nt authority\system'
+      expect { resource.after_created }.to_not raise_error
+    end
+  end
+
   context "when random_delay is passed" do
     it "raises error if frequency is `:once`" do
       resource.frequency :once
       resource.random_delay "20"
-      expect { resource.after_created }.to raise_error(Chef::Exceptions::ArgumentError, "`random_delay` property is supported only for frequency :minute, :hourly, :daily, :weekly and :monthly")
+      expect { resource.after_created }.to raise_error(ArgumentError, "`random_delay` property is supported only for frequency :minute, :hourly, :daily, :weekly and :monthly")
     end
 
     it "raises error for invalid random_delay" do
       resource.frequency :monthly
       resource.random_delay "xyz"
-      expect { resource.after_created }.to raise_error(Chef::Exceptions::ArgumentError, "Invalid value passed for `random_delay`. Please pass seconds as a String e.g. '60'.")
+      expect { resource.after_created }.to raise_error(ArgumentError, "Invalid value passed for `random_delay`. Please pass seconds as an Integer (e.g. 60) or a String with numeric values only (e.g. '60').")
     end
 
-    it "converts seconds into iso8601 format" do
+    it "raises error for invalid random_delay which looks like an Integer" do
+      resource.frequency :monthly
+      resource.random_delay "5,000"
+      expect { resource.after_created }.to raise_error(ArgumentError, "Invalid value passed for `random_delay`. Please pass seconds as an Integer (e.g. 60) or a String with numeric values only (e.g. '60').")
+    end
+
+    it "converts seconds String into iso8601 duration format" do
       resource.frequency :monthly
       resource.random_delay "60"
       resource.after_created
       expect(resource.random_delay).to eq("PT60S")
     end
+
+    it "converts seconds Integer into iso8601 duration format" do
+      resource.frequency :monthly
+      resource.random_delay 60
+      resource.after_created
+      expect(resource.random_delay).to eq("PT60S")
+    end
+
+    it "raises error that random_delay is not supported" do
+      expect { resource.send(:validate_random_delay, 60, :on_idle) }.to raise_error(ArgumentError, "`random_delay` property is supported only for frequency :minute, :hourly, :daily, :weekly and :monthly")
+    end
   end
 
-  context "when execution_time_limit is passed" do
-    it "sets the deafult value as PT72H" do
+  context "when execution_time_limit isn't specified" do
+    it "sets the default value to PT72H" do
       resource.after_created
       expect(resource.execution_time_limit).to eq("PT72H")
     end
+  end
 
+  context "when execution_time_limit is passed" do
     it "raises error for invalid execution_time_limit" do
       resource.execution_time_limit "abc"
-      expect { resource.after_created }.to raise_error(Chef::Exceptions::ArgumentError, "Invalid value passed for `execution_time_limit`. Please pass seconds as a String e.g. '60'.")
+      expect { resource.after_created }.to raise_error(ArgumentError, "Invalid value passed for `execution_time_limit`. Please pass seconds as an Integer (e.g. 60) or a String with numeric values only (e.g. '60').")
     end
 
-    it "converts seconds into iso8601 format" do
+    it "raises error for invalid execution_time_limit that looks like an Integer" do
+      resource.execution_time_limit "5,000"
+      expect { resource.after_created }.to raise_error(ArgumentError, "Invalid value passed for `execution_time_limit`. Please pass seconds as an Integer (e.g. 60) or a String with numeric values only (e.g. '60').")
+    end
+
+    it "converts seconds Integer into iso8601 format" do
+      resource.execution_time_limit 60
+      resource.after_created
+      expect(resource.execution_time_limit).to eq("PT60S")
+    end
+
+    it "converts seconds String into iso8601 format" do
       resource.execution_time_limit "60"
       resource.after_created
       expect(resource.execution_time_limit).to eq("PT60S")
@@ -104,28 +151,48 @@ describe Chef::Resource::WindowsTask do
   context "#validate_start_time" do
     it "raises error if start_time is nil when frequency `:once`" do
       resource.frequency :once
-      expect { resource.send(:validate_start_time, nil, :once) }.to raise_error(Chef::Exceptions::ArgumentError, "`start_time` needs to be provided with `frequency :once`")
+      expect { resource.send(:validate_start_time, nil, :once) }.to raise_error(ArgumentError, "`start_time` needs to be provided with `frequency :once`")
     end
 
     it "raises error if start_time is given when frequency `:none`" do
       resource.frequency :none
-      expect { resource.send(:validate_start_time, "12.00", :none) }.to raise_error(Chef::Exceptions::ArgumentError, "`start_time` property is not supported with `frequency :none`")
+      expect { resource.send(:validate_start_time, "12.00", :none) }.to raise_error(ArgumentError, "`start_time` property is not supported with `frequency :none`")
+    end
+
+    it "raises error if start_time is not HH:mm format" do
+      resource.frequency :once
+      expect { resource.send(:validate_start_time, "2:30", :once) }.to raise_error(ArgumentError, "`start_time` property must be in the HH:mm format (e.g. 6:20pm -> 18:20).")
+    end
+
+    it "does not raise error if start_time is in HH:mm format" do
+      resource.frequency :once
+      expect { resource.send(:validate_start_time, "12:30", :once) }.not_to raise_error
     end
   end
 
   context "#validate_start_day" do
-    it "raise error if start_day is passed with frequency :on_logon" do
-      resource.frequency :on_logon
-      expect { resource.send(:validate_start_day, "Wed", :on_logon) }.to raise_error(Chef::Exceptions::ArgumentError, "`start_day` property is not supported with frequency: on_logon")
+    it "raise error if start_day is passed with invalid frequency (:on_logon)" do
+      expect { resource.send(:validate_start_day, "02/07/1984", :on_logon) }.to raise_error(ArgumentError, "`start_day` property is not supported with frequency: on_logon")
     end
-  end
 
-  context "#validate_user_and_password" do
-    context "when password is not passed" do
-      it "raises error with non-system users" do
-        allow(resource).to receive(:use_password?).and_return(true)
-        expect { resource.send(:validate_user_and_password, "Testuser", nil) }.to raise_error("Can't specify a non-system user without a password!")
-      end
+    it "does not raise error if start_day is passed with valid frequency (:weekly)" do
+      expect { resource.send(:validate_start_day, "02/07/1984", :weekly) }.not_to raise_error
+    end
+
+    it "raise error if start_day is passed with invalid date format (DD/MM/YYYY)" do
+      expect { resource.send(:validate_start_day, "28/12/2009", :weekly) }.to raise_error(ArgumentError, "`start_day` property must be in the MM/DD/YYYY format.")
+    end
+
+    it "raise error if start_day is passed with invalid date format (M/DD/YYYY)" do
+      expect { resource.send(:validate_start_day, "2/07/1984", :weekly) }.to raise_error(ArgumentError, "`start_day` property must be in the MM/DD/YYYY format.")
+    end
+
+    it "raise error if start_day is passed with invalid date format (MM/D/YYYY)" do
+      expect { resource.send(:validate_start_day, "02/7/1984", :weekly) }.to raise_error(ArgumentError, "`start_day` property must be in the MM/DD/YYYY format.")
+    end
+
+    it "raise error if start_day is passed with invalid date format (MM/DD/YY)" do
+      expect { resource.send(:validate_start_day, "02/07/84", :weekly) }.to raise_error(ArgumentError, "`start_day` property must be in the MM/DD/YYYY format.")
     end
   end
 
@@ -138,42 +205,42 @@ describe Chef::Resource::WindowsTask do
   context "#validate_create_frequency_modifier" do
     context "when frequency is :minute" do
       it "raises error if frequency_modifier > 1439" do
-        expect { resource.send(:validate_create_frequency_modifier, :minute, 1500) }.to raise_error("frequency_modifier value 1500 is invalid.  Valid values for :minute frequency are 1 - 1439.")
+        expect { resource.send(:validate_create_frequency_modifier, :minute, 1500) }.to raise_error("frequency_modifier value 1500 is invalid. Valid values for :minute frequency are 1 - 1439.")
       end
     end
 
     context "when frequency is :hourly" do
       it "raises error if frequency_modifier > 23" do
-        expect { resource.send(:validate_create_frequency_modifier, :hourly, 24) }.to raise_error("frequency_modifier value 24 is invalid.  Valid values for :hourly frequency are 1 - 23.")
+        expect { resource.send(:validate_create_frequency_modifier, :hourly, 24) }.to raise_error("frequency_modifier value 24 is invalid. Valid values for :hourly frequency are 1 - 23.")
       end
     end
 
     context "when frequency is :daily" do
       it "raises error if frequency_modifier > 365" do
-        expect { resource.send(:validate_create_frequency_modifier, :daily, 366) }.to raise_error("frequency_modifier value 366 is invalid.  Valid values for :daily frequency are 1 - 365.")
+        expect { resource.send(:validate_create_frequency_modifier, :daily, 366) }.to raise_error("frequency_modifier value 366 is invalid. Valid values for :daily frequency are 1 - 365.")
       end
     end
 
     context "when frequency is :weekly" do
       it "raises error if frequency_modifier > 52" do
-        expect { resource.send(:validate_create_frequency_modifier, :weekly, 53) }.to raise_error("frequency_modifier value 53 is invalid.  Valid values for :weekly frequency are 1 - 52.")
+        expect { resource.send(:validate_create_frequency_modifier, :weekly, 53) }.to raise_error("frequency_modifier value 53 is invalid. Valid values for :weekly frequency are 1 - 52.")
       end
     end
 
     context "when frequency is :monthly" do
       it "raises error if frequency_modifier > 12" do
-        expect { resource.send(:validate_create_frequency_modifier, :monthly, 14) }.to raise_error("frequency_modifier value 14 is invalid.  Valid values for :monthly frequency are 1 - 12, 'FIRST', 'SECOND', 'THIRD', 'FOURTH', 'LAST', 'LASTDAY'.")
+        expect { resource.send(:validate_create_frequency_modifier, :monthly, 14) }.to raise_error("frequency_modifier value 14 is invalid. Valid values for :monthly frequency are 1 - 12, 'FIRST', 'SECOND', 'THIRD', 'FOURTH', 'LAST', 'LASTDAY'.")
       end
 
       it "raises error if frequency_modifier is invalid" do
-        expect { resource.send(:validate_create_frequency_modifier, :monthly, "abc") }.to raise_error("frequency_modifier value abc is invalid.  Valid values for :monthly frequency are 1 - 12, 'FIRST', 'SECOND', 'THIRD', 'FOURTH', 'LAST', 'LASTDAY'.")
+        expect { resource.send(:validate_create_frequency_modifier, :monthly, "abc") }.to raise_error("frequency_modifier value abc is invalid. Valid values for :monthly frequency are 1 - 12, 'FIRST', 'SECOND', 'THIRD', 'FOURTH', 'LAST', 'LASTDAY'.")
       end
     end
   end
 
   context "#validate_create_day" do
     it "raises error if frequency is not :weekly or :monthly" do
-      expect  { resource.send(:validate_create_day, "Mon", :once) }.to raise_error("day attribute is only valid for tasks that run monthly or weekly")
+      expect  { resource.send(:validate_create_day, "Mon", :once) }.to raise_error("day property is only valid for tasks that run monthly or weekly")
     end
 
     it "accepts a valid single day" do
@@ -185,13 +252,13 @@ describe Chef::Resource::WindowsTask do
     end
 
     it "raises error for invalid day value" do
-      expect  { resource.send(:validate_create_day, "xyz", :weekly) }.to raise_error("day attribute invalid.  Only valid values are: MON, TUE, WED, THU, FRI, SAT, SUN and *.  Multiple values must be separated by a comma.")
+      expect  { resource.send(:validate_create_day, "xyz", :weekly) }.to raise_error(ArgumentError, "day property invalid. Only valid values are: MON, TUE, WED, THU, FRI, SAT, SUN and *. Multiple values must be separated by a comma.")
     end
   end
 
   context "#validate_create_months" do
     it "raises error if frequency is not :monthly" do
-      expect  { resource.send(:validate_create_months, "Jan", :once) }.to raise_error("months attribute is only valid for tasks that run monthly")
+      expect  { resource.send(:validate_create_months, "Jan", :once) }.to raise_error(ArgumentError, "months property is only valid for tasks that run monthly")
     end
 
     it "accepts a valid single month" do
@@ -203,17 +270,46 @@ describe Chef::Resource::WindowsTask do
     end
 
     it "raises error for invalid month value" do
-      expect  { resource.send(:validate_create_months, "xyz", :monthly) }.to raise_error("months attribute invalid. Only valid values are: JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC and *. Multiple values must be separated by a comma.")
+      expect  { resource.send(:validate_create_months, "xyz", :monthly) }.to raise_error(ArgumentError, "months property invalid. Only valid values are: JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC and *. Multiple values must be separated by a comma.")
     end
   end
 
   context "#validate_idle_time" do
     it "raises error if frequency is not :on_idle" do
-      expect  { resource.send(:validate_idle_time, 5, :hourly) }.to raise_error("idle_time attribute is only valid for tasks that run on_idle")
+      expect  { resource.send(:validate_idle_time, 5, :hourly) }.to raise_error(ArgumentError, "idle_time property is only valid for tasks that run on_idle")
     end
 
     it "raises error if idle_time > 999" do
-      expect  { resource.send(:validate_idle_time, 1000, :on_idle) }.to raise_error("idle_time value 1000 is invalid.  Valid values for :on_idle frequency are 1 - 999.")
+      expect  { resource.send(:validate_idle_time, 1000, :on_idle) }.to raise_error(ArgumentError, "idle_time value 1000 is invalid. Valid values for :on_idle frequency are 1 - 999.")
+    end
+
+    it "raises error if idle_time < 0" do
+      expect  { resource.send(:validate_idle_time, -5, :on_idle) }.to raise_error(ArgumentError, "idle_time value -5 is invalid. Valid values for :on_idle frequency are 1 - 999.")
+    end
+
+    it "raises error if idle_time is not set" do
+      expect  { resource.send(:validate_idle_time, nil, :on_idle) }.to raise_error(ArgumentError, "idle_time value should be set for :on_idle frequency.")
+    end
+  end
+
+  context "#sec_to_dur" do
+    it "return nil when passed 0" do
+      expect(resource.send(:sec_to_dur, 0)).to eql("PT0S")
+    end
+    it "return PT1S when passed 1" do
+      expect(resource.send(:sec_to_dur, 1)).to eql("PT1S")
+    end
+    it "return PT86400S when passed 86400" do
+      expect(resource.send(:sec_to_dur, 86400)).to eql("PT86400S")
+    end
+    it "return PT86401S when passed 86401" do
+      expect(resource.send(:sec_to_dur, 86401)).to eql("PT86401S")
+    end
+    it "return PT86500S when passed 86500" do
+      expect(resource.send(:sec_to_dur, 86500)).to eql("PT86500S")
+    end
+    it "return PT604801S when passed 604801" do
+      expect(resource.send(:sec_to_dur, 604801)).to eql("PT604801S")
     end
   end
 end