chef 17.10.95 → 18.0.169

data/spec/unit/provider/http_request_spec.rb

@@ -19,87 +19,75 @@
 require "spec_helper"
 
 describe Chef::Provider::HttpRequest do
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-
-    @new_resource = Chef::Resource::HttpRequest.new("adam")
-    @new_resource.name "adam"
-    @new_resource.url "http://www.opscode.com/"
-    @new_resource.message "is cool"
-
-    @provider = Chef::Provider::HttpRequest.new(@new_resource, @run_context)
-  end
-
-  describe "load_current_resource" do
-
-    it "should set up a Chef::ServerAPI client, with no authentication" do
-      expect(Chef::HTTP::Simple).to receive(:new).with(@new_resource.url)
-      @provider.load_current_resource
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:new_resource) do
+    Chef::Resource::HttpRequest.new("adam").tap do |new_resource|
+      new_resource.name "adam"
+      new_resource.url "http://www.opscode.com/"
+      new_resource.message "is cool"
     end
   end
 
+  let(:provider) { Chef::Provider::HttpRequest.new(new_resource, run_context) }
+
   describe "when making REST calls" do
-    before(:each) do
-      # run_action(x) forces load_current_resource to run;
-      # that would overwrite our supplied mock Chef::Rest # object
-      allow(@provider).to receive(:load_current_resource).and_return(true)
-      @http = double("Chef::ServerAPI")
-      @provider.http = @http
+    let(:http) do
+      provider.http = double("Chef::ServerAPI")
     end
 
     describe "action_get" do
 
       it "should inflate a message block at runtime" do
-        @new_resource.message { "return" }
-        expect(@http).to receive(:get).with("http://www.opscode.com/", {})
-        @provider.run_action(:get)
-        expect(@new_resource).to be_updated
+        new_resource.message { "return" }
+        expect(http).to receive(:get).with("http://www.opscode.com/", {})
+        provider.run_action(:get)
+        expect(new_resource).to be_updated
       end
 
       it "should run a GET request" do
-        expect(@http).to receive(:get).with("http://www.opscode.com/", {})
-        @provider.run_action(:get)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:get).with("http://www.opscode.com/", {})
+        provider.run_action(:get)
+        expect(new_resource).to be_updated
       end
     end
 
     describe "action_put" do
       it "should run a PUT request with the message as the payload" do
-        expect(@http).to receive(:put).with("http://www.opscode.com/", @new_resource.message, {})
-        @provider.run_action(:put)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:put).with("http://www.opscode.com/", new_resource.message, {})
+        provider.run_action(:put)
+        expect(new_resource).to be_updated
       end
 
       it "should inflate a message block at runtime" do
-        @new_resource.message(lambda { "return" })
-        expect(@http).to receive(:put).with("http://www.opscode.com/", "return", {})
-        @provider.run_action(:put)
-        expect(@new_resource).to be_updated
+        new_resource.message(lambda { "return" })
+        expect(http).to receive(:put).with("http://www.opscode.com/", "return", {})
+        provider.run_action(:put)
+        expect(new_resource).to be_updated
       end
     end
 
     describe "action_post" do
       it "should run a PUT request with the message as the payload" do
-        expect(@http).to receive(:post).with("http://www.opscode.com/", @new_resource.message, {})
-        @provider.run_action(:post)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:post).with("http://www.opscode.com/", new_resource.message, {})
+        provider.run_action(:post)
+        expect(new_resource).to be_updated
       end
 
       it "should inflate a message block at runtime" do
-        @new_resource.message { "return" }
-        expect(@http).to receive(:post).with("http://www.opscode.com/", "return", {})
-        @provider.run_action(:post)
-        expect(@new_resource).to be_updated
+        new_resource.message { "return" }
+        expect(http).to receive(:post).with("http://www.opscode.com/", "return", {})
+        provider.run_action(:post)
+        expect(new_resource).to be_updated
       end
     end
 
     describe "action_delete" do
       it "should run a DELETE request" do
-        expect(@http).to receive(:delete).with("http://www.opscode.com/", {})
-        @provider.run_action(:delete)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:delete).with("http://www.opscode.com/", {})
+        provider.run_action(:delete)
+        expect(new_resource).to be_updated
       end
     end
 
@@ -107,52 +95,52 @@ describe Chef::Provider::HttpRequest do
     # and false for a "304 Not Modified" response
     describe "action_head" do
       before do
-        @provider.http = @http
+        provider.http = http
       end
 
       it "should inflate a message block at runtime" do
