chef 13.4.19 → 13.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 103c769a6347776d48577798e5e82271b9f9b082
-  data.tar.gz: cfc8564484b034b788fbc8307f322c1acd3d61a9
+  metadata.gz: 2b099115d6c801f6af5fd5b426ce8b197b80dd4a
+  data.tar.gz: a3321cbe79f0be926034983c3c02ed6feea2712b
 SHA512:
-  metadata.gz: a0b57f2f5e07eefa55e3510688b18a31bbb40dd2395b96cceb299a69fc8f434843afe64a4bea04eee8fe403e38a248a97b9504797ec10c2397ad46654e3143bf
-  data.tar.gz: 60446f65bc583b79e4a490cea2da2a221769aaae9d6c14298808970a44ff2a3c11f6fffaafc65760e16e59fb4d09af6e8f9d20955d8271ffcf35842ad0330c98
+  metadata.gz: 492210b4a982af74a5524870fe85d3abfa0db2d791c6b1b73fde75b4cd7caab656838af3f49b33eb6a9c0a3d9a25b1da4d5436474bdf0556e3fdafa1acc2ce17
+  data.tar.gz: a941cb6b0bfb2ae86de6633c258d3d5e684daf1ac1ac913e2f118fa4db16fc3a47dd8af62541c98c89f92d36e8bec78bb325f326cb38742dbfed5785d8cc119b

data/VERSION

@@ -1 +1 @@
-13.4.19
+13.4.24

data/lib/chef/provider/package.rb

@@ -311,18 +311,19 @@ class Chef
       #
       # This MUST have 'equality' semantics -- the exact thing matches the exact thing.
       #
-      # The current_version should probably be dropped out of the method signature, it should
-      # always be the first argument.
-      #
       # The name is not just bad, but i find it completely misleading, consider:
       #
       #    target_version_already_installed?(current_version, new_version)
       #    target_version_already_installed?(current_version, candidate_version)
       #
-      # which of those is the 'target_version'?  i'd say the new_version and i'm confused when
+      # Which of those is the 'target_version'?  I'd say the new_version and I'm confused when
       # i see it called with the candidate_version.
       #
-      # `current_version_equals?(version)` would be a better name
+      # `version_equals?(v1, v2)` would be a better name.
+      #
+      # Note that most likely we need a spaceship operator on versions that subclasses can implement
+      # and we should have `version_compare(v1, v2)` that returns `v1 <=> v2`.
+      #
       def target_version_already_installed?(current_version, target_version)
         return false unless current_version && target_version
         current_version == target_version
@@ -333,10 +334,8 @@ class Chef
       #
       # Subclasses MAY override this to provide fuzzy matching on the resource ('>=' and '~>' stuff)
       #
-      # This should only ever be offered the same arguments (so they should most likely be
-      # removed from the method signature).
+      # `version_satisfied_by?(version, constraint)` might be a better name to make this generic.
       #
-      # `new_version_satisfied?()` might be a better name
       def version_requirement_satisfied?(current_version, new_version)
         target_version_already_installed?(current_version, new_version)
       end

data/lib/chef/provider/route.rb

@@ -86,7 +86,9 @@ class Chef
         self.is_running = false
 
         # cidr or quad dot mask
-        new_ip = if new_resource.netmask
+        new_ip = if new_resource.target == "default"
+                   IPAddr.new(new_resource.gateway)
+                 elsif new_resource.netmask
                    IPAddr.new("#{new_resource.target}/#{new_resource.netmask}")
                  else
                    IPAddr.new(new_resource.target)
@@ -180,12 +182,29 @@ class Chef
             end
           end
           conf.each do |k, v|
