chef 17.6.18-universal-mingw32 → 17.7.22-universal-mingw32

data/spec/functional/resource/registry_spec.rb

@@ -75,19 +75,19 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
   def create_deletable_keys
     # create them both 32-bit and 64-bit
     [ 0x0100, 0x0200 ].each do |flag|
-      hive_class.create(key_parent + '\Opscode', Win32::Registry::KEY_WRITE | flag)
-      hive_class.open(key_parent + '\Opscode', Win32::Registry::KEY_ALL_ACCESS | flag) do |reg|
+      hive_class.create(key_parent + "\\Opscode", Win32::Registry::KEY_WRITE | flag)
+      hive_class.open(key_parent + "\\Opscode", Win32::Registry::KEY_ALL_ACCESS | flag) do |reg|
         reg["Color", Win32::Registry::REG_SZ] = "Orange"
         reg.write("Opscode", Win32::Registry::REG_MULTI_SZ, %w{Seattle Washington})
         reg["AKA", Win32::Registry::REG_SZ] = "OC"
       end
-      hive_class.create(key_parent + '\ReportKey', Win32::Registry::KEY_WRITE | flag)
-      hive_class.open(key_parent + '\ReportKey', Win32::Registry::KEY_ALL_ACCESS | flag) do |reg|
+      hive_class.create(key_parent + "\\ReportKey", Win32::Registry::KEY_WRITE | flag)
+      hive_class.open(key_parent + "\\ReportKey", Win32::Registry::KEY_ALL_ACCESS | flag) do |reg|
         reg["ReportVal4", Win32::Registry::REG_SZ] = "report4"
         reg["ReportVal5", Win32::Registry::REG_SZ] = "report5"
       end
-      hive_class.create(key_parent + '\OpscodeWhyRun', Win32::Registry::KEY_WRITE | flag)
-      hive_class.open(key_parent + '\OpscodeWhyRun', Win32::Registry::KEY_ALL_ACCESS | flag) do |reg|
+      hive_class.create(key_parent + "\\OpscodeWhyRun", Win32::Registry::KEY_WRITE | flag)
+      hive_class.open(key_parent + "\\OpscodeWhyRun", Win32::Registry::KEY_ALL_ACCESS | flag) do |reg|
         reg["BriskWalk", Win32::Registry::REG_SZ] = "is good for health"
       end
     end
@@ -188,13 +188,13 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     it "creates subkey if parent exists" do
-      @new_resource.key(reg_child + '\OpscodeTest')
+      @new_resource.key(reg_child + "\\OpscodeTest")
       @new_resource.values([{ name: "Chef", type: :multi_string, data: %w{OpscodeOrange Rules} }])
       @new_resource.recursive(false)
       @new_resource.run_action(:create)
 
-      expect(@registry.key_exists?(reg_child + '\OpscodeTest')).to eq(true)
-      expect(@registry.value_exists?(reg_child + '\OpscodeTest', { name: "Chef", type: :multi_string, data: %w{OpscodeOrange Rules} })).to eq(true)
+      expect(@registry.key_exists?(reg_child + "\\OpscodeTest")).to eq(true)
+      expect(@registry.value_exists?(reg_child + "\\OpscodeTest", { name: "Chef", type: :multi_string, data: %w{OpscodeOrange Rules} })).to eq(true)
     end
 
     it "raises an error if action create and parent does not exist and recursive is set to false" do
@@ -258,20 +258,20 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
         @registry.architecture = :machine
       end
       it "creates a key in a 32-bit registry that is not viewable in 64-bit" do
-        @new_resource.key(reg_child + '\Atraxi' )
+        @new_resource.key(reg_child + "\\Atraxi" )
         @new_resource.values([{ name: "OC", type: :string, data: "Data" }])
         @new_resource.recursive(true)
         @new_resource.architecture(:i386)
         @new_resource.run_action(:create)
         @registry.architecture = :i386
-        expect(@registry.data_exists?(reg_child + '\Atraxi', { name: "OC", type: :string, data: "Data" })).to eq(true)
+        expect(@registry.data_exists?(reg_child + "\\Atraxi", { name: "OC", type: :string, data: "Data" })).to eq(true)
         @registry.architecture = :x86_64
