chef 17.4.38-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/integration/compliance/compliance_spec.rb

@@ -80,4 +80,64 @@ describe "chef-client with compliance phase" do
       expect(result["status"]).to eq("passed")
     end
   end
+
+  when_the_repository "has a compliance segment" do
+    let(:report_file) { path_to("report_file.json") }
+
+    before do
+      directory "cookbooks/x" do
+        directory "compliance" do
+          directory "profiles/my_profile" do
+            file "inspec.yml", <<~FILE
+              ---
+              name: my-profile
+            FILE
+
+            directory "controls" do
+              file "my_control.rb", <<~FILE
+                control "my control" do
+                  describe Dir.home do
+                    it { should be_kind_of String }
+                  end
+                end
+              FILE
+            end
+          end
+        end
+        file "attributes/default.rb", <<~FILE
+        default['audit']['reporter'] = "json-file"
+        default['audit']['json_file'] = {
+              "location" => "#{report_file}"
+            }
+        FILE
+        file "recipes/default.rb", <<~FILE
+          include_profile ".*::.*"
+        FILE
+      end
+      file "config/client.rb", <<~EOM
+        local_mode true
+        cookbook_path "#{path_to("cookbooks")}"
+        log_level :warn
+      EOM
+    end
+
+    it "should complete with success" do
+      result = shell_out!("#{chef_client} -c \"#{path_to("config/client.rb")}\" -r 'recipe[x]'", cwd: chef_dir)
+      result.error!
+
+      inspec_report = JSON.parse(File.read(report_file))
+      expect(inspec_report["profiles"].length).to eq(1)
+
+      profile = inspec_report["profiles"].first
+      expect(profile["name"]).to eq("my-profile")
+      expect(profile["controls"].length).to eq(1)
+
+      control = profile["controls"].first
+      expect(control["id"]).to eq("my control")
+      expect(control["results"].length).to eq(1)
+
+      result = control["results"].first
+      expect(result["status"]).to eq("passed")
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -68,6 +68,7 @@ end
 require "spec/support/local_gems" if File.exist?(File.join(File.dirname(__FILE__), "support", "local_gems.rb"))
 
 # Explicitly require spec helpers that need to load first
+require "spec/support/ruby_installer"
 require "spec/support/platform_helpers"
 require "spec/support/shared/unit/mock_shellout"
 
@@ -186,6 +187,8 @@ RSpec.configure do |config|
   config.filter_run_excluding not_rhel7: true if rhel7?
   config.filter_run_excluding not_intel_64bit: true if intel_64bit?
 
+  config.filter_run_excluding libarchive_loading_broken: true if aix? || amazon_linux? || rhel7?
+
   # these let us use chef: ">= 13" or ruby: "~> 2.0.0" or any other Gem::Dependency-style constraint
   config.filter_run_excluding chef: DependencyProc.with(Chef::VERSION)
   config.filter_run_excluding ruby: DependencyProc.with(RUBY_VERSION)

data/spec/support/platform_helpers.rb

@@ -163,6 +163,10 @@ def aix?
   RUBY_PLATFORM.include?("aix")
 end
 
+def amazon_linux?
+  ohai[:platform_family] == "amazon"
+end
+
 def wpar?
   !((ohai[:virtualization] || {})[:wpar_no].nil?)
 end