chef 12.22.5-universal-mingw32 → 13.0.113-universal-mingw32

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

@@ -198,6 +198,33 @@ describe Chef::Provider::Service::Solaris do
       end
     end
 
+    describe "when enabling the service recursively" do
+      before(:each) do
+        @provider.current_resource = @current_resource
+      end
+
+      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).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
+        expect(@provider.enable_service).to be_truthy
+        expect(@current_resource.enabled).to be_truthy
+      end
+
+      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).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
+        expect(@provider.enable_service).to be_truthy
+        expect(@current_resource.enabled).to be_truthy
+      end
+
+    end
+
     describe "when disabling the service" do
       before(:each) do
         @provider.current_resource = @current_resource
@@ -215,7 +242,16 @@ describe Chef::Provider::Service::Solaris do
         expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@disabled_svc_status)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "disable", "-s", "chef").and_return(@success)
         @provider.load_current_resource
-        expect(@provider.stop_service).to be_truthy
+        expect(@provider.disable_service).to be_truthy
+        expect(@current_resource.enabled).to be_falsey
+      end
+
+      it "should call svcadm disable chef with options" do
+        @new_resource.options("-t")
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", { :returns => [0, 1] }).and_return(@disabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "disable", "-s", "-t", "chef").and_return(@success)
+        @provider.load_current_resource
+        expect(@provider.disable_service).to be_truthy
         expect(@current_resource.enabled).to be_falsey
       end
 

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

@@ -71,12 +71,8 @@ describe Chef::Provider::Service::Upstart do
       @current_resource = Chef::Resource::Service.new("rsyslog")
       allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
 
-      @status = double("Status", :exitstatus => 0)
-      allow(@provider).to receive(:popen4).and_return(@status)
-      @stdin = StringIO.new
-      @stdout = StringIO.new
-      @stderr = StringIO.new
-      @pid = double("PID")
+      @status = double("Status", exitstatus: 0, stdout: "", stderr: "")
+      allow(@provider).to receive(:shell_out).and_return(@status)
 
       allow(::File).to receive(:exists?).and_return(true)
       allow(::File).to receive(:open).and_return(true)
@@ -100,28 +96,25 @@ describe Chef::Provider::Service::Upstart do
     end
 
     it "should run '/sbin/status rsyslog'" do
-      expect(@provider).to receive(:popen4).with("/sbin/status rsyslog").and_return(@status)
+      expect(@provider).to receive(:shell_out).with("/sbin/status rsyslog").and_return(@status)
       @provider.load_current_resource
     end
 
     describe "when the status command uses the new format" do
       it "should set running to true if the goal state is 'start'" do
-        @stdout = StringIO.new("rsyslog start/running")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog start/running")
         @provider.load_current_resource
         expect(@current_resource.running).to be_truthy
       end
 
       it "should set running to true if the goal state is 'start' but current state is not 'running'" do
-        @stdout = StringIO.new("rsyslog start/starting")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog start/starting")
         @provider.load_current_resource
         expect(@current_resource.running).to be_truthy
       end
 
       it "should set running to false if the goal state is 'stop'" do
-        @stdout = StringIO.new("rsyslog stop/waiting")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog stop/waiting")
         @provider.load_current_resource
         expect(@current_resource.running).to be_falsey
       end
@@ -129,22 +122,19 @@ describe Chef::Provider::Service::Upstart do
 
     describe "when the status command uses the new format with an instance" do
       it "should set running to true if the goal state is 'start'" do
-        @stdout = StringIO.new("rsyslog (test) start/running, process 100")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog (test) start/running, process 100")
         @provider.load_current_resource
         expect(@current_resource.running).to be_truthy
       end
 
       it "should set running to true if the goal state is 'start' but current state is not 'running'" do
-        @stdout = StringIO.new("rsyslog (test) start/starting, process 100")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog (test) start/starting, process 100")
         @provider.load_current_resource
         expect(@current_resource.running).to be_truthy
       end
 
       it "should set running to false if the goal state is 'stop'" do
-        @stdout = StringIO.new("rsyslog (test) stop/waiting, process 100")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog (test) stop/waiting, process 100")
         @provider.load_current_resource
         expect(@current_resource.running).to be_falsey
       end
@@ -152,22 +142,19 @@ describe Chef::Provider::Service::Upstart do
 
     describe "when the status command uses the old format" do
       it "should set running to true if the goal state is 'start'" do