-        expect(@registry.key_exists?(reg_child + '\Atraxi')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Atraxi")).to eq(false)
       end
     end
 
     it "prepares the reporting data for action :create" do
-      @new_resource.key(reg_child + '\Ood')
+      @new_resource.key(reg_child + "\\Ood")
       @new_resource.values([{ name: "ReportingVal1", type: :string, data: "report1" }, { name: "ReportingVal2", type: :string, data: "report2" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create)
@@ -280,7 +280,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
       expect(@report["action"]).to eq("end")
       expect(@report["resources"][0]["type"]).to eq("registry_key")
       expect(@report["resources"][0]["name"]).to eq(resource_name)
-      expect(@report["resources"][0]["id"]).to eq(reg_child + '\Ood')
+      expect(@report["resources"][0]["id"]).to eq(reg_child + "\\Ood")
       expect(@report["resources"][0]["after"][:values]).to eq([{ name: "ReportingVal1", type: :string, data: "report1" },
                                                            { name: "ReportingVal2", type: :string, data: "report2" }])
       expect(@report["resources"][0]["before"][:values]).to eq([])
@@ -295,48 +295,48 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
       end
 
       it "does not raise an exception if the keys do not exist but recursive is set to false" do
-        @new_resource.key(reg_child + '\Slitheen\Raxicoricofallapatorius')
+        @new_resource.key(reg_child + "\\Slitheen\\Raxicoricofallapatorius")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:create) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
-        expect(@registry.key_exists?(reg_child + '\Slitheen\Raxicoricofallapatorius')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Slitheen")).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Slitheen\\Raxicoricofallapatorius")).to eq(false)
       end
 
       it "does not create key if the action is create" do
-        @new_resource.key(reg_child + '\Slitheen')
+        @new_resource.key(reg_child + "\\Slitheen")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:create)
-        expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Slitheen")).to eq(false)
       end
 
       it "does not raise an exception if the action create and type key missing in values hash" do
-        @new_resource.key(reg_child + '\Slitheen')
+        @new_resource.key(reg_child + "\\Slitheen")
         @new_resource.values([{ name: "BriskWalk", data: "my_data" }])
         @new_resource.run_action(:create) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Slitheen")).to eq(false)
       end
 
       it "does not raise an exception if the action create and data key missing in values hash" do
-        @new_resource.key(reg_child + '\Slitheen')
+        @new_resource.key(reg_child + "\\Slitheen")
         @new_resource.values([{ name: "BriskWalk", type: :string }])
         @new_resource.run_action(:create) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Slitheen")).to eq(false)
       end
 
       it "does not raise an exception if the action create and only name key present in values hash" do
-        @new_resource.key(reg_child + '\Slitheen')
+        @new_resource.key(reg_child + "\\Slitheen")
         @new_resource.values([{ name: "BriskWalk" }])
         @new_resource.run_action(:create) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Slitheen")).to eq(false)
       end
 
       it "does not raise an exception if the action create and all keys are present in values hash" do
-        @new_resource.key(reg_child + '\Slitheen')
+        @new_resource.key(reg_child + "\\Slitheen")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "my_data" }])
         @new_resource.run_action(:create) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Slitheen")).to eq(false)
       end
     end
   end
@@ -374,17 +374,17 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     it "creates subkey if parent exists" do
-      @new_resource.key(reg_child + '\Pyrovile')
+      @new_resource.key(reg_child + "\\Pyrovile")
       @new_resource.values([{ name: "Chef", type: :multi_string, data: %w{OpscodeOrange Rules} }])
       @new_resource.recursive(false)
       @new_resource.run_action(:create_if_missing)
 
-      expect(@registry.key_exists?(reg_child + '\Pyrovile')).to eq(true)
-      expect(@registry.value_exists?(reg_child + '\Pyrovile', { name: "Chef", type: :multi_string, data: %w{OpscodeOrange Rules} })).to eq(true)
+      expect(@registry.key_exists?(reg_child + "\\Pyrovile")).to eq(true)
+      expect(@registry.value_exists?(reg_child + "\\Pyrovile", { name: "Chef", type: :multi_string, data: %w{OpscodeOrange Rules} })).to eq(true)
     end
 
     it "raises an error if action create and parent does not exist and recursive is set to false" do