-            network_file_name = "/etc/sysconfig/network-scripts/route-#{k}"
-            converge_by("write route route.#{k}\n#{conf[k]} to #{network_file_name}") do
-              network_file = ::File.new(network_file_name, "w")
-              network_file.puts(conf[k])
-              Chef::Log.debug("#{new_resource} writing route.#{k}\n#{conf[k]}")
-              network_file.close
+            if new_resource.target == "default"
+              network_file_name = "/etc/sysconfig/network"
+              converge_by("write route default route to #{network_file_name}") do
+                Chef::Log.debug("#{new_resource} writing default route #{new_resource.gateway} to #{network_file_name}")
+                if ::File.exists?(network_file_name)
+                  network_file = ::Chef::Util::FileEdit.new(network_file_name)
+                  network_file.search_file_replace_line /^GATEWAY=/, "GATEWAY=#{new_resource.gateway}"
+                  network_file.insert_line_if_no_match /^GATEWAY=/, "GATEWAY=#{new_resource.gateway}"
+                  network_file.write_file
+                else
+                  network_file = ::File.new(network_file_name, "w")
+                  network_file.puts("GATEWAY=#{new_resource.gateway}")
+                  network_file.close
+                end
+              end
+            else
+              network_file_name = "/etc/sysconfig/network-scripts/route-#{k}"
+              converge_by("write route route.#{k}\n#{conf[k]} to #{network_file_name}") do
+                network_file = ::File.new(network_file_name, "w")
+                network_file.puts(conf[k])
+                Chef::Log.debug("#{new_resource} writing route.#{k}\n#{conf[k]}")
+                network_file.close
+              end
             end
           end
         end

data/lib/chef/provider/windows_task.rb

@@ -7,7 +7,7 @@
 # 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
+#    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,
@@ -30,30 +30,33 @@ class Chef
       provides :windows_task, os: "windows"
 
       def load_current_resource
-        @current_resource = Chef::Resource::WindowsTask.new(new_resource.name)
+        self.current_resource = Chef::Resource::WindowsTask.new(new_resource.name)
         pathed_task_name = new_resource.task_name.start_with?('\\') ? new_resource.task_name : "\\#{new_resource.task_name}"
 
-        @current_resource.task_name(pathed_task_name)
+        current_resource.task_name(pathed_task_name)
         task_hash = load_task_hash(pathed_task_name)
 
         set_current_resource(task_hash) if task_hash.respond_to?(:[]) && task_hash[:TaskName] == pathed_task_name
-        @current_resource
+        current_resource
       end
 
       def set_current_resource(task_hash)
-        @current_resource.exists = true
-        @current_resource.command(task_hash[:TaskToRun])
-        @current_resource.cwd(task_hash[:StartIn]) unless task_hash[:StartIn] == "N/A"
-        @current_resource.user(task_hash[:RunAsUser])
+        current_resource.exists = true
+        current_resource.command(task_hash[:TaskToRun])
+        current_resource.cwd(task_hash[:StartIn]) unless task_hash[:StartIn] == "N/A"
+        current_resource.user(task_hash[:RunAsUser])
         set_current_run_level task_hash[:run_level]
         set_current_frequency task_hash
-        @current_resource.day(task_hash[:day]) if task_hash[:day]
-        @current_resource.months(task_hash[:months]) if task_hash[:months]
+        current_resource.day(task_hash[:day]) if task_hash[:day]
+        current_resource.months(task_hash[:months]) if task_hash[:months]
         set_current_idle_time(task_hash[:idle_time]) if task_hash[:idle_time]
-        @current_resource.random_delay(task_hash[:random_delay]) if task_hash[:random_delay]
-        @current_resource.execution_time_limit(task_hash[:execution_time_limit]) if task_hash[:execution_time_limit]
-        @current_resource.status = :running if task_hash[:Status] == "Running"
-        @current_resource.enabled = true if task_hash[:ScheduledTaskState] == "Enabled"
+        current_resource.random_delay(task_hash[:random_delay]) if task_hash[:random_delay]
+        # schtask sets execution_time_limit as PT72H by default
+        current_resource.execution_time_limit(task_hash[:execution_time_limit] || "PT72H")
+        current_resource.status = :running if task_hash[:Status] == "Running"
+        current_resource.enabled = true if task_hash[:ScheduledTaskState] == "Enabled"
+        current_resource.start_time = task_hash[:StartTime] if task_hash[:StartTime]
+        current_resource.start_day = task_hash[:StartDate] if task_hash[:StartDate]
       end
 
       # This method checks if task and command attributes exist since those two are mandatory attributes to create a schedules task.
@@ -71,7 +74,7 @@ class Chef
       end
 
       def action_create
