chef 16.2.44-universal-mingw32 → 16.4.35-universal-mingw32

data/spec/unit/resource/file/verification_spec.rb

@@ -112,7 +112,8 @@ describe Chef::Resource::File::Verification do
       end
 
       it "returns true if the command succeeds" do
-        v = Chef::Resource::File::Verification.new(parent_resource, "true", {})
+        test_command = platform_specific_verify_command("path")
+        v = Chef::Resource::File::Verification.new(parent_resource, test_command, {})
         expect(v.verify(temp_path)).to eq(true)
       end
 

data/spec/unit/resource/macos_user_defaults_spec.rb

@@ -20,16 +20,117 @@ require "spec_helper"
 describe Chef::Resource::MacosUserDefaults do
 
   let(:resource) { Chef::Resource::MacosUserDefaults.new("foo") }
+  let(:provider) { resource.provider_for_action(:write) }
 
   it "has a resource name of :macos_userdefaults" do
-    expect(resource.resource_name).to eql(:macos_userdefaults)
+    expect(resource.resource_name).to eq(:macos_userdefaults)
+  end
+
+  it "the domain property defaults to NSGlobalDomain" do
+    expect(resource.domain).to eq("NSGlobalDomain")
+  end
+
+  it "the value property coerces keys in hashes to strings so we can compare them with plist data" do
+    resource.value "User": "/Library/Managed Installs/way_fake.log"
+    expect(resource.value).to eq({ "User" => "/Library/Managed Installs/way_fake.log" })
+  end
+
+  it "the host property defaults to nil" do
+    expect(resource.host).to be_nil
+  end
+
+  it "the sudo property defaults to false" do
+    expect(resource.sudo).to be false
   end
 
   it "sets the default action as :write" do
-    expect(resource.action).to eql([:write])
+    expect(resource.action).to eq([:write])
   end
 
   it "supports :write action" do
     expect { resource.action :write }.not_to raise_error
   end
+
+  describe "#defaults_export_cmd" do
+    it "exports NSGlobalDomain if no domain is set" do
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "export", "NSGlobalDomain", "-"])
+    end
+
+    it "exports a provided domain" do
+      resource.domain "com.tim"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "export", "com.tim", "-"])
+    end
+
+    it "sets -currentHost if host is 'current'" do
+      resource.host "current"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "-currentHost", "export", "NSGlobalDomain", "-"])
+    end
+
+    it "sets -host 'tim-laptop if host is 'tim-laptop'" do
+      resource.host "tim-laptop"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "-host", "tim-laptop", "export", "NSGlobalDomain", "-"])
+    end
+  end
+
+  describe "#defaults_modify_cmd" do
+    # avoid needing to set these required values over and over. We'll overwrite them where necessary
+    before do
+      resource.key = "foo"
+      resource.value = "bar"
+    end
+
+    it "writes to NSGlobalDomain if domain isn't specified" do
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "uses the domain property if set" do
+      resource.domain = "MyCustomDomain"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "MyCustomDomain", "foo", "-string", "bar"])
+    end
+
+    it "sets host specific values using host property" do
+      resource.host = "tims_laptop"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "-host", "tims_laptop", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "if host is set to :current it passes CurrentHost" do
+      resource.host = :current
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "-currentHost", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "raises ArgumentError if bool is specified, but the value can't be made into a bool" do
+      resource.type "bool"
+      expect { provider.defaults_modify_cmd }.to raise_error(ArgumentError)
+    end
+
+    it "autodetects array type and passes individual values" do
+      resource.value = %w{one two three}
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-array", "one", "two", "three"])
+    end
+
+    it "autodetects string type and passes a single value" do
+      resource.value = "one"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-string", "one"])
+    end
+
+    it "autodetects integer type and passes a single value" do
+      resource.value = 1
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-int", 1])
+    end
+
+    it "autodetects boolean type from TrueClass value and passes a 'TRUE' string" do
+      resource.value = true
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-bool", "TRUE"])
+    end
+
+    it "autodetects boolean type from FalseClass value and passes a 'FALSE' string" do
+      resource.value = false
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-bool", "FALSE"])
+    end
+
+    it "autodetects dict type from Hash value and flattens keys & values" do
+      resource.value = { "foo" => "bar" }
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-dict", "foo", "bar"])
+    end
+  end
 end