-        @stdout = StringIO.new("rsyslog (start) running, process 32225")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog (start) running, process 32225")
         @provider.load_current_resource
         expect(@current_resource.running).to be_truthy
       end
 
       it "should set running to true if the goal state is 'start' but current state is not 'running'" do
-        @stdout = StringIO.new("rsyslog (start) starting, process 32225")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog (start) starting, process 32225")
         @provider.load_current_resource
         expect(@current_resource.running).to be_truthy
       end
 
       it "should set running to false if the goal state is 'stop'" do
-        @stdout = StringIO.new("rsyslog (stop) waiting")
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@status).to receive(:stdout).and_return("rsyslog (stop) waiting")
         @provider.load_current_resource
         expect(@current_resource.running).to be_falsey
       end

data/spec/unit/provider/subversion_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -43,7 +43,7 @@ describe Chef::Provider::Subversion do
     ENV.update(@original_env)
   end
 
-  it "converts resource attributes to options for run_command and popen4" do
+  it "converts resource attributes to options for shell_out" do
     expect(@provider.run_options).to eq({})
     @resource.user "deployninja"
     expect(@provider.run_options).to eq({ :user => "deployninja" })

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

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 #
 # License:: Apache License, Version 2.0
 #
@@ -45,56 +45,18 @@ describe Chef::Provider::User::Linux do
       @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
     end
 
-    it "supports manage_home does not exist", chef: ">= 13" do
-      expect( @new_resource.supports.key?(:manage_home) ).to be false
+    it "throws an error when trying to set supports manage_home: true" do
+      expect { @new_resource.supports( manage_home: true ) }.to raise_error(NoMethodError)
     end
 
-    it "supports non_unique does not exist", chef: ">= 13" do
-      expect( @new_resource.supports.key?(:non_unique) ).to be false
-    end
-
-    # supports is a method on the superclass so can't totally be removed, but we should aggressively NOP it to decisively break it
-    it "disables the supports API", chef: ">= 13" do
-      @new_resource.supports( manage_home: true )
-      expect( @new_resource.supports.key?(:manage_home) ).to be false
-    end
-
-    it "sets supports manage_home to false" do
-      expect( @new_resource.supports[:manage_home] ).to be false
-    end
-
-    it "sets supports non-unique to false" do
-      expect( @new_resource.supports[:non_unique] ).to be false
-    end
-
-    it "throws a deprecation warning on setting supports[:non_unique]" do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      expect(Chef).to receive(:deprecated).with(:supports_property, "supports { non_unique: true } on the user resource is deprecated and will be removed in Chef 13, set non_unique true instead")
-      @new_resource.supports( non_unique: true )
-    end
-
-    it "throws a deprecation warning on setting supports[:manage_home]" do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      expect(Chef).to receive(:deprecated).with(:supports_property, "supports { manage_home: true } on the user resource is deprecated and will be removed in Chef 13, set manage_home true instead")
-      @new_resource.supports( manage_home: true )
+    it "throws an error when trying to set supports non_unique: true" do
+      expect { @new_resource.supports( non_unique: true ) }.to raise_error(NoMethodError)
     end
 
     it "defaults manage_home to false" do
       expect( @new_resource.manage_home ).to be false
     end
 
-    it "supports[:manage_home] (incorectly) acts like manage_home" do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      @new_resource.supports(manage_home: true)
-      expect( provider.useradd_options ).to eql(["-m"])
-    end
-
-    it "supports[:manage_home] does not change behavior of manage_home: false", chef: ">= 13" do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      @new_resource.supports(manage_home: true)
-      expect( provider.useradd_options ).to eql(["-M"])
-    end
-
     it "by default manage_home is false and we use -M" do
       expect( provider.useradd_options ).to eql(["-M"])
     end

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

@@ -1,6 +1,6 @@
 #
 # Author:: Stephen Haynes (<sh@nomitor.com>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -32,9 +32,7 @@ describe Chef::Provider::User::Pw do
     @new_resource.shell     "/usr/bin/zsh"
     @new_resource.password  "abracadabra"
 
-    # XXX: rip out in Chef-13
-    Chef::Config[:treat_deprecation_warnings_as_errors] = false
-    @new_resource.supports manage_home: true
+    @new_resource.manage_home true
 
     @current_resource = Chef::Resource::User::PwUser.new("adam")
     @current_resource.comment  "Adam Jacob"