-        if @current_resource.exists
+        if current_resource.exists
           if !(task_need_update? || new_resource.force)
             Chef::Log.info "#{new_resource} task already exists - nothing to do"
             return
@@ -79,7 +82,7 @@ class Chef
           # To merge current resource and new resource attributes
           resource_attributes.each do |attribute|
             new_resource_attribute = new_resource.send(attribute)
-            current_resource_attribute = @current_resource.send(attribute)
+            current_resource_attribute = current_resource.send(attribute)
             new_resource.send("#{attribute}=", current_resource_attribute ) if current_resource_attribute && new_resource_attribute.nil?
           end
         end
@@ -89,7 +92,7 @@ class Chef
         options["SC"] = schedule
         options["MO"] = new_resource.frequency_modifier if frequency_modifier_allowed
         options["I"]  = new_resource.idle_time unless new_resource.idle_time.nil?
-        options["SD"] = new_resource.start_day unless new_resource.start_day.nil?
+        options["SD"] = convert_user_date_to_system_date new_resource.start_day unless new_resource.start_day.nil?
         options["ST"] = new_resource.start_time unless new_resource.start_time.nil?
         options["TR"] = new_resource.command
         options["RU"] = new_resource.user
@@ -110,8 +113,8 @@ class Chef
       end
 
       def action_run
-        if @current_resource.exists
-          if @current_resource.status == :running
+        if current_resource.exists
+          if current_resource.status == :running
             Chef::Log.info "#{new_resource} task is currently running, skipping run"
           else
             run_schtasks "RUN"
@@ -124,7 +127,7 @@ class Chef
       end
 
       def action_delete
-        if @current_resource.exists
+        if current_resource.exists
           # always need to force deletion
           run_schtasks "DELETE", "F" => ""
           new_resource.updated_by_last_action true
@@ -135,8 +138,8 @@ class Chef
       end
 
       def action_end
-        if @current_resource.exists
-          if @current_resource.status != :running
+        if current_resource.exists
+          if current_resource.status != :running
             Chef::Log.debug "#{new_resource} is not running - nothing to do"
           else
             run_schtasks "END"
@@ -149,8 +152,8 @@ class Chef
       end
 
       def action_enable
-        if @current_resource.exists
-          if @current_resource.enabled
+        if current_resource.exists
+          if current_resource.enabled
             Chef::Log.debug "#{new_resource} already enabled - nothing to do"
           else
             run_schtasks "CHANGE", "ENABLE" => ""
@@ -164,8 +167,8 @@ class Chef
       end
 
       def action_disable
-        if @current_resource.exists
-          if @current_resource.enabled
+        if current_resource.exists
+          if current_resource.enabled
             run_schtasks "CHANGE", "DISABLE" => ""
             new_resource.updated_by_last_action true
             Chef::Log.info "#{new_resource} task disabled"
@@ -194,19 +197,20 @@ class Chef
 
       def task_need_update?
         return true if (new_resource.command &&
-            @current_resource.command != new_resource.command.tr("'", '"')) ||
-            @current_resource.user != new_resource.user ||
-            @current_resource.run_level != new_resource.run_level ||
-            @current_resource.cwd != new_resource.cwd ||
-            @current_resource.frequency_modifier != new_resource.frequency_modifier ||
-            @current_resource.frequency != new_resource.frequency ||
-            @current_resource.idle_time != new_resource.idle_time ||
-            @current_resource.random_delay != new_resource.random_delay ||
-            @current_resource.execution_time_limit != new_resource.execution_time_limit ||
-            !new_resource.start_day.nil? || !new_resource.start_time.nil?
+            current_resource.command != new_resource.command.tr("'", '"')) ||
+            current_resource.user != new_resource.user ||
+            current_resource.run_level != new_resource.run_level ||
+            current_resource.cwd != new_resource.cwd ||
+            current_resource.frequency_modifier != new_resource.frequency_modifier ||
+            current_resource.frequency != new_resource.frequency ||
+            current_resource.idle_time != new_resource.idle_time ||
+            current_resource.random_delay != new_resource.random_delay ||
+            !new_resource.execution_time_limit.include?(current_resource.execution_time_limit) ||
+            (new_resource.start_day && start_day_updated?) ||
+            (new_resource.start_time && start_time_updated?)
         begin