-        @new_resource.message { "return" }
-        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
-        @provider.run_action(:head)
-        expect(@new_resource).to be_updated
+        new_resource.message { "return" }
+        expect(http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        provider.run_action(:head)
+        expect(new_resource).to be_updated
       end
 
       it "should run a HEAD request" do
-        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
-        @provider.run_action(:head)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        provider.run_action(:head)
+        expect(new_resource).to be_updated
       end
 
       it "should update a HEAD request with empty string response body (CHEF-4762)" do
-        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return("")
-        @provider.run_action(:head)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:head).with("http://www.opscode.com/", {}).and_return("")
+        provider.run_action(:head)
+        expect(new_resource).to be_updated
       end
 
       it "should update a HEAD request with nil response body (CHEF-4762)" do
-        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
-        @provider.run_action(:head)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        provider.run_action(:head)
+        expect(new_resource).to be_updated
       end
 
       it "should not update a HEAD request if a not modified response (CHEF-4762)" do
         if_modified_since = File.mtime(__FILE__).httpdate
-        @new_resource.headers "If-Modified-Since" => if_modified_since
-        expect(@http).to receive(:head).with("http://www.opscode.com/", { "If-Modified-Since" => if_modified_since }).and_return(false)
-        @provider.run_action(:head)
-        expect(@new_resource).not_to be_updated
+        new_resource.headers "If-Modified-Since" => if_modified_since
+        expect(http).to receive(:head).with("http://www.opscode.com/", { "If-Modified-Since" => if_modified_since }).and_return(false)
+        provider.run_action(:head)
+        expect(new_resource).not_to be_updated
       end
 
       it "should run a HEAD request with If-Modified-Since header" do
-        @new_resource.headers "If-Modified-Since" => File.mtime(__FILE__).httpdate
-        expect(@http).to receive(:head).with("http://www.opscode.com/", @new_resource.headers)
-        @provider.run_action(:head)
+        new_resource.headers "If-Modified-Since" => File.mtime(__FILE__).httpdate
+        expect(http).to receive(:head).with("http://www.opscode.com/", new_resource.headers)
+        provider.run_action(:head)
       end
 
       it "doesn't call converge_by if HEAD does not return modified" do
-        expect(@http).to receive(:head).and_return(false)
-        expect(@provider).not_to receive(:converge_by)
-        @provider.run_action(:head)
+        expect(http).to receive(:head).and_return(false)
+        expect(provider).not_to receive(:converge_by)
+        provider.run_action(:head)
       end
     end
   end

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

@@ -25,6 +25,7 @@ describe Chef::Provider::Mount::Linux do
     allow(::File).to receive(:exists?).with("/dev/sdz1").and_return true
     allow(::File).to receive(:exists?).with("/tmp/foo").and_return true
     allow(::File).to receive(:exists?).with("//192.168.11.102/Share/backup").and_return true
+    allow(::File).to receive(:exists?).with("//192.168.11.102/Share/backup folder").and_return true
     allow(::File).to receive(:realpath).with("/dev/sdz1").and_return "/dev/sdz1"
     allow(::File).to receive(:realpath).with("/tmp/foo").and_return "/tmp/foo"
   end
@@ -103,6 +104,15 @@ describe Chef::Provider::Mount::Linux do
       provider.load_current_resource
       expect(provider.current_resource.mounted).to be_truthy
     end
+
+    it "should set mounted true if device name has a space and the mount point is found in the mounts list" do
+      new_resource.device "//192.168.11.102/Share/backup folder"
+      new_resource.fstype "cifs"
+      mount = "/tmp/foo //192.168.11.102/Share/backup\x20folder cifs rw\n"
+      allow(provider).to receive(:shell_out!).and_return(double(stdout: mount))
+      provider.load_current_resource
+      expect(provider.current_resource.mounted).to be_truthy
+    end
   end
 
   context "to check if loop resource is mounted" do

data/spec/unit/provider/package/chocolatey_spec.rb

@@ -49,10 +49,6 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-l", "-r", { returns: [0, 2], timeout: timeout }).and_return(local_list_obj)
   end
 
-  after(:each) do
-    described_class.instance_variable_set(:@get_choco_version, nil)
-  end
-
   def allow_remote_list(package_names, args = nil)
     remote_list_stdout = <<~EOF
       Chocolatey v0.9.9.11
@@ -65,9 +61,9 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     remote_list_obj = double(stdout: remote_list_stdout)
     package_names.each do |pkg|
       if args
-        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, described_class.query_command, "-r", pkg, *args, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
+        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-r", pkg, *args, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
       else
-        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, described_class.query_command, "-r", pkg, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
+        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-r", pkg, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
       end
     end
   end
@@ -82,18 +78,6 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     end
   end
 