@@ -67,12 +65,6 @@ describe Chef::Provider::User::Pw do
         allow(@new_resource).to receive(attribute).and_return("hola")
         expect(@provider.set_options).to eql([ @new_resource.username, option, @new_resource.send(attribute), "-m"])
       end
-
-      it "should set the option for #{attribute} if the new resources #{attribute} is not null, without homedir management" do
-        allow(@new_resource).to receive(:supports).and_return(manage_home: false)
-        allow(@new_resource).to receive(attribute).and_return("hola")
-        expect(@provider.set_options).to eql([@new_resource.username, option, @new_resource.send(attribute)])
-      end
     end
 
     it "should combine all the possible options" do
@@ -123,7 +115,7 @@ describe Chef::Provider::User::Pw do
 
   describe "remove_user" do
     it "should run pw userdel with the new resources user name" do
-      @new_resource.supports manage_home: false
+      @new_resource.manage_home false
       expect(@provider).to receive(:shell_out!).with("pw", "userdel", @new_resource.username).and_return(true)
       @provider.remove_user
     end
@@ -163,11 +155,7 @@ describe Chef::Provider::User::Pw do
   describe "when modifying the password" do
     before(:each) do
       @status = double("Status", exitstatus: 0)
-      allow(@provider).to receive(:popen4).and_return(@status)
-      @pid = nil
-      @stdin = nil
-      @stdout = nil
-      @stderr = nil
+      allow(@provider).to receive(:shell_out!).and_return(@status)
     end
 
     describe "and the new password has not been specified" do
@@ -214,24 +202,16 @@ describe Chef::Provider::User::Pw do
       end
 
       it "should run pw usermod with the username and the option -H 0" do
-        expect(@provider).to receive(:popen4).with("pw usermod adam -H 0", waitlast: true).and_return(@status)
-        @provider.modify_password
-      end
-
-      it "should send the new password to the stdin of pw usermod" do
-        @stdin = StringIO.new
-        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        expect(@provider).to receive(:shell_out!).with("pw usermod adam -H 0", { :input => "abracadabra" }).and_return(@status)
         @provider.modify_password
-        expect(@stdin.string).to eq("abracadabra\n")
       end
 
       it "should raise an exception if pw usermod fails" do