-          return true if new_resource.day.to_s.casecmp(@current_resource.day.to_s) != 0 ||
-              new_resource.months.to_s.casecmp(@current_resource.months.to_s) != 0
+          return true if new_resource.day.to_s.casecmp(current_resource.day.to_s) != 0 ||
+              new_resource.months.to_s.casecmp(current_resource.months.to_s) != 0
         rescue
           Chef::Log.debug "caught a raise in task_needs_update?"
         end
@@ -214,6 +218,56 @@ class Chef
         false
       end
 
+      def start_day_updated?
+        current_day = DateTime.strptime(current_resource.start_day, convert_system_date_format_to_ruby_date_format)
+        new_day = DateTime.parse(new_resource.start_day)
+        current_day != new_day
+      end
+
+      def start_time_updated?
+        time = DateTime.parse(current_resource.start_time).strftime("%H:%M")
+        time != new_resource.start_time
+      end
+
+      def convert_user_date_to_system_date(date_in_string)
+        DateTime.parse(date_in_string).strftime(convert_system_date_format_to_ruby_long_date)
+      end
+
+      def convert_system_date_format_to_ruby_long_date
+        date_format = get_system_short_date_format.dup
+        date_format.sub!("MMM", "%m")
+        common_date_format_conversion(date_format)
+        date_format.sub!("yy", "%Y")
+        date_format
+      end
+
+      def convert_system_date_format_to_ruby_date_format
+        date_format = get_system_short_date_format.dup
+        date_format.sub!("MMM", "%b")
+        common_date_format_conversion(date_format)
+        date_format.sub!("yy", "%y")
+        date_format
+      end
+
+      def common_date_format_conversion(date_format)
+        date_format.sub!("dd", "d")
+        date_format.sub!("d", "%d")
+        date_format.sub!("MM", "%m")
+        date_format.sub!("M", "%m")
+        date_format.sub!("yyyy", "%Y")
+      end
+
+      def get_system_short_date_format
+        return @system_short_date_format if @system_short_date_format
+        Chef::Log.debug "Finding system date format"
+        task_script = <<-EOH
+          [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
+          [Globalization.Cultureinfo]::CurrentCulture.DateTimeFormat.ShortDatePattern
+        EOH
+        @system_short_date_format = powershell_out(task_script).stdout.force_encoding("UTF-8").gsub(/[\s+\uFEFF]/, "")
+        @system_short_date_format
+      end
+
       def update_task_xml(options = [])
         # random_delay xml element is different for different frequencies
         random_delay_xml_element = {
@@ -394,9 +448,9 @@ class Chef
       def set_current_run_level(run_level)
         case run_level
         when "HighestAvailable"
-          @current_resource.run_level(:highest)
+          current_resource.run_level(:highest)
         when "LeastPrivilege"
-          @current_resource.run_level(:limited)
+          current_resource.run_level(:limited)
         end
       end
 
@@ -404,34 +458,34 @@ class Chef
         if task_hash[:repetition_interval]
           duration = ISO8601::Duration.new(task_hash[:repetition_interval])
           if task_hash[:repetition_interval].include?("M")
-            @current_resource.frequency(:minute)
-            @current_resource.frequency_modifier(duration.minutes.atom.to_i)
+            current_resource.frequency(:minute)
+            current_resource.frequency_modifier(duration.minutes.atom.to_i)
           elsif task_hash[:repetition_interval].include?("H")
-            @current_resource.frequency(:hourly)
-            @current_resource.frequency_modifier(duration.hours.atom.to_i)
+            current_resource.frequency(:hourly)
+            current_resource.frequency_modifier(duration.hours.atom.to_i)
           end
         end
 
         if task_hash[:schedule_by_day]
-          @current_resource.frequency(:daily)
-          @current_resource.frequency_modifier(task_hash[:schedule_by_day].to_i)
+          current_resource.frequency(:daily)
+          current_resource.frequency_modifier(task_hash[:schedule_by_day].to_i)
         end
 
         if task_hash[:schedule_by_week]
-          @current_resource.frequency(:weekly)
-          @current_resource.frequency_modifier(task_hash[:schedule_by_week].to_i)
+          current_resource.frequency(:weekly)
+          current_resource.frequency_modifier(task_hash[:schedule_by_week].to_i)
         end
 
-        @current_resource.frequency(:monthly) if task_hash[:schedule_by_month]
-        @current_resource.frequency(:on_logon) if task_hash[:on_logon]
-        @current_resource.frequency(:onstart) if task_hash[:onstart]
-        @current_resource.frequency(:on_idle) if task_hash[:on_idle]
-        @current_resource.frequency(:once) if task_hash[:once]
+        current_resource.frequency(:monthly) if task_hash[:schedule_by_month]
+        current_resource.frequency(:on_logon) if task_hash[:on_logon]
+        current_resource.frequency(:onstart) if task_hash[:onstart]
+        current_resource.frequency(:on_idle) if task_hash[:on_idle]
+        current_resource.frequency(:once) if task_hash[:once]
       end
 
       def set_current_idle_time(idle_time)
         duration = ISO8601::Duration.new(idle_time)
-        @current_resource.idle_time(duration.minutes.atom.to_i)
+        current_resource.idle_time(duration.minutes.atom.to_i)
       end
 
     end

data/lib/chef/util/dsc/local_configuration_manager.rb

@@ -47,15 +47,13 @@ class Chef::Util::DSC
 
     def run_configuration_cmdlet(configuration_document, apply_configuration, shellout_flags)
       Chef::Log.debug("DSC: Calling DSC Local Config Manager to #{apply_configuration ? "set" : "test"} configuration document.")
-      test_only_parameters = ! apply_configuration ? "-whatif; if (! $?) { exit 1 }" : ""
 
       start_operation_timing
-      command_code = lcm_command_code(@configuration_path, test_only_parameters)
       status = nil
 
       begin
         save_configuration_document(configuration_document)
-        cmdlet = ::Chef::Util::Powershell::Cmdlet.new(@node, "#{command_code}")
+        cmdlet = ::Chef::Util::Powershell::Cmdlet.new(@node, lcm_command(apply_configuration))
         if apply_configuration
           status = cmdlet.run!({}, shellout_flags)
         else
@@ -72,10 +70,22 @@ class Chef::Util::DSC
       status
     end
 
-    def lcm_command_code(configuration_path, test_only_parameters)
-      <<-EOH
-$ProgressPreference = 'SilentlyContinue';start-dscconfiguration -path #{@configuration_path} -wait -erroraction 'stop' -force #{test_only_parameters}
-EOH
+    def lcm_command(apply_configuration)
+      common_command_prefix = "$ProgressPreference = 'SilentlyContinue';"
+      ps4_base_command = "#{common_command_prefix} Start-DscConfiguration -path #{@configuration_path} -wait -erroraction 'stop' -force"
+      if apply_configuration
+        ps4_base_command
+      else
+        if ps_version_gte_5?
+          "#{common_command_prefix} Test-DscConfiguration -path #{@configuration_path}"
+        else
+          ps4_base_command + " -whatif; if (! $?) { exit 1 }"
+        end
+      end
+    end
+
+    def ps_version_gte_5?
+      Chef::Platform.supported_powershell_version?(@node, 5)
     end
 
     def log_what_if_exception(what_if_exception_output)

data/lib/chef/version.rb

@@ -23,7 +23,7 @@ require "chef/version_string"
 
 class Chef
   CHEF_ROOT = File.expand_path("../..", __FILE__)
-  VERSION = Chef::VersionString.new("13.4.19")
+  VERSION = Chef::VersionString.new("13.4.24")
 end
 
 #

data/spec/unit/provider/route_spec.rb

@@ -29,9 +29,14 @@ describe Chef::Provider::Route do
     @new_resource.gateway "10.0.0.9"
     @current_resource = Chef::Resource::Route.new("10.0.0.10")
     @current_resource.gateway "10.0.0.9"
+    @default_resource = Chef::Resource::Route.new("default")
+    @default_resource.gateway "10.0.0.9"
 
     @provider = Chef::Provider::Route.new(@new_resource, @run_context)
     @provider.current_resource = @current_resource
+
+    @default_provider = Chef::Provider::Route.new(@default_resource, @run_context)
+    @default_provider.current_resource = @default_resource
   end
 
   describe Chef::Provider::Route, "hex2ip" do
@@ -161,6 +166,11 @@ describe Chef::Provider::Route do
       @new_resource.gateway(nil)
       expect(@provider.generate_command(:add).join(" ")).not_to match(/\svia\s#{Regexp.escape(@new_resource.gateway.to_s)}/)
     end
+
+    it "should use the gatway when target is default" do
+      @default_resource.gateway("10.0.0.10")
+      expect(@default_provider.generate_command(:add).join(" ")).to match(/10.0.0.10/)
+    end
   end
 
   describe Chef::Provider::Route, "generate_command for action_delete" do
@@ -216,10 +226,20 @@ describe Chef::Provider::Route do
 
         route_file = StringIO.new
         expect(File).to receive(:new).with("/etc/sysconfig/network-scripts/route-eth0", "w").and_return(route_file)
-        # Chef::Log.should_receive(:debug).with("route[10.0.0.10] writing route.eth0\n10.0.0.10 via 10.0.0.9\n")
         @run_context.resource_collection << @new_resource
         @provider.generate_config
       end
+
+    end
+    %w{ centos redhat fedora }.each do |platform|
+      it "should write a default route file on #{platform} platform" do
+        @node.automatic_attrs[:platform] = platform
+
+        route_file = StringIO.new
+        expect(File).to receive(:new).with("/etc/sysconfig/network", "w").and_return(route_file)
+        @run_context.resource_collection << @default_resource
+        @default_provider.generate_config
+      end
     end
 
     it "should put all routes for a device in a route config file" do

data/spec/unit/provider/windows_task_spec.rb

@@ -322,6 +322,7 @@ describe Chef::Provider::WindowsTask do
     context "when the task exists" do
       before do
         allow(provider).to receive(:load_task_hash).and_return(task_hash)
+        allow(provider).to receive(:get_system_short_date_format).and_return("MM/dd/yyyy")
         provider.load_current_resource
 
         new_resource.command "chef-client"
@@ -330,6 +331,8 @@ describe Chef::Provider::WindowsTask do
         new_resource.frequency_modifier 15
         new_resource.user "SYSTEM"
         new_resource.execution_time_limit "PT72H"
+        new_resource.start_day "30-Mar-2017"
+        new_resource.start_time "13:12"
       end
 
       context "when no attributes are modified" do
@@ -368,6 +371,116 @@ describe Chef::Provider::WindowsTask do
     end
   end
 
+  describe "#start_day_updated?" do
+    before do
+      allow(provider).to receive(:load_task_hash).and_return(task_hash)
+      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.run_level :highest
+      new_resource.frequency :minute
+      new_resource.frequency_modifier 15
+      new_resource.user "SYSTEM"
+      new_resource.execution_time_limit "PT72H"
+      new_resource.start_day "30-Mar-2017"
+      new_resource.start_time "13:12"
+    end
+    context "when start_day not changed" do
+      it "returns false" do
+        expect(provider.send(:start_day_updated?)).to be(false)
+      end
+    end
+
+    context "when start_day changed" do
+      it "returns true" do
+        new_resource.start_day "01/01/2000"
+        expect(provider.send(:start_day_updated?)).to be(true)
+      end
+    end
+  end
+
+  describe "#start_time_updated?" 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"
+      new_resource.start_day "3/30/2017"
+      new_resource.start_time "13:12"
+    end
+    context "when start_time not changed" do
+      it "returns false" do
+        expect(provider.send(:start_time_updated?)).to be(false)
+      end
+    end
+
+    context "when start_time changed" do
+      it "returns true" do
+        new_resource.start_time "01:01"
+        expect(provider.send(:start_time_updated?)).to be(true)
+      end
+    end
+  end
+
+  describe "#convert_user_date_to_system_date" do
+    it "when current resource start date is '30-May-2017' then returns '05/30/2017'" do
+      allow(provider).to receive(:get_system_short_date_format).and_return("MM/dd/yyyy")
+      expect(provider.send(:convert_user_date_to_system_date, "30-May-2017")).to eq("05/30/2017")
+    end
+  end
+
+  describe "#convert_system_date_format_to_ruby_date_format" do
+    context "when system date format 'dd-MMM-yy'" do
+      it "returns '%d-%b-%y'" do
+        allow(provider).to receive(:get_system_short_date_format).and_return("dd-MMM-yy")
+        expect(provider.send(:convert_system_date_format_to_ruby_date_format)).to eq("%d-%b-%y")
+      end
+    end
+
+    context "when system date format 'dd/MM/yyyy'" do
+      it "returns '%d/%m/%Y'" do
+        allow(provider).to receive(:get_system_short_date_format).and_return("dd/MM/yyyy")
+        expect(provider.send(:convert_system_date_format_to_ruby_date_format)).to eq("%d/%m/%Y")
+      end
+    end
+  end
+
+  describe "#convert_system_date_format_to_ruby_long_date" do
+    context "when system date format 'dd-MMM-yy'" do
+      it "returns '%d-%m-%Y'" do
+        allow(provider).to receive(:get_system_short_date_format).and_return("dd-MMM-yy")
+        expect(provider.send(:convert_system_date_format_to_ruby_long_date)).to eq("%d-%m-%Y")
+      end
+    end
+
+    context "when system date format 'dd/MM/yyyy'" do
+      it "returns '%d/%m/%Y'" do
+        allow(provider).to receive(:get_system_short_date_format).and_return("dd/MM/yyyy")
+        expect(provider.send(:convert_system_date_format_to_ruby_long_date)).to eq("%d/%m/%Y")
+      end
+    end
+  end
+
+  describe "#common_date_format_conversion" do
+    context "when system date format 'dd-MM-yyyy'" do
+      it "returns '%d-%m-%Y'" do
+        expect(provider.send(:common_date_format_conversion, "dd-MM-yyyy")).to eq("%d-%m-%Y")
+      end
+    end
+
+    context "when system date format 'd-M-yyyy'" do
+      it "returns '%d-%m-%Y'" do
+        expect(provider.send(:common_date_format_conversion, "dd-MM-yyyy")).to eq("%d-%m-%Y")
+      end
+    end
+  end
+
   describe "#update_task_xml" do
     before do
       new_resource.command "chef-client"

data/spec/unit/util/dsc/local_configuration_manager_spec.rb

@@ -63,7 +63,7 @@ EOH
         let(:lcm_standard_error) { nil }
         let(:lcm_cmdlet_success) { true }
 
-        it "should successfully return resource information for normally formatted output when cmdlet the cmdlet succeeds" do
+        it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
           test_configuration_result = lcm.test_configuration("config", {})
           expect(test_configuration_result.class).to be(Array)
           expect(test_configuration_result.length).to be > 0
@@ -71,6 +71,58 @@ EOH
         end
       end
 
+      context "when running on PowerShell version 5" do
+        let(:lcm_standard_output) { normal_lcm_output }
+        let(:lcm_standard_error) { nil }
+        let(:lcm_cmdlet_success) { true }
+
+        it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
+          allow(lcm).to receive(:ps_version_gte_5?).and_return(true)
+          test_configuration_result = lcm.test_configuration("config", {})
+          expect(test_configuration_result.class).to be(Array)
+          expect(test_configuration_result.length).to be > 0
+          expect(Chef::Log).not_to receive(:warn)
+        end
+      end
+
+      context "when running on PowerShell version less than 5" do
+        let(:lcm_standard_output) { normal_lcm_output }
+        let(:lcm_standard_error) { nil }
+        let(:lcm_cmdlet_success) { true }
+
+        it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
+          allow(lcm).to receive(:ps_version_gte_5?).and_return(false)
+          test_configuration_result = lcm.test_configuration("config", {})
+          expect(test_configuration_result.class).to be(Array)
+          expect(test_configuration_result.length).to be > 0
+          expect(Chef::Log).not_to receive(:warn)
+        end
+      end
+
+      context "#lcm_command" do
+        let(:common_command_prefix) { "$ProgressPreference = 'SilentlyContinue';" }
+        let(:ps4_base_command) { "#{common_command_prefix} Start-DscConfiguration -path tmp -wait -erroraction 'stop' -force" }
+        let(:lcm_command_ps4) { ps4_base_command + " -whatif; if (! $?) { exit 1 }" }
+        let(:lcm_command_ps5) { "#{common_command_prefix} Test-DscConfiguration -path tmp" }
+        let(:lcm_standard_output) { normal_lcm_output }
+        let(:lcm_standard_error) { nil }
+        let(:lcm_cmdlet_success) { true }
+
+        it "successfully returns command when apply_configuration true" do
+          expect(lcm.send(:lcm_command, true)).to eq(ps4_base_command)
+        end
+
+        it "successfully returns command when PowerShell version 4" do
+          allow(lcm).to receive(:ps_version_gte_5?).and_return(false)
+          expect(lcm.send(:lcm_command, false)).to eq(lcm_command_ps4)
+        end
+
+        it "successfully returns command when PowerShell version 5" do
+          allow(lcm).to receive(:ps_version_gte_5?).and_return(true)
+          expect(lcm.send(:lcm_command, false)).to eq(lcm_command_ps5)
+        end
+      end
+
       context "that fails due to missing what-if switch in DSC resource cmdlet implementation" do
         let(:lcm_standard_output) { "" }
         let(:lcm_standard_error) { no_whatif_lcm_output }
@@ -80,7 +132,7 @@ EOH
           expect(lcm.send(:whatif_not_supported?, no_whatif_lcm_output)).to be_truthy
         end
 
-        it "should should return a (possibly empty) array of ResourceInfo instances" do
+        it "returns a (possibly empty) array of ResourceInfo instances" do
           expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:whatif_not_supported?).and_call_original
           test_configuration_result = nil
@@ -94,14 +146,14 @@ EOH
         let(:lcm_standard_error) { dsc_resource_import_failure_output }
         let(:lcm_cmdlet_success) { false }
 
-        it "should log a warning if the message is formatted as expected when a resource import failure occurs" do
+        it "logs a warning if the message is formatted as expected when a resource import failure occurs" do
           expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:dsc_module_import_failure?).and_call_original
           test_configuration_result = nil
           expect { test_configuration_result = lcm.test_configuration("config", {}) }.not_to raise_error
         end
 
-        it "should return a (possibly empty) array of ResourceInfo instances" do
+        it "returns a (possibly empty) array of ResourceInfo instances" do
           expect(Chef::Log).to receive(:warn).at_least(:once)
           test_configuration_result = nil
           expect { test_configuration_result = lcm.test_configuration("config", {}) }.not_to raise_error
@@ -114,7 +166,7 @@ EOH
         let(:lcm_standard_error) { "Abort, Retry, Fail?" }
         let(:lcm_cmdlet_success) { false }
 
-        it "should log a warning" do
+        it "logs a warning" do
           expect(Chef::Log).to receive(:warn).at_least(:once)
           expect(lcm).to receive(:dsc_module_import_failure?).and_call_original
           expect { lcm.test_configuration("config", {}) }.not_to raise_error
@@ -122,15 +174,15 @@ EOH
       end
     end
 
-    it "should identify a correctly formatted error message as a resource import failure" do
+    it "identify a correctly formatted error message as a resource import failure" do
       expect(lcm.send(:dsc_module_import_failure?, dsc_resource_import_failure_output)).to be(true)
     end
 
-    it "should not identify an incorrectly formatted error message as a resource import failure" do
+    it "does not identify an incorrectly formatted error message as a resource import failure" do
       expect(lcm.send(:dsc_module_import_failure?, dsc_resource_import_failure_output.gsub("module", "gibberish"))).to be(false)
     end
 
-    it "should not identify a message without a CimException reference as a resource import failure" do
+    it "does not identify a message without a CimException reference as a resource import failure" do
       expect(lcm.send(:dsc_module_import_failure?, dsc_resource_import_failure_output.gsub("CimException", "ArgumentException"))).to be(false)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef
 version: !ruby/object:Gem::Version
-  version: 13.4.19
+  version: 13.4.24
 platform: ruby
 authors:
 - Adam Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-11 00:00:00.000000000 Z
+date: 2017-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-config
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 13.4.19
+        version: 13.4.24
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 13.4.19
+        version: 13.4.24
 - !ruby/object:Gem::Dependency
   name: mixlib-cli
   requirement: !ruby/object:Gem::Requirement