-  describe "choco searches change with the version" do
-    it "Choco V1 uses List" do
-      allow(described_class).to receive(:get_choco_version).and_return("1.4.0")
-      expect(provider.query_command).to eql("list")
-    end
-
-    it "Choco V2 uses Search" do
-      allow(described_class).to receive(:get_choco_version).and_return("2.1.0")
-      expect(provider.query_command).to eql("search")
-    end
-  end
-
   describe "#candidate_version" do
     it "should set the candidate_version to the latest version when not pinning" do
       allow_remote_list(["git"])
@@ -166,7 +150,7 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
       new_resource.package_name("package-does-not-exist")
       new_resource.returns([0])
       allow(provider).to receive(:shell_out_compacted!)
-        .with(choco_exe, described_class.query_command, "-r", new_resource.package_name.first, { returns: new_resource.returns, timeout: timeout })
+        .with(choco_exe, "list", "-r", new_resource.package_name.first, { returns: new_resource.returns, timeout: timeout })
         .and_raise(Mixlib::ShellOut::ShellCommandFailed, "Expected process to exit with [0], but received '2'")
       expect { provider.send(:available_packages) }.to raise_error(Mixlib::ShellOut::ShellCommandFailed, "Expected process to exit with [0], but received '2'")
     end

data/spec/unit/provider/package/rubygems_spec.rb

@@ -139,7 +139,7 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
         .to_return(status: 200, body: "", headers: {})
       stub_request(:get, "https://rubygems2.org/info/sexp_processor")
         .to_return(status: 200, body: File.binread(File.join(CHEF_SPEC_DATA, "rubygems.org", "sexp_processor-info")))
-      stub_request(:get, "https://rubygems2.org/quick/Marshal.4.8/sexp_processor-4.15.1.gemspec.rz")
+      stub_request(:get, "https://rubygems2.org/quick/Marshal.4.8/sexp_processor-4.16.1.gemspec.rz")
         .to_return(status: 200, body: File.binread(File.join(CHEF_SPEC_DATA, "rubygems.org", "sexp_processor-4.15.1.gemspec.rz")))
 
       dep = Gem::Dependency.new("sexp_processor", ">= 0")

data/spec/unit/provider/package/zypper_spec.rb

@@ -32,6 +32,8 @@ describe Chef::Provider::Package::Zypper do
 
   let(:status) { double(stdout: "\n", exitstatus: 0) }
 
+  let(:source) { "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm" }
+
   before(:each) do
     allow(Chef::Resource::Package).to receive(:new).and_return(current_resource)
     allow(provider).to receive(:shell_out_compacted!).and_return(status)
@@ -163,6 +165,21 @@ describe Chef::Provider::Package::Zypper do
       )
       provider.install_package(["emacs"], ["1.0"])
     end
+
+    it "should run zypper install with source option" do
+      new_resource.source "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm"
+      allow(::File).to receive(:exist?).with("/tmp/wget_1.11.4-1ubuntu1_amd64.rpm").and_return(true)
+      shell_out_expectation!(
+        "zypper", "--non-interactive", "install", "--auto-agree-with-licenses", "--oldpackage", "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm"
+      )
+      provider.install_package(["wget"], ["1.11.4-1ubuntu1_amd64"])
+    end
+
+    it "should raise an exception if a source is supplied but not found when :install" do
+      new_resource.source "/tmp/blah/wget_1.11.4-1ubuntu1_amd64.rpm"
+      allow(::File).to receive(:exist?).with(new_resource.source).and_return(false)
+      expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
+    end
   end
 
   describe "upgrade_package" do
@@ -200,6 +217,21 @@ describe Chef::Provider::Package::Zypper do
       )
       provider.upgrade_package(["emacs"], ["1.0"])
     end
+
+    it "should run zypper upgrade with source option" do
+      new_resource.source "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm"
+      allow(::File).to receive(:exist?).with("/tmp/wget_1.11.4-1ubuntu1_amd64.rpm").and_return(true)
+      shell_out_expectation!(
+        "zypper", "--non-interactive", "install", "--auto-agree-with-licenses", "--oldpackage", "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm"
+      )
+      provider.upgrade_package(["wget"], ["1.11.4-1ubuntu1_amd64"])
+    end
+
+    it "should raise an exception if a source is supplied but not found when :upgrade" do
+      new_resource.source "/tmp/blah/wget_1.11.4-1ubuntu1_amd64.rpm"
+      allow(::File).to receive(:exist?).with(new_resource.source).and_return(false)
+      expect { provider.run_action(:upgrade) }.to raise_error(Chef::Exceptions::Package)
+    end
   end
 
   describe "remove_package" do

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