-        expect(@status).to receive(:exitstatus).and_return(1)
-        expect { @provider.modify_password }.to raise_error(Chef::Exceptions::User)
+        expect(@provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+        expect { @provider.modify_password }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
       end
 
       it "should not raise an exception if pw usermod succeeds" do
-        expect(@status).to receive(:exitstatus).and_return(0)
         expect { @provider.modify_password }.not_to raise_error
       end
     end

data/spec/unit/provider/windows_task_spec.rb

@@ -0,0 +1,392 @@
+#
+# Author:: Nimisha Sharad (<nimisha.sharad@msystechnologies.com>)
+# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+
+describe Chef::Provider::WindowsTask do
+  let(:new_resource) { Chef::Resource::WindowsTask.new("sample_task") }
+
+  let(:provider) do
+    node = Chef::Node.new
+    events = Chef::EventDispatch::Dispatcher.new
+    run_context = Chef::RunContext.new(node, {}, events)
+    Chef::Provider::WindowsTask.new(new_resource, run_context)
+  end
+
+  let(:task_hash) do
+    {
+      :"" => "",
+      :Folder => "\\",
+      :HostName => "NIMISHA-PC",
+      :TaskName => "\\sample_task",
+      :NextRunTime => "3/30/2017 2:42:00 PM",
+      :Status => "Ready",
+      :LogonMode => "Interactive/Background",
+      :LastRunTime => "3/30/2017 2:27:00 PM",
+      :LastResult => "1",
+      :Author => "Administrator",
+      :TaskToRun => "chef-client",
+      :StartIn => "N/A",
+      :Comment => "N/A",
+      :ScheduledTaskState => "Enabled",
+      :IdleTime => "Disabled",
+      :PowerManagement => "Stop On Battery Mode, No Start On Batteries",
+      :RunAsUser => "SYSTEM",
+      :DeleteTaskIfNotRescheduled => "Enabled",
+      :StopTaskIfRunsXHoursandXMins => "72:00:00",
+      :Schedule => "Scheduling data is not available in this format.",
+      :ScheduleType => "One Time Only, Minute",
+      :StartTime => "1:12:00 PM",
+      :StartDate => "3/30/2017",
+      :EndDate => "N/A",
+      :Days => "N/A",
+      :Months => "N/A",
+      :"Repeat:Every" => "0 Hour(s), 15 Minute(s)",
+      :"Repeat:Until:Time" => "None",
+      :"Repeat:Until:Duration" => "Disabled",
+      :"Repeat:StopIfStillRunning" => "Disabled",
+      :run_level => "HighestAvailable",
+      :repetition_interval => "PT15M",
+      :execution_time_limit => "PT72H",
+    }
+  end
+
+  let(:task_xml) do
+    "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\r\r\n<Task version=\"1.2\" xmlns=\"http://schemas.microsoft.com/windows/2004/02/mit/task\">\r\r\n  <RegistrationInfo>\r\r\n    <Date>2017-03-31T15:34:44</Date>\r\r\n    <Author>Administrator</Author>\r\r\n  </RegistrationInfo>\r\r\n<Triggers>\r\r\n    <TimeTrigger>\r\r\n      <Repetition>\r\r\n        <Interval>PT15M</Interval>\r\r\n        <StopAtDurationEnd>false</StopAtDurationEnd>\r\r\n      </Repetition>\r\r\n      <StartBoundary>2017-03-31T15:34:00</StartBoundary>\r\r\n      <Enabled>true</Enabled>\r\r\n    </TimeTrigger>\r\r\n  </Triggers>\r\r\n  <Principals>\r\r\n    <Principal id=\"Author\">\r\r\n      <RunLevel>HighestAvailable</RunLevel>\r\r\n      <UserId>S-1-5-18</UserId>\r\r\n    </Principal>\r\r\n  </Principals>\r\r\n  <Settings>\r\r\n    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>\r\r\n    <DisallowStartIfOnBatteries>true</DisallowStartIfOnBatteries>\r\r\n    <StopIfGoingOnBatteries>true</StopIfGoingOnBatteries>\r\r\n    <AllowHardTerminate>true</AllowHardTerminate>\r\r\n    <StartWhenAvailable>false</StartWhenAvailable>\r\r\n    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>\r\r\n    <IdleSettings>\r\r\n      <Duration>PT10M</Duration>\r\r\n<WaitTimeout>PT1H</WaitTimeout>\r\r\n      <StopOnIdleEnd>true</StopOnIdleEnd>\r\r\n      <RestartOnIdle>false</RestartOnIdle>\r\r\n    </IdleSettings>\r\r\n    <AllowStartOnDemand>true</AllowStartOnDemand>\r\r\n    <Enabled>true</Enabled>\r\r\n    <Hidden>false</Hidden>\r\r\n<RunOnlyIfIdle>false</RunOnlyIfIdle>\r\r\n    <WakeToRun>false</WakeToRun>\r\r\n    <ExecutionTimeLimit>PT72H</ExecutionTimeLimit>\r\r\n<Priority>7</Priority>\r\r\n  </Settings>\r\r\n  <Actions Context=\"Author\">\r\r\n    <Exec>\r\r\n      <Command>chef-client</Command>\r\r\n    </Exec>\r\r\n  </Actions>\r\r\n</Task>"
+  end
+
+  describe "#load_current_resource" do
+    it "returns a current_resource" do
+      allow(provider).to receive(:load_task_hash)
+      expect(provider.load_current_resource).to be_kind_of(Chef::Resource::WindowsTask)
+    end
+
+    context "if the given task name already exists" do
+      before do
+        allow(provider).to receive(:load_task_hash).and_return({ :TaskName => "\\sample_task" })
+      end
+
+      it "calls set_current_resource" do
+        expect(provider).to receive(:set_current_resource)
+        provider.load_current_resource
+      end
+    end
+
+    it "sets the attributes of current_resource" 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.user).to eq("SYSTEM")
+      expect(current_resource.run_level).to eq(:highest)
+      expect(current_resource.frequency).to eq(:minute)
+      expect(current_resource.frequency_modifier).to eq(15)
+      expect(current_resource.execution_time_limit).to eq("PT72H")
+      expect(current_resource.enabled).to be(true)
+    end
+  end
+
+  describe "#action_create" do
+    it "doesn't create the same task if it's already existing" do
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      allow(provider).to receive(:task_need_update?).and_return(false)
+      provider.run_action(:create)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+
+    context "when task is not existing" do
+      before do
+        allow(provider).to receive(:load_task_hash)
+        provider.load_current_resource
+      end
+
+      it "creates the task if it's not already existing" do
+        allow(provider).to receive(:task_need_update?).and_return(true)
+        expect(provider).to receive(:run_schtasks).with("CREATE", { "F" => "", "SC" => :hourly, "MO" => 1, "TR" => nil, "RU" => "SYSTEM" })
+        provider.run_action(:create)
+        expect(new_resource).to be_updated_by_last_action
+      end
+
+      it "updates the task XML if random_delay is provided" do
+        new_resource.random_delay "20"
+        allow(provider).to receive(:task_need_update?).and_return(true)
+        expect(provider).to receive(:run_schtasks).with("CREATE", { "F" => "", "SC" => :hourly, "MO" => 1, "TR" => nil, "RU" => "SYSTEM" })
+        expect(provider).to receive(:update_task_xml)
+        provider.run_action(:create)
+        expect(new_resource).to be_updated_by_last_action
+      end
+
+      it "updates the task XML if execution_time_limit is provided" do
+        new_resource.execution_time_limit "20"
+        allow(provider).to receive(:task_need_update?).and_return(true)
+        expect(provider).to receive(:run_schtasks).with("CREATE", { "F" => "", "SC" => :hourly, "MO" => 1, "TR" => nil, "RU" => "SYSTEM" })
+        expect(provider).to receive(:update_task_xml)
+        provider.run_action(:create)
+        expect(new_resource).to be_updated_by_last_action
+      end
+    end
+  end
+
+  describe "#action_run" do
+    it "does nothing if the task doesn't exist" do
+      allow(provider).to receive(:load_task_hash)
+      provider.load_current_resource
+      provider.run_action(:run)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+
+    context "when the task exists" do
+      it "does nothing if the task is already running" do
+        task_hash[:Status] = "Running"
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+        provider.run_action(:run)
+        expect(new_resource).not_to be_updated_by_last_action
+      end
+
+      it "runs the task" do
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+        expect(provider).to receive(:run_schtasks).with("RUN")
+        provider.run_action(:run)
+        expect(new_resource).to be_updated_by_last_action
+      end
+    end
+  end
+
+  describe "#action_delete" do
+    it "deletes the task if it exists" do
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      provider.load_current_resource
+      expect(provider).to receive(:run_schtasks).with("DELETE", { "F" => "" })
+      provider.run_action(:delete)
+      expect(new_resource).to be_updated_by_last_action
+    end
+
+    it "does nothing if the task doesn't exist" do
+      allow(provider).to receive(:load_task_hash)
+      provider.load_current_resource
+      provider.run_action(:delete)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+  end
+
+  describe "#action_end" do
+    it "does nothing if the task doesn't exist" do
+      allow(provider).to receive(:load_task_hash)
+      provider.load_current_resource
+      provider.run_action(:end)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+
+    context "when the task exists" do
+      it "does nothing if the task is not running" do
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+        provider.run_action(:end)
+        expect(new_resource).not_to be_updated_by_last_action
+      end
+
+      it "ends the task if it's running" do
+        task_hash[:Status] = "Running"
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+        expect(provider).to receive(:run_schtasks).with("END")
+        provider.run_action(:end)
+        expect(new_resource).to be_updated_by_last_action
+      end
+    end
+  end
+
+  describe "#action_enable" do
+    it "raises error if the task doesn't exist" do
+      allow(provider).to receive(:load_task_hash)
+      provider.load_current_resource
+      expect { provider.run_action(:enable) }.to raise_error(Errno::ENOENT)
+    end
+
+    context "when the task exists" do
+      it "does nothing if the task is already enabled" do
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+        provider.run_action(:enable)
+        expect(new_resource).not_to be_updated_by_last_action
+      end
+
+      it "enables the task if it exists" do
+        task_hash[:ScheduledTaskState] = "Disabled"
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+        expect(provider).to receive(:run_schtasks).with("CHANGE", { "ENABLE" => "" })
+        provider.run_action(:enable)
+        expect(new_resource).to be_updated_by_last_action
+      end
+    end
+  end
+
+  describe "#action_disable" do
+    it "does nothing if the task doesn't exist" do
+      allow(provider).to receive(:load_task_hash)
+      provider.load_current_resource
+      provider.run_action(:disable)
+      expect(new_resource).not_to be_updated_by_last_action
+    end
+
+    context "when the task exists" do
+      it "disables the task if it's enabled" do
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+        expect(provider).to receive(:run_schtasks).with("CHANGE", { "DISABLE" => "" })
+        provider.run_action(:disable)
+        expect(new_resource).to be_updated_by_last_action
+      end
+
+      it "does nothing if the task is already disabled" do
+        task_hash[:ScheduledTaskState] = "Disabled"
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+        provider.run_action(:disable)
+        expect(new_resource).not_to be_updated_by_last_action
+      end
+    end
+  end
+
+  describe "#run_schtasks" 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\" "
+    end
+
+    it "forms the command properly from the given options" do
+      expect(provider).to receive(:shell_out!).with(@cmd, { :returns => [0] })
+      provider.send(:run_schtasks, @task_action, @options)
+    end
+  end
+
+  describe "#task_need_update?" do
+    context "when task doesn't exist" do
+      before do
+        allow(provider).to receive(:load_task_hash)
+        provider.load_current_resource
+      end
+
+      it "returns true" do
+        new_resource.command "chef-client"
+        expect(provider.send(:task_need_update?)).to be(true)
+      end
+    end
+
+    context "when the task exists" do
+      before do
+        allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        provider.load_current_resource
+
+        new_resource.command "chef-client"
+        new_resource.run_level :highest
+        new_resource.frequency :minute
+        new_resource.frequency_modifier 15
+        new_resource.user "SYSTEM"
+        new_resource.execution_time_limit "PT72H"
+      end
+
+      context "when no attributes are modified" do
+        it "returns false" do
+          expect(provider.send(:task_need_update?)).to be(false)
+        end
+      end
+
+      context "when frequency_modifier is updated" do
+        it "returns true" do
+          new_resource.frequency_modifier 25
+          expect(provider.send(:task_need_update?)).to be(true)
+        end
+      end
+
+      context "when months are updated" do
+        it "returns true" do
+          new_resource.months "JAN"
+          expect(provider.send(:task_need_update?)).to be(true)
+        end
+      end
+    end
+  end
+
+  describe "#update_task_xml" 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"
+      new_resource.random_delay "20"
+    end
+
+    it "does nothing if the task doesn't exist" do
+      task_xml = double("xml", :exitstatus => 1)
+      allow(provider).to receive(:powershell_out).and_return(task_xml)
+      output = provider.send(:update_task_xml, ["random_delay"])
+      expect(output).to be(nil)
+    end
+
+    it "updates the task XML if random_delay is passed" do
+      shell_out_obj = double("xml", :exitstatus => 0, :stdout => task_xml)
+      allow(provider).to receive(:powershell_out).and_return(shell_out_obj)
+      expect(::File).to receive(:join)
+      expect(::File).to receive(:open)
+      expect(::File).to receive(:delete)
+      expect(provider).to receive(:run_schtasks).twice
+      output = provider.send(:update_task_xml, ["random_delay"])
+    end
+  end
+
+  describe "#load_task_hash" do
+    it "returns false if the task doesn't exist" do
+      allow(provider).to receive_message_chain(:powershell_out, :stdout, :force_encoding).and_return("")
+      allow(provider).to receive(:load_task_xml)
+      expect(provider.send(:load_task_hash, "chef-client")).to be(false)
+    end
+
+    it "returns task hash if the task exists" do
+      powershell_output = "\r\nFolder: \\\r\nHostName:                             NIMISHA-PC\r\nTaskName:                             \\chef-client\r\n"
+      task_h = { :"" => "", :Folder => "\\", :HostName => "NIMISHA-PC", :TaskName => "\\chef-client" }
+      allow(provider).to receive_message_chain(:powershell_out, :stdout, :force_encoding).and_return(powershell_output)
+      allow(provider).to receive(:load_task_xml).with("chef-client")
+      expect(provider.send(:load_task_hash, "chef-client")).to eq(task_h)
+    end
+  end
+
+  describe "#frequency_modifier_allowed" do
+    it "returns true for frequency :hourly" do
+      new_resource.frequency :hourly
+      expect(provider.send(:frequency_modifier_allowed)).to be(true)
+    end
+
+    it "returns true for frequency :monthly if frequency_modifier is THIRD" do
+      new_resource.frequency :monthly
+      new_resource.frequency_modifier "THIRD"
+      expect(provider.send(:frequency_modifier_allowed)).to be(true)
+    end
+
+    it "returns false for frequency :once" do
+      new_resource.frequency :once
+      expect(provider.send(:frequency_modifier_allowed)).to be(false)
+    end
+  end
+end