-      @new_resource.key(reg_child + '\Sontaran\Sontar')
+      @new_resource.key(reg_child + "\\Sontaran\\Sontar")
       @new_resource.values([{ name: "OC", type: :string, data: "MissingData" }])
       @new_resource.recursive(false)
       expect { @new_resource.run_action(:create_if_missing) }.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
@@ -415,28 +415,28 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     it "creates missing keys if action create and parent does not exist and recursive is set to true" do
-      @new_resource.key(reg_child + '\Sontaran\Sontar')
+      @new_resource.key(reg_child + "\\Sontaran\\Sontar")
       @new_resource.values([{ name: "OC", type: :string, data: "MissingData" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create_if_missing)
 
-      expect(@registry.key_exists?(reg_child + '\Sontaran\Sontar')).to eq(true)
-      expect(@registry.value_exists?(reg_child + '\Sontaran\Sontar', { name: "OC", type: :string, data: "MissingData" })).to eq(true)
+      expect(@registry.key_exists?(reg_child + "\\Sontaran\\Sontar")).to eq(true)
+      expect(@registry.value_exists?(reg_child + "\\Sontaran\\Sontar", { name: "OC", type: :string, data: "MissingData" })).to eq(true)
     end
 
     it "creates key with multiple value as specified" do
-      @new_resource.key(reg_child + '\Adipose')
+      @new_resource.key(reg_child + "\\Adipose")
       @new_resource.values([{ name: "one", type: :string, data: "1" }, { name: "two", type: :string, data: "2" }, { name: "three", type: :string, data: "3" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create_if_missing)
 
       @new_resource.each_value do |value|
-        expect(@registry.value_exists?(reg_child + '\Adipose', value)).to eq(true)
+        expect(@registry.value_exists?(reg_child + "\\Adipose", value)).to eq(true)
       end
     end
 
     it "prepares the reporting data for :create_if_missing" do
-      @new_resource.key(reg_child + '\Judoon')
+      @new_resource.key(reg_child + "\\Judoon")
       @new_resource.values([{ name: "ReportingVal3", type: :string, data: "report3" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create_if_missing)
@@ -445,7 +445,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
       expect(@report["action"]).to eq("end")
       expect(@report["resources"][0]["type"]).to eq("registry_key")
       expect(@report["resources"][0]["name"]).to eq(resource_name)
-      expect(@report["resources"][0]["id"]).to eq(reg_child + '\Judoon')
+      expect(@report["resources"][0]["id"]).to eq(reg_child + "\\Judoon")
       expect(@report["resources"][0]["after"][:values]).to eq([{ name: "ReportingVal3", type: :string, data: "report3" }])
       expect(@report["resources"][0]["before"][:values]).to eq([])
       expect(@report["resources"][0]["result"]).to eq("create_if_missing")
@@ -459,48 +459,48 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
       end
 
       it "does not raise an exception if the keys do not exist but recursive is set to false" do
-        @new_resource.key(reg_child + '\Zygons\Zygor')
+        @new_resource.key(reg_child + "\\Zygons\\Zygor")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:create_if_missing) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
-        expect(@registry.key_exists?(reg_child + '\Zygons\Zygor')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Zygons")).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Zygons\\Zygor")).to eq(false)
       end
 
       it "does nothing if the action is create_if_missing" do
-        @new_resource.key(reg_child + '\Zygons')
+        @new_resource.key(reg_child + "\\Zygons")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:create_if_missing)
-        expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Zygons")).to eq(false)
       end
 
       it "does not raise an exception if the action create_if_missing and type key missing in values hash" do
-        @new_resource.key(reg_child + '\Zygons')
+        @new_resource.key(reg_child + "\\Zygons")
         @new_resource.values([{ name: "BriskWalk", data: "my_data" }])
         @new_resource.run_action(:create_if_missing) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Zygons")).to eq(false)
       end
 
       it "does not raise an exception if the action create_if_missing and data key missing in values hash" do
-        @new_resource.key(reg_child + '\Zygons')
+        @new_resource.key(reg_child + "\\Zygons")
         @new_resource.values([{ name: "BriskWalk", type: :string }])
         @new_resource.run_action(:create_if_missing) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Zygons")).to eq(false)
       end
 
       it "does not raise an exception if the action create_if_missing and only name key present in values hash" do
-        @new_resource.key(reg_child + '\Zygons')
+        @new_resource.key(reg_child + "\\Zygons")
         @new_resource.values([{ name: "BriskWalk" }])
         @new_resource.run_action(:create_if_missing) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Zygons")).to eq(false)
       end
 
       it "does not raise an exception if the action create_if_missing and all keys are present in values hash" do
-        @new_resource.key(reg_child + '\Zygons')
+        @new_resource.key(reg_child + "\\Zygons")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "my_data" }])
         @new_resource.run_action(:create_if_missing) # should not raise_error