data/spec/unit/resource/osx_profile_spec.rb

@@ -58,4 +58,237 @@ describe Chef::Resource::OsxProfile do
     resource.profile test_profile
     expect(resource.profile).to be_a(Hash)
   end
+
+  let(:shell_out_success) do
+    double("shell_out", exitstatus: 0, error?: false)
+  end
+
+  describe "action_create" do
+    let(:node) { Chef::Node.new }
+    let(:events) { Chef::EventDispatch::Dispatcher.new }
+    let(:run_context) { Chef::RunContext.new(node, {}, events) }
+    let(:resource) { Chef::Resource::OsxProfile.new("Profile Test", run_context) }
+    let(:provider) { resource.provider_for_action(:create) }
+    let(:all_profiles) do
+      { "_computerlevel" => [{ "ProfileDisplayName" => "Finder Settings",
+                               "ProfileIdentifier" => "com.apple.finder",
+                               "ProfileInstallDate" => "2015-11-08 23:15:21 +0000",
+                               "ProfileItems" => [{ "PayloadContent" => { "PayloadContentManagedPreferences" => { "com.apple.finder" => { "Forced" => [{ "mcx_preference_settings" => { "ShowExternalHardDrivesOnDesktop" => false } }] } } },
+                                                    "PayloadDisplayName" => "Custom: (com.apple.finder)",
+                                                    "PayloadIdentifier" => "com.apple.finder",
+                                                    "PayloadType" => "com.apple.ManagedClient.preferences",
+                                                    "PayloadUUID" => "a017048f-684b-4e81-baa3-43afe316d739",
+                                                    "PayloadVersion" => 1 }],
+                               "ProfileOrganization" => "Chef",
+                               "ProfileRemovalDisallowed" => "false",
+                               "ProfileType" => "Configuration",
+                               "ProfileUUID" => "e2e09bef-e673-44a6-bcbe-ecb5f1c1b740",
+                               "ProfileVerificationState" => "unsigned",
+                               "ProfileVersion" => 1 },
+        { "ProfileDisplayName" => "ScreenSaver Settings",
+          "ProfileIdentifier" => "com.testprofile.screensaver",
+          "ProfileInstallDate" => "2015-10-05 23:15:21 +0000",
+          "ProfileItems" => [{ "PayloadContent" => { "PayloadContentManagedPreferences" => { "com.apple.screensaver" => { "Forced" => [{ "mcx_preference_settings" => { "idleTime" => 0 } }] } } },
+                               "PayloadDisplayName" => "Custom: (com.apple.screensaver)",
+                               "PayloadIdentifier" => "com.apple.screensaver",
+                               "PayloadType" => "com.apple.ManagedClient.preferences",
+                               "PayloadUUID" => "73fc30e0-1e57-0131-c32d-000c2944c110",
+                               "PayloadVersion" => 1 }],
+          "ProfileOrganization" => "Chef",
+          "ProfileRemovalDisallowed" => "false",
+          "ProfileType" => "Configuration",
+          "ProfileUUID" => "6e95927c-f200-54b4-85c7-52ab99b61c47",
+          "ProfileVerificationState" => "unsigned",
+          "ProfileVersion" => 1 }],
+      }
+    end
+    # If anything is changed within this profile, be sure to update the
+    # ProfileUUID in all_profiles to match the new config specific UUID
+    let(:test_profile) do
+      {
+        "PayloadIdentifier" => "com.testprofile.screensaver",
+        "PayloadRemovalDisallowed" => false,
+        "PayloadScope" => "System",
+        "PayloadType" => "Configuration",
+        "PayloadUUID" => "1781fbec-3325-565f-9022-8aa28135c3cc",
+        "PayloadOrganization" => "Chef",
+        "PayloadVersion" => 1,
+        "PayloadDisplayName" => "Screensaver Settings",
+        "PayloadContent" => [
+          {
+            "PayloadType" => "com.apple.ManagedClient.preferences",
+            "PayloadVersion" => 1,
+            "PayloadIdentifier" => "com.testprofile.screensaver",
+            "PayloadUUID" => "73fc30e0-1e57-0131-c32d-000c2944c108",
+            "PayloadEnabled" => true,
+            "PayloadDisplayName" => "com.apple.screensaver",
+            "PayloadContent" => {
+              "com.apple.screensaver" => {
+                "Forced" => [
+                  {
+                    "mcx_preference_settings" => {
+                      "idleTime" => 0,
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        ],
+        }
+    end
+    let(:no_profiles) do
+      {}
+    end
+
+    before(:each) do
+      allow(provider).to receive(:cookbook_file_available?).and_return(true)
+      allow(provider).to receive(:cache_cookbook_profile).and_return("/tmp/test.mobileconfig.remote")
+      allow(provider).to receive(:get_new_profile_hash).and_return(test_profile)
+      allow(provider).to receive(:get_installed_profiles).and_return(all_profiles)
+      allow(provider).to receive(:read_plist).and_return(all_profiles)
+      allow(::File).to receive(:unlink).and_return(true)
+    end
+
+    it "should build the get all profiles shellout command correctly" do
+      profile_name = "com.testprofile.screensaver.mobileconfig"
+      resource.profile_name profile_name
+      allow(provider).to receive(:get_installed_profiles).and_call_original
+      allow(provider).to receive(:read_plist).and_return(all_profiles)
+      expect(provider).to receive(:shell_out_compacted!).with("/usr/bin/profiles", "-P", "-o", kind_of(String))
+      provider.load_current_resource
+    end
+
+    it "should use profile name as profile when no profile is set" do
+      profile_name = "com.testprofile.screensaver.mobileconfig"
+      resource.profile_name profile_name
+      provider.load_current_resource
+      expect(resource.profile_name).to eql(profile_name)
+    end
+
+    it "should use identifier from specified profile" do
+      resource.profile test_profile
+      provider.load_current_resource
+      expect(
+        provider.instance_variable_get(:@new_profile_identifier)
+      ).to eql(test_profile["PayloadIdentifier"])
+    end
+
+    it "should install when not installed" do
+      resource.profile test_profile
+      allow(provider).to receive(:get_installed_profiles).and_return(no_profiles)
+      provider.load_current_resource
+      expect(provider).to receive(:install_profile)
+      expect { provider.run_action(:install) }.to_not raise_error
+    end
+
+    it "does not install if the profile is already installed" do
+      resource.profile test_profile
+      allow(provider).to receive(:get_installed_profiles).and_return(all_profiles)
+      provider.load_current_resource
+      expect(provider).to_not receive(:install_profile)
+      expect { provider.action_install }.to_not raise_error
+    end
+
+    it "should install when installed but uuid differs" do
+      resource.profile test_profile
+      all_profiles["_computerlevel"][1]["ProfileUUID"] = "1781fbec-3325-565f-9022-9bb39245d4dd"
+      provider.load_current_resource
+      expect(provider).to receive(:install_profile)
+      expect { provider.run_action(:install) }.to_not raise_error
+    end
+
+    it "should build the shellout install command correctly" do
+      profile_path = "/tmp/test.mobileconfig"
+      resource.profile test_profile
+      # Change the profile so it triggers an install
+      all_profiles["_computerlevel"][1]["ProfileUUID"] = "1781fbec-3325-565f-9022-9bb39245d4dd"
+      provider.load_current_resource
+      allow(provider).to receive(:write_profile_to_disk).and_return(profile_path)
+      expect(provider).to receive(:shell_out_compacted!).with("/usr/bin/profiles", "-I", "-F", profile_path).and_return(shell_out_success)
+      provider.action_install
+    end
+
+    it "should fail if there is no identifier inside the profile" do
+      test_profile.delete("PayloadIdentifier")
+      resource.profile test_profile
+      error_message = "The specified profile does not seem to be valid"
+      expect { provider.run_action(:install) }.to raise_error(RuntimeError, error_message)
+    end
+  end
+
+  describe "action_remove" do
+    let(:node) { Chef::Node.new }
+    let(:events) { Chef::EventDispatch::Dispatcher.new }
+    let(:run_context) { Chef::RunContext.new(node, {}, events) }
+    let(:resource) { Chef::Resource::OsxProfile.new("Profile Test", run_context) }
+    let(:provider) { resource.provider_for_action(:remove) }
+    let(:current_resource) { Chef::Resource::OsxProfile.new("Profile Test") }
+    let(:all_profiles) do
+      { "_computerlevel" => [{ "ProfileDisplayName" => "ScreenSaver Settings",
+                               "ProfileIdentifier" => "com.apple.screensaver",
+                               "ProfileInstallDate" => "2015-10-05 23:15:21 +0000",
+                               "ProfileItems" => [{ "PayloadContent" => { "PayloadContentManagedPreferences" => { "com.apple.screensaver" => { "Forced" => [{ "mcx_preference_settings" => { "idleTime" => 0 } }] } } },
+                                                    "PayloadDisplayName" => "Custom: (com.apple.screensaver)",
+                                                    "PayloadIdentifier" => "com.apple.screensaver",
+                                                    "PayloadType" => "com.apple.ManagedClient.preferences",
+                                                    "PayloadUUID" => "73fc30e0-1e57-0131-c32d-000c2944c108",
+                                                    "PayloadVersion" => 1 }],
+                               "ProfileOrganization" => "Chef",
+                               "ProfileRemovalDisallowed" => "false",
+                               "ProfileType" => "Configuration",
+                               "ProfileUUID" => "1781fbec-3325-565f-9022-8aa28135c3cc",
+                               "ProfileVerificationState" => "unsigned",
+                               "ProfileVersion" => 1 },
+        { "ProfileDisplayName" => "ScreenSaver Settings",
+          "ProfileIdentifier" => "com.testprofile.screensaver",
+          "ProfileInstallDate" => "2015-10-05 23:15:21 +0000",
+          "ProfileItems" => [{ "PayloadContent" => { "PayloadContentManagedPreferences" => { "com.apple.screensaver" => { "Forced" => [{ "mcx_preference_settings" => { "idleTime" => 0 } }] } } },
+                               "PayloadDisplayName" => "Custom: (com.apple.screensaver)",
+                               "PayloadIdentifier" => "com.apple.screensaver",
+                               "PayloadType" => "com.apple.ManagedClient.preferences",
+                               "PayloadUUID" => "73fc30e0-1e57-0131-c32d-000c2944c110",
+                               "PayloadVersion" => 1 }],
+          "ProfileOrganization" => "Chef",
+          "ProfileRemovalDisallowed" => "false",
+          "ProfileType" => "Configuration",
+          "ProfileUUID" => "1781fbec-3325-565f-9022-8aa28135c3cc",
+          "ProfileVerificationState" => "unsigned",
+          "ProfileVersion" => 1 }],
+      }
+    end
+
+    before(:each) do
+      provider.current_resource = current_resource
+      allow(provider).to receive(:get_installed_profiles).and_return(all_profiles)
+    end
+
+    it "should use resource name for identifier when not specified" do
+      resource.profile_name "com.testprofile.screensaver"
+      resource.action(:remove)
+      provider.load_current_resource
+      expect(provider.instance_variable_get(:@new_profile_identifier)).to eql(resource.profile_name)
+    end
+
+    it "should use specified identifier" do
+      resource.identifier "com.testprofile.screensaver"
+      resource.action(:remove)
+      provider.load_current_resource
+      expect(provider.instance_variable_get(:@new_profile_identifier)).to eql(resource.identifier)
+    end
+
+    it "should work with spaces in the identifier" do
+      provider.action = :remove
+      provider.define_resource_requirements
+      expect { provider.process_resource_requirements }.not_to raise_error
+    end
+
+    it "should build the shellout remove command correctly" do
+      resource.identifier "com.testprofile.screensaver"
+      resource.action(:remove)
+      provider.load_current_resource
+      expect(provider).to receive(:shell_out_compacted!).with("/usr/bin/profiles", "-R", "-p", resource.identifier).and_return(shell_out_success)
+      provider.action_remove
+    end
+  end
 end

data/spec/unit/resource/powershell_script_spec.rb

@@ -20,7 +20,7 @@ require "spec_helper"
 
 describe Chef::Resource::PowershellScript do
 
-  before(:each) do
+  let(:resource) do
     node = Chef::Node.new
 
     node.default["kernel"] = {}
@@ -29,26 +29,25 @@ describe Chef::Resource::PowershellScript do
 
     run_context = Chef::RunContext.new(node, nil, nil)
 
-    @resource = Chef::Resource::PowershellScript.new("powershell_unit_test", run_context)
+    Chef::Resource::PowershellScript.new("powershell_unit_test", run_context)
   end
 
   it "creates a new Chef::Resource::PowershellScript" do
-    expect(@resource).to be_a_kind_of(Chef::Resource::PowershellScript)
+    expect(resource).to be_a_kind_of(Chef::Resource::PowershellScript)
   end
 
   it "sets convert_boolean_return to false by default" do
-    expect(@resource.convert_boolean_return).to eq(false)
+    expect(resource.convert_boolean_return).to eq(false)
   end
 
   it "returns the value for convert_boolean_return that was set" do
-    @resource.convert_boolean_return true
-    expect(@resource.convert_boolean_return).to eq(true)
-    @resource.convert_boolean_return false
-    expect(@resource.convert_boolean_return).to eq(false)
+    resource.convert_boolean_return true
+    expect(resource.convert_boolean_return).to eq(true)
+    resource.convert_boolean_return false
+    expect(resource.convert_boolean_return).to eq(false)
   end
 
   context "when using guards" do
-    let(:resource) { @resource }
     before(:each) do
       allow(resource).to receive(:run_action)
       allow(resource).to receive(:updated).and_return(true)
@@ -126,28 +125,11 @@ describe Chef::Resource::PowershellScript do
   end
 
   context "as a script running in Windows-based scripting language" do
-    let(:resource_instance) { @resource }
-    let(:resource_instance_name ) { @resource.command }
+    let(:windows_script_resource) { resource }
+    let(:resource_instance_name ) { resource.command }
     let(:resource_name) { :powershell_script }
     let(:interpreter_file_name) { "powershell.exe" }
-    before do
-      allow(@resource).to receive(:default_flags).and_return(nil)
-    end
-    it_behaves_like "a Windows script resource"
-  end
-
-  describe "#flags" do
-    let(:resource) { @resource }
-
-    it "appends user's flags to the defaults" do
-      flags = %q{-Lunch "tacos"}
-      resource.flags = flags
 
-      expect(resource.flags).to eq("#{resource.default_flags} #{flags}")
-    end
-
-    it "uses the defaults when user doesn't provide flags" do
-      expect(resource.flags).to eq(resource.default_flags)
-    end
+    it_behaves_like "a Windows script resource"
   end
 end

data/spec/unit/resource/script_spec.rb

@@ -21,9 +21,14 @@ require "spec_helper"
 
 describe Chef::Resource::Script do
   let(:resource_instance_name) { "fakey_fakerton" }
-  let(:script_resource) { Chef::Resource::Script.new(resource_instance_name) }
   let(:resource_name) { :script }
 
+  let(:script_resource) do
+    run_context = Chef::RunContext.new(Chef::Node.new, nil, nil)
+
+    Chef::Resource::Script.new(resource_instance_name, run_context)
+  end
+
   it "sets the default action as :run" do
     expect(script_resource.action).to eql([:run])
   end