@@ -20,7 +20,7 @@
 
 require "spec_helper"
 
-describe Chef::Provider::User::Linux do
+describe Chef::Provider::User::Linux, linux_only: true do
 
   subject(:provider) do
     p = described_class.new(@new_resource, @run_context)
@@ -71,6 +71,56 @@ describe Chef::Provider::User::Linux do
     end
   end
 
+  describe "expire_date behavior" do
+    before(:each) do
+      @new_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+      @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+    end
+
+    it "defaults expire_date to nil" do
+      expect( @new_resource.expire_date ).to be nil
+    end
+
+    it "by default expire_date is nil and we use ''" do
+      expect( provider.universal_options ).to eql([])
+    end
+
+    it "setting expire_date to nil includes ''" do
+      @new_resource.expire_date nil
+      expect( provider.universal_options ).to eql([])
+    end
+
+    it "setting expire_date to 1982-04-16 includes -e" do
+      @new_resource.expire_date "1982-04-16"
+      expect( provider.universal_options ).to eql(["-e", "1982-04-16"])
+    end
+  end
+
+  describe "inactive behavior" do
+    before(:each) do
+      @new_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+      @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+    end
+
+    it "defaults inactive to nil" do
+      expect( @new_resource.inactive ).to be nil
+    end
+
+    it "by default inactive is nil and we use ''" do
+      expect( provider.universal_options ).to eql([])
+    end
+
+    it "setting inactive to nil includes ''" do
+      @new_resource.inactive nil
+      expect( provider.universal_options ).to eql([])
+    end
+
+    it "setting inactive to 90 includes -f" do
+      @new_resource.inactive 90
+      expect( provider.universal_options ).to eql(["-f", 90])
+    end
+  end
+
   describe "compare_user_linux" do
     before(:each) do
       @new_resource = Chef::Resource::User::LinuxUser.new("notarealuser")
@@ -86,7 +136,6 @@ describe Chef::Provider::User::Linux do
         "home" => ["/home/notarealuser", "/Users/notarealuser"],
         "shell" => ["/usr/bin/zsh", "/bin/bash"],
         "password" => %w{abcd 12345},
-        "sensitive" => [true],
       }
     end
 
@@ -98,15 +147,6 @@ describe Chef::Provider::User::Linux do
       end
     end
 
-    it "should show a blank for password if sensitive set to true" do
-      @new_resource.password mapping["password"][0]
-      @current_resource.password mapping["password"][1]
-      @new_resource.sensitive true
-      @current_resource.sensitive true
-      provider.compare_user
-      expect(provider.change_desc).to eql(["change password from ******** to ********"])
-    end
-
     %w{uid gid}.each do |property|
       it "should return false if string #{property} matches fixnum" do
         @new_resource.send(property, "100")

data/spec/unit/provider/user_spec.rb

@@ -178,12 +178,30 @@ describe Chef::Provider::User do
         end
       end
 
-      it "should fail assertions when ruby-shadow cannot be loaded" do
-        expect(@provider).to receive(:require).with("shadow") { raise LoadError }
-        @provider.load_current_resource
-        @provider.action = :create
-        @provider.define_resource_requirements
-        expect { @provider.process_resource_requirements }.to raise_error Chef::Exceptions::MissingLibrary
+      context "when ruby-shadow is supported on the platform" do
+        before do
+          allow(@provider).to receive(:supports_ruby_shadow?).and_return true
+        end
+        it "should fail assertions when ruby-shadow cannot be loaded" do
+          expect(@provider).to receive(:require).with("shadow") { raise LoadError }
+          @provider.load_current_resource
+          @provider.action = :create
+          @provider.define_resource_requirements
+          expect { @provider.process_resource_requirements }.to raise_error Chef::Exceptions::MissingLibrary
+        end
+      end
+
+      context "when ruby-shadow is not supported on the platform" do
+        before do
+          allow(@provider).to receive(:supports_ruby_shadow?).and_return false
+        end
+        it "should not fail any assertions when ruby-shadow cannot be loaded" do
+          expect(@provider).to receive(:require).with("shadow") { raise LoadError }
+          @provider.load_current_resource
+          @provider.action = :create
+          @provider.define_resource_requirements
+          @provider.process_resource_requirements
+        end
       end
 
     end

data/spec/unit/resource/archive_file_spec.rb

@@ -29,7 +29,7 @@ rescue LoadError
   end
 end
 
-describe Chef::Resource::ArchiveFile, :not_supported_on_aix do
+describe Chef::Resource::ArchiveFile, :not_supported_on_aix, :not_supported_on_windows do
   let(:node) { Chef::Node.new }
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }

data/spec/unit/resource/chef_client_cron_spec.rb

@@ -43,6 +43,11 @@ describe Chef::Resource::ChefClientCron do
     expect { resource.splay("-10") }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
+  it "set splay to 0" do
+    resource.splay "0"
+    expect(resource.splay).to eql(0)
+  end
+
   it "builds a default value for chef_binary_path dist values" do
     expect(resource.chef_binary_path).to eql("/opt/chef/bin/chef-client")
   end

data/spec/unit/resource/chef_client_launchd_spec.rb

@@ -43,6 +43,11 @@ describe Chef::Resource::ChefClientLaunchd do
     expect { resource.splay("-10") }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
+  it "set splay to 0" do
+    resource.splay "0"
+    expect(resource.splay).to eql(0)
+  end
+
   it "builds a default value for chef_binary_path dist values" do
     expect(resource.chef_binary_path).to eql("/opt/chef/bin/chef-client")
   end

data/spec/unit/resource/chef_client_scheduled_task_spec.rb

@@ -43,6 +43,11 @@ describe Chef::Resource::ChefClientScheduledTask do
     expect { resource.splay("-10") }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
+  it "set splay to 0" do
+    resource.splay "0"
+    expect(resource.splay).to eql(0)
+  end
+
   it "coerces frequency_modifier to an Integer" do
     resource.frequency_modifier "10"
     expect(resource.frequency_modifier).to eql(10)

data/spec/unit/resource/chef_client_systemd_timer_spec.rb

@@ -105,4 +105,4 @@ describe Chef::Resource::ChefClientSystemdTimer do
       expect(provider.service_content["Service"]["CPUQuota"]).to eq(50)
     end
   end
-end
+end

data/spec/unit/resource/cron_d_spec.rb

@@ -18,7 +18,11 @@
 require "spec_helper"
 
 describe Chef::Resource::CronD do
-  let(:resource) { Chef::Resource::CronD.new("cronify") }
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::CronD.new("cronify", run_context) }
+  let(:provider) { resource.provider_for_action(:create) }
 
   it "has a default action of [:create]" do
     expect(resource.action).to eql([:create])
@@ -34,6 +38,38 @@ describe Chef::Resource::CronD do
     expect(resource.cron_name).to eql("cronify")
   end
 
+  context "on linux" do
+    before(:each) do
+      node.automatic_attrs[:os] = "linux"
+    end
+
+    it "the cron_name property is valid" do
+      provider.define_resource_requirements
+
+      expect { resource.cron_name "cron-job";   provider.process_resource_requirements }.not_to raise_error
+      expect { resource.cron_name "cron_job_0"; provider.process_resource_requirements }.not_to raise_error
+      expect { resource.cron_name "CronJob";    provider.process_resource_requirements }.not_to raise_error
+      expect { resource.cron_name "cron!";      provider.process_resource_requirements }.to raise_error "The cron job name should contain letters, numbers, hyphens and underscores only."
+      expect { resource.cron_name "cron job";   provider.process_resource_requirements }.to raise_error "The cron job name should contain letters, numbers, hyphens and underscores only."
+    end
+  end
+
+  context "not on linux" do
+    before(:each) do
+      node.automatic_attrs[:os] = "aix"
+    end
+
+    it "all cron names are valid" do
+      provider.define_resource_requirements
+
+      expect { resource.cron_name "cron-job";   provider.process_resource_requirements }.not_to raise_error
+      expect { resource.cron_name "cron_job_0"; provider.process_resource_requirements }.not_to raise_error
+      expect { resource.cron_name "CronJob";    provider.process_resource_requirements }.not_to raise_error
+      expect { resource.cron_name "cron!";      provider.process_resource_requirements }.not_to raise_error
+      expect { resource.cron_name "cron job";   provider.process_resource_requirements }.not_to raise_error
+    end
+  end
+
   it "the mode property defaults to '0600'" do
     expect(resource.mode).to eql("0600")
   end

data/spec/unit/resource/macos_user_defaults_spec.rb

@@ -39,12 +39,12 @@ describe Chef::Resource::MacosUserDefaults, :macos_only do
       expect(resource.domain).to eq("NSGlobalDomain")
     end
 
-    it ":all for the host property" do
-      expect(resource.host).to eq(:all)
+    it "nil for the host property" do
+      expect(resource.host).to be_nil
     end
 
-    it ":current for the user property" do
-      expect(resource.user).to eq(:current)
+    it "nil for the user property" do
+      expect(resource.user).to be_nil
     end
 
     it ":write for resource action" do