-        expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
+        expect(@registry.key_exists?(reg_child + "\\Zygons")).to eq(false)
       end
     end
   end
@@ -512,61 +512,61 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     it "takes no action if the specified key path does not exist in the system" do
-      expect(@registry.key_exists?(reg_parent + '\Osirian')).to eq(false)
+      expect(@registry.key_exists?(reg_parent + "\\Osirian")).to eq(false)
 
-      @new_resource.key(reg_parent + '\Osirian')
+      @new_resource.key(reg_parent + "\\Osirian")
       @new_resource.recursive(false)
       @new_resource.run_action(:delete)
 
-      expect(@registry.key_exists?(reg_parent + '\Osirian')).to eq(false)
+      expect(@registry.key_exists?(reg_parent + "\\Osirian")).to eq(false)
     end
 
     it "takes no action if the key exists but the value does not" do
-      expect(@registry.data_exists?(reg_parent + '\Opscode', { name: "Color", type: :string, data: "Orange" })).to eq(true)
+      expect(@registry.data_exists?(reg_parent + "\\Opscode", { name: "Color", type: :string, data: "Orange" })).to eq(true)
 
-      @new_resource.key(reg_parent + '\Opscode')
+      @new_resource.key(reg_parent + "\\Opscode")
       @new_resource.values([{ name: "LooksLike", type: :multi_string, data: %w{SeattleGrey OCOrange} }])
       @new_resource.recursive(false)
       @new_resource.run_action(:delete)
 
-      expect(@registry.data_exists?(reg_parent + '\Opscode', { name: "Color", type: :string, data: "Orange" })).to eq(true)
+      expect(@registry.data_exists?(reg_parent + "\\Opscode", { name: "Color", type: :string, data: "Orange" })).to eq(true)
     end
 
     it "deletes only specified values under a key path" do
-      @new_resource.key(reg_parent + '\Opscode')
+      @new_resource.key(reg_parent + "\\Opscode")
       @new_resource.values([{ name: "Opscode", type: :multi_string, data: %w{Seattle Washington} }, { name: "AKA", type: :string, data: "OC" }])
       @new_resource.recursive(false)
       @new_resource.run_action(:delete)
 
-      expect(@registry.data_exists?(reg_parent + '\Opscode', { name: "Color", type: :string, data: "Orange" })).to eq(true)
-      expect(@registry.value_exists?(reg_parent + '\Opscode', { name: "AKA", type: :string, data: "OC" })).to eq(false)
-      expect(@registry.value_exists?(reg_parent + '\Opscode', { name: "Opscode", type: :multi_string, data: %w{Seattle Washington} })).to eq(false)
+      expect(@registry.data_exists?(reg_parent + "\\Opscode", { name: "Color", type: :string, data: "Orange" })).to eq(true)
+      expect(@registry.value_exists?(reg_parent + "\\Opscode", { name: "AKA", type: :string, data: "OC" })).to eq(false)
+      expect(@registry.value_exists?(reg_parent + "\\Opscode", { name: "Opscode", type: :multi_string, data: %w{Seattle Washington} })).to eq(false)
     end
 
     it "it deletes the values with the same name irrespective of it type and data" do
-      @new_resource.key(reg_parent + '\Opscode')
+      @new_resource.key(reg_parent + "\\Opscode")
       @new_resource.values([{ name: "Color", type: :multi_string, data: %w{Black Orange} }])
       @new_resource.recursive(false)
       @new_resource.run_action(:delete)
 
-      expect(@registry.value_exists?(reg_parent + '\Opscode', { name: "Color", type: :string, data: "Orange" })).to eq(false)
+      expect(@registry.value_exists?(reg_parent + "\\Opscode", { name: "Color", type: :string, data: "Orange" })).to eq(false)
     end
 
     it "prepares the reporting data for action :delete" do
-      @new_resource.key(reg_parent + '\ReportKey')
+      @new_resource.key(reg_parent + "\\ReportKey")
       @new_resource.values([{ name: "ReportVal4", type: :string, data: "report4" }, { name: "ReportVal5", type: :string, data: "report5" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:delete)
 
       @report = @resource_reporter.prepare_run_data
 
-      expect(@registry.value_exists?(reg_parent + '\ReportKey', [{ name: "ReportVal4", type: :string, data: "report4" }, { name: "ReportVal5", type: :string, data: "report5" }])).to eq(false)
+      expect(@registry.value_exists?(reg_parent + "\\ReportKey", [{ name: "ReportVal4", type: :string, data: "report4" }, { name: "ReportVal5", type: :string, data: "report5" }])).to eq(false)
 
       expect(@report["action"]).to eq("end")
       expect(@report["resources"].count).to eq(1)
       expect(@report["resources"][0]["type"]).to eq("registry_key")
       expect(@report["resources"][0]["name"]).to eq(resource_name)
-      expect(@report["resources"][0]["id"]).to eq(reg_parent + '\ReportKey')
+      expect(@report["resources"][0]["id"]).to eq(reg_parent + "\\ReportKey")
       expect(@report["resources"][0]["before"][:values]).to eq([{ name: "ReportVal4", type: :string, data: "report4" },
                                                             { name: "ReportVal5", type: :string, data: "report5" }])
       # Not testing for after values to match since after -> new_resource values.
@@ -580,12 +580,12 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
         Chef::Config[:why_run] = true
       end
       it "does nothing if the action is delete" do
-        @new_resource.key(reg_parent + '\OpscodeWhyRun')
+        @new_resource.key(reg_parent + "\\OpscodeWhyRun")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:delete)
 
-        expect(@registry.key_exists?(reg_parent + '\OpscodeWhyRun')).to eq(true)
+        expect(@registry.key_exists?(reg_parent + "\\OpscodeWhyRun")).to eq(true)
       end
     end
   end
@@ -597,21 +597,21 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     it "takes no action if the specified key path does not exist in the system" do
-      expect(@registry.key_exists?(reg_parent + '\Osirian')).to eq(false)
+      expect(@registry.key_exists?(reg_parent + "\\Osirian")).to eq(false)
 
-      @new_resource.key(reg_parent + '\Osirian')
+      @new_resource.key(reg_parent + "\\Osirian")
       @new_resource.recursive(false)
       @new_resource.run_action(:delete_key)
 
-      expect(@registry.key_exists?(reg_parent + '\Osirian')).to eq(false)
+      expect(@registry.key_exists?(reg_parent + "\\Osirian")).to eq(false)
     end
 
     it "deletes key if it has no subkeys and recursive == false" do
-      @new_resource.key(reg_parent + '\OpscodeTest')
+      @new_resource.key(reg_parent + "\\OpscodeTest")
       @new_resource.recursive(false)
       @new_resource.run_action(:delete_key)
 
-      expect(@registry.key_exists?(reg_parent + '\OpscodeTest')).to eq(false)
+      expect(@registry.key_exists?(reg_parent + "\\OpscodeTest")).to eq(false)
     end
 
     it "raises an exception if the key has subkeys and recursive == false" do
@@ -621,22 +621,22 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     it "ignores the values under a key" do
-      @new_resource.key(reg_parent + '\OpscodeIgnoredValues')
+      @new_resource.key(reg_parent + "\\OpscodeIgnoredValues")
       # @new_resource.values([{:name=>"DontExist", :type=>:string, :data=>"These will be ignored anyways"}])
       @new_resource.recursive(true)
       @new_resource.run_action(:delete_key)
     end
 
     it "deletes the key if it has subkeys and recursive == true" do
-      @new_resource.key(reg_parent + '\Opscode')
+      @new_resource.key(reg_parent + "\\Opscode")
       @new_resource.recursive(true)
       @new_resource.run_action(:delete_key)
 
-      expect(@registry.key_exists?(reg_parent + '\Opscode')).to eq(false)
+      expect(@registry.key_exists?(reg_parent + "\\Opscode")).to eq(false)
     end
 
     it "prepares the reporting data for action :delete_key" do
-      @new_resource.key(reg_parent + '\ReportKey')
+      @new_resource.key(reg_parent + "\\ReportKey")
       @new_resource.recursive(true)
       @new_resource.run_action(:delete_key)
 
@@ -644,7 +644,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
       expect(@report["action"]).to eq("end")
       expect(@report["resources"][0]["type"]).to eq("registry_key")
       expect(@report["resources"][0]["name"]).to eq(resource_name)
-      expect(@report["resources"][0]["id"]).to eq(reg_parent + '\ReportKey')
+      expect(@report["resources"][0]["id"]).to eq(reg_parent + "\\ReportKey")
       # Not testing for before or after values to match since
       # after -> new_resource.values and
       # before -> current_resource.values
@@ -658,18 +658,18 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
       end
 
       it "does not throw an exception if the key has subkeys but recursive is set to false" do
-        @new_resource.key(reg_parent + '\OpscodeWhyRun')
+        @new_resource.key(reg_parent + "\\OpscodeWhyRun")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:delete_key)
       end
       it "does nothing if the action is delete_key" do
-        @new_resource.key(reg_parent + '\OpscodeWhyRun')
+        @new_resource.key(reg_parent + "\\OpscodeWhyRun")
         @new_resource.values([{ name: "BriskWalk", type: :string, data: "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:delete_key)
 
-        expect(@registry.key_exists?(reg_parent + '\OpscodeWhyRun')).to eq(true)
+        expect(@registry.key_exists?(reg_parent + "\\OpscodeWhyRun")).to eq(true)
       end
     end
   end

data/spec/functional/win32/registry_spec.rb

@@ -28,14 +28,14 @@ describe "Chef::Win32::Registry", :windows_only do
     ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root\\Branch"
     ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root\\B®anch"
     ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root\\Branch\\Flower"
-    ::Win32::Registry::HKEY_CURRENT_USER.open('Software\\Root', Win32::Registry::KEY_ALL_ACCESS) do |reg|
+    ::Win32::Registry::HKEY_CURRENT_USER.open("Software\\Root", Win32::Registry::KEY_ALL_ACCESS) do |reg|
       reg["RootType1", Win32::Registry::REG_SZ] = "fibrous"
       reg.write("Roots", Win32::Registry::REG_MULTI_SZ, ["strong roots", "healthy tree"])
     end
-    ::Win32::Registry::HKEY_CURRENT_USER.open('Software\\Root\\Branch', Win32::Registry::KEY_ALL_ACCESS) do |reg|
+    ::Win32::Registry::HKEY_CURRENT_USER.open("Software\\Root\\Branch", Win32::Registry::KEY_ALL_ACCESS) do |reg|
       reg["Strong", Win32::Registry::REG_SZ] = "bird nest"
     end
-    ::Win32::Registry::HKEY_CURRENT_USER.open('Software\\Root\\Branch\\Flower', Win32::Registry::KEY_ALL_ACCESS) do |reg|
+    ::Win32::Registry::HKEY_CURRENT_USER.open("Software\\Root\\Branch\\Flower", Win32::Registry::KEY_ALL_ACCESS) do |reg|
       reg["Petals", Win32::Registry::REG_MULTI_SZ] = %w{Pink Delicate}
     end
 
@@ -297,7 +297,7 @@ describe "Chef::Win32::Registry", :windows_only do
   describe "delete_value" do
     before(:all) do
       ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root\\Trunk\\Peck\\Woodpecker"
-      ::Win32::Registry::HKEY_CURRENT_USER.open('Software\\Root\\Trunk\\Peck\\Woodpecker', Win32::Registry::KEY_ALL_ACCESS) do |reg|
+      ::Win32::Registry::HKEY_CURRENT_USER.open("Software\\Root\\Trunk\\Peck\\Woodpecker", Win32::Registry::KEY_ALL_ACCESS) do |reg|
         reg["Peter", Win32::Registry::REG_SZ] = "Tiny"
       end
     end
@@ -324,11 +324,11 @@ describe "Chef::Win32::Registry", :windows_only do
   describe "delete_key" do
     before(:all) do
       ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root\\Branch\\Fruit"
-      ::Win32::Registry::HKEY_CURRENT_USER.open('Software\\Root\\Branch\\Fruit', Win32::Registry::KEY_ALL_ACCESS) do |reg|
+      ::Win32::Registry::HKEY_CURRENT_USER.open("Software\\Root\\Branch\\Fruit", Win32::Registry::KEY_ALL_ACCESS) do |reg|
         reg["Apple", Win32::Registry::REG_MULTI_SZ] = %w{Red Juicy}
       end
       ::Win32::Registry::HKEY_CURRENT_USER.create "Software\\Root\\Trunk\\Peck\\Woodpecker"
-      ::Win32::Registry::HKEY_CURRENT_USER.open('Software\\Root\\Trunk\\Peck\\Woodpecker', Win32::Registry::KEY_ALL_ACCESS) do |reg|
+      ::Win32::Registry::HKEY_CURRENT_USER.open("Software\\Root\\Trunk\\Peck\\Woodpecker", Win32::Registry::KEY_ALL_ACCESS) do |reg|
         reg["Peter", Win32::Registry::REG_SZ] = "Tiny"
       end
     end
@@ -519,12 +519,12 @@ describe "Chef::Win32::Registry", :windows_only do
         end
         # 64-bit
         ::Win32::Registry::HKEY_LOCAL_MACHINE.create("Software\\Root\\Mauve", ::Win32::Registry::KEY_ALL_ACCESS | 0x0100)
-        ::Win32::Registry::HKEY_LOCAL_MACHINE.open('Software\\Root\\Mauve', Win32::Registry::KEY_ALL_ACCESS | 0x0100) do |reg|
+        ::Win32::Registry::HKEY_LOCAL_MACHINE.open("Software\\Root\\Mauve", Win32::Registry::KEY_ALL_ACCESS | 0x0100) do |reg|
           reg["Alert", Win32::Registry::REG_SZ] = "Universal"
         end
         # 32-bit
         ::Win32::Registry::HKEY_LOCAL_MACHINE.create("Software\\Root\\Poosh", ::Win32::Registry::KEY_ALL_ACCESS | 0x0200)
-        ::Win32::Registry::HKEY_LOCAL_MACHINE.open('Software\\Root\\Poosh', Win32::Registry::KEY_ALL_ACCESS | 0x0200) do |reg|
+        ::Win32::Registry::HKEY_LOCAL_MACHINE.open("Software\\Root\\Poosh", Win32::Registry::KEY_ALL_ACCESS | 0x0200) do |reg|
           reg["Status", Win32::Registry::REG_SZ] = "Lost"
         end
       end

data/spec/unit/data_collector_spec.rb

@@ -164,7 +164,7 @@ describe Chef::DataCollector do
       "after" => after_resource&.state_for_resource_reporter || {},
       "before" => before_resource&.state_for_resource_reporter || {},
       "cookbook_name" => cookbook_name,
-      "cookbook_version" => cookbook_version.version,
+      "cookbook_version" => cookbook_version&.version,
       "delta" => resource_has_diff(new_resource, status) ? new_resource.diff : "",
       "duration" => duration,
       "id" => new_resource.identity,
@@ -567,6 +567,29 @@ describe Chef::DataCollector do
         it_behaves_like "sends a converge message"
       end
 
+      context "when the run contains a file resource that is up-to-date from a @recipe_files, returns nil for the version" do
+        let(:total_resource_count) { 1 }
+        let(:updated_resource_count) { 0 }
+        let(:cookbook_name) { "@recipe_files" }
+        let(:resource_record) { [ resource_record_for(new_resource, current_resource, after_resource, :create, "up-to-date", "1234") ] }
+        let(:status) { "success" }
+        let(:cookbook_version) { nil }
+
+        before do
+          allow(new_resource).to receive(:cookbook_version).and_call_original
+          events.resource_action_start(new_resource, :create)
+          events.resource_current_state_loaded(new_resource, :create, current_resource)
+          events.resource_up_to_date(new_resource, :create)
+          events.resource_after_state_loaded(new_resource, :create, after_resource)
+          new_resource.instance_variable_set(:@elapsed_time, 1.2345)
+          events.resource_completed(new_resource)
+          events.converge_complete
+          run_status.stop_clock
+        end
+
+        it_behaves_like "sends a converge message"
+      end
+
       context "when the run contains a file resource that is updated" do
         let(:total_resource_count) { 1 }
         let(:updated_resource_count) { 1 }

data/spec/unit/dsl/reboot_pending_spec.rb

@@ -36,7 +36,7 @@ describe Chef::DSL::RebootPending do
         end
 
         it 'should return true if "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations" exists' do
-          allow(recipe).to receive(:registry_value_exists?).with('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { name: "PendingFileRenameOperations" }).and_return(true)
+          allow(recipe).to receive(:registry_value_exists?).with("HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager", { name: "PendingFileRenameOperations" }).and_return(true)
           expect(recipe.reboot_pending?).to be_truthy
         end
 

data/spec/unit/mixin/default_paths_spec.rb

@@ -84,7 +84,7 @@ describe Chef::Mixin::DefaultPaths do
       allow(Gem).to receive(:bindir).and_return(gem_bindir)
       allow(RbConfig::CONFIG).to receive(:[]).with("bindir").and_return(ruby_bindir)
       allow(ChefUtils).to receive(:windows?).and_return(true)
-      env = { "PATH" => 'C:\Windows\system32;C:\mr\softie' }
+      env = { "PATH" => "C:\\Windows\\system32;C:\\mr\\softie" }
       @default_paths.enforce_default_paths(env)
       expect(env["PATH"]).to eq("#{gem_bindir};#{ruby_bindir};C:\\Windows\\system32;C:\\mr\\softie")
     end

data/spec/unit/mixin/securable_spec.rb

@@ -53,8 +53,8 @@ describe Chef::Mixin::Securable do
     end
 
     it "should accept group/owner names with spaces and backslashes" do
-      expect { @securable.group 'test\ group' }.not_to raise_error
-      expect { @securable.owner 'test\ group' }.not_to raise_error
+      expect { @securable.group "test\\ group" }.not_to raise_error
+      expect { @securable.owner "test\\ group" }.not_to raise_error
     end
 
     it "should accept group/owner names that are a single character or digit" do
@@ -186,7 +186,7 @@ describe Chef::Mixin::Securable do
     end
 
     it "should not accept a group name or id for group with spaces and multiple backslashes" do
-      expect { @securable.group 'test\ \group' }.to raise_error(ArgumentError)
+      expect { @securable.group "test\\ \\group" }.to raise_error(ArgumentError)
     end
 
     it "should accept a unix file mode in string form as an octal number" do

data/spec/unit/provider/cron_spec.rb

@@ -392,6 +392,27 @@ describe Chef::Provider::Cron do
         expect(cron.command).to eq("/bin/true")
       end
     end
+
+    context "with a matching entry with a commented crontab line" do
+      it "should set cron_exists" do
+        allow(@provider).to receive(:read_crontab).and_return(<<~CRONTAB)
+          0 2 * * * /some/other/command
+
+          # Chef Name: cronhole some stuff
+          #* * * * * /bin/true
+        CRONTAB
+        cron = @provider.load_current_resource
+        expect(@provider.cron_exists).to eq(true)
+        expect(@provider.cron_empty).to eq(false)
+        expect(cron.minute).to eq("*")
+        expect(cron.hour).to eq("*")
+        expect(cron.day).to eq("*")
+        expect(cron.month).to eq("*")
+        expect(cron.weekday).to eq("*")
+        expect(cron.time).to eq(nil)
+        expect(cron.property_is_set?(:command)).to eq(false)
+      end
+    end
   end
 
   describe "cron_different?" do
@@ -691,6 +712,30 @@ describe Chef::Provider::Cron do
       end
     end
 
+    context "when there is a crontab with a matching section with a commented crontab line in it" do
+      before :each do
+        @provider.cron_exists = true
+      end
+
+      it "should add the crontab to the entry" do
+        allow(@provider).to receive(:read_crontab).and_return(<<~CRONTAB)
+          0 2 * * * /some/other/command
+
+          # Chef Name: cronhole some stuff
+          # * * * * * /bin/true
+        CRONTAB
+        expect(@provider).to receive(:write_crontab).with(<<~ENDCRON)
+          0 2 * * * /some/other/command
+
+          # Chef Name: cronhole some stuff
+          * * * * * /bin/true
+          # * * * * * /bin/true
+        ENDCRON
+        @new_resource.minute "*"
+        @provider.run_action(:create)
+      end
+    end
+
     context "when there is a crontab with a matching and identical section" do
       context "when environment variable is not used" do
         before :each do