chef 16.18.30 → 17.10.163

data/spec/unit/provider/service/upstart_service_spec.rb

@@ -27,7 +27,6 @@ describe Chef::Provider::Service::Upstart do
     @node = Chef::Node.new
     @node.name("upstarter")
     @node.automatic_attrs[:platform] = "ubuntu"
-    @node.automatic_attrs[:platform_version] = "9.10"
 
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
@@ -36,34 +35,6 @@ describe Chef::Provider::Service::Upstart do
     @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
   end
 
-  describe "when first created" do
-    before do
-      @platform = nil
-    end
-
-    it "should return /etc/event.d as the upstart job directory when running on Ubuntu 9.04" do
-      @node.automatic_attrs[:platform_version] = "9.04"
-      # Chef::Platform.stub(:find_platform_and_version).and_return([ "ubuntu", "9.04" ])
-      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
-      expect(@provider.instance_variable_get(:@upstart_job_dir)).to eq("/etc/event.d")
-      expect(@provider.instance_variable_get(:@upstart_conf_suffix)).to eq("")
-    end
-
-    it "should return /etc/init as the upstart job directory when running on Ubuntu 9.10" do
-      @node.automatic_attrs[:platform_version] = "9.10"
-      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
-      expect(@provider.instance_variable_get(:@upstart_job_dir)).to eq("/etc/init")
-      expect(@provider.instance_variable_get(:@upstart_conf_suffix)).to eq(".conf")
-    end
-
-    it "should return /etc/init as the upstart job directory by default" do
-      @node.automatic_attrs[:platform_version] = "9000"
-      @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
-      expect(@provider.instance_variable_get(:@upstart_job_dir)).to eq("/etc/init")
-      expect(@provider.instance_variable_get(:@upstart_conf_suffix)).to eq(".conf")
-    end
-  end
-
   describe "load_current_resource" do
     before(:each) do
       @node.automatic_attrs[:command] = { ps: "ps -ax" }
@@ -189,7 +160,7 @@ describe Chef::Provider::Service::Upstart do
     it "should track state when the upstart configuration file fails to load" do
       expect(File).to receive(:exist?).and_return false
       @provider.load_current_resource
-      expect(@provider.instance_variable_get("@config_file_found")).to eq(false)
+      expect(@provider.instance_variable_get(:@config_file_found)).to eq(false)
     end
 
     describe "when a status command has been specified" do
@@ -206,7 +177,7 @@ describe Chef::Provider::Service::Upstart do
       it "should track state when the user-provided status command fails" do
         allow(@provider).to receive(:shell_out!).and_raise(Errno::ENOENT)
         @provider.load_current_resource
-        expect(@provider.instance_variable_get("@command_success")).to eq(false)
+        expect(@provider.instance_variable_get(:@command_success)).to eq(false)
       end
 
       it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
@@ -219,7 +190,7 @@ describe Chef::Provider::Service::Upstart do
     it "should track state when we fail to obtain service status via upstart_goal_state" do
       expect(@provider).to receive(:upstart_goal_state).and_raise Chef::Exceptions::Exec
       @provider.load_current_resource
-      expect(@provider.instance_variable_get("@command_success")).to eq(false)
+      expect(@provider.instance_variable_get(:@command_success)).to eq(false)
     end
 
     it "should return the current resource" do

data/spec/unit/provider/service/windows_spec.rb

@@ -33,7 +33,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
 
   # Actual response from Win32::Service.config_info('chef-client')
   let(:chef_service_binary_path_name) do
-    'C:\\opscode\\chef\\embedded\\bin\\ruby.exe C:\\opscode\\chef\\bin\\chef-windows-service'
+    "C:\\opscode\\chef\\embedded\\bin\\ruby.exe C:\\opscode\\chef\\bin\\chef-windows-service"
   end
   let(:chef_service_config_info) do
     double("Struct::ServiceConfigInfo",
@@ -153,11 +153,11 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
           service_type: "share process",
           start_type: "demand start",
           error_control: "normal",
-          binary_path_name: 'C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted',
+          binary_path_name: "C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted",
           load_order_group: "TDI",
           tag_id: 0,
           dependencies: %w{NSI Tdx Afd},
-          service_start_name: 'NT Authority\\LocalService',
+          service_start_name: "NT Authority\\LocalService",
           display_name: "DHCP Client")
       )
     end
@@ -169,11 +169,11 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
             service_type: "share process",
             start_type: "demand start",
             error_control: "normal",
-            binary_path_name: 'C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted',
+            binary_path_name: "C:\\Windows\\system32\\svchost.exe -k LocalServiceNetworkRestricted",
             load_order_group: "TDI",
             tag_id: 0,
             dependencies: %w{NSI Tdx Afd},
-            service_start_name: 'NT Authority\\LocalService',
+            service_start_name: "NT Authority\\LocalService",
             display_name: "DHCP Client")
         )
       end
@@ -254,7 +254,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       end
 
       it "logs debug message" do
-        expect(logger).to receive(:trace).with("windows_service[#{chef_service_name}] already exists - nothing to do")
+        expect(logger).to receive(:debug).with("windows_service[#{chef_service_name}] already exists - nothing to do")
         provider.action_create
       end
 
@@ -334,7 +334,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       end
 
       it "logs debug message" do
-        expect(logger).to receive(:trace).with("windows_service[#{chef_service_name}] does not exist - nothing to do")
+        expect(logger).to receive(:debug).with("windows_service[#{chef_service_name}] does not exist - nothing to do")
         provider.action_delete
       end
 

data/spec/unit/provider/subversion_spec.rb

@@ -190,7 +190,7 @@ describe Chef::Provider::Subversion do
   it "runs an export with the --force option" do
     allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, {})
+    expect(@provider).to receive(:shell_out!).with(expected_cmd)
     @provider.run_action(:force_export)
     expect(@resource).to be_updated
   end
@@ -198,7 +198,7 @@ describe Chef::Provider::Subversion do
   it "runs the checkout command for action_checkout" do
     allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn checkout -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, {})
+    expect(@provider).to receive(:shell_out!).with(expected_cmd)
     @provider.run_action(:checkout)
     expect(@resource).to be_updated
   end
@@ -248,7 +248,7 @@ describe Chef::Provider::Subversion do
     allow(@provider).to receive(:find_current_revision).and_return("11410")
     allow(@provider).to receive(:current_revision_matches_target_revision?).and_return(false)
     expected_cmd = "svn update -q   -r12345 /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, {})
+    expect(@provider).to receive(:shell_out!).with(expected_cmd)
     @provider.run_action(:sync)
     expect(@resource).to be_updated
   end
@@ -265,7 +265,7 @@ describe Chef::Provider::Subversion do
   it "runs the export_command on action_export" do
     allow(::File).to receive(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, {})
+    expect(@provider).to receive(:shell_out!).with(expected_cmd)
     @provider.run_action(:export)
     expect(@resource).to be_updated
   end
@@ -319,11 +319,11 @@ describe Chef::Provider::Subversion do
     let(:http_proxy_uri) { "http://somehost:1" }
     let(:http_no_proxy) { "svn.example.org" }
 
-    before (:all) do
+    before(:all) do
       @original_env = ENV.to_hash
     end
 
-    after (:all) do
+    after(:all) do
       ENV.clear
       ENV.update(@original_env)
     end

data/spec/unit/provider/systemd_unit_spec.rb

@@ -117,6 +117,7 @@ describe Chef::Provider::SystemdUnit, :linux_only do
       allow(provider).to receive(:enabled?).and_return(false)
       allow(provider).to receive(:masked?).and_return(false)
       allow(provider).to receive(:static?).and_return(false)
+      allow(provider).to receive(:indirect?).and_return(false)
     end
 
     it "should create a current resource with the name of the new resource" do
@@ -811,6 +812,49 @@ describe Chef::Provider::SystemdUnit, :linux_only do
         end
       end
 
+      def with_systemctl_show(systemctl_path, instance, opts, stdout)
+        systemctl_show = [systemctl_path, instance, "show", "-p", "UnitFileState", "-p", "ActiveState", unit_name]
+        expect(provider).to receive(:shell_out).with(*systemctl_show, **opts).and_return(double(stdout: stdout, exitstatus: 0, error?: false))
+      end
+
+      describe "systemd_unit_status" do
+        before(:each) do
+          provider.current_resource = current_resource
+          current_resource.unit_name(unit_name)
+        end
+
+        it "should return status if '#{systemctl_path} --system show -p UnitFileState -p ActiveState unit_name' returns 0 and has nil" do
+          # No unit known for this service, and inactive
+          nil_and_inactive = <<-STDOUT
+            ActiveState=inactive
+            UnitFileState=
+          STDOUT
+          nil_and_inactive_h = {
+            "ActiveState" => "inactive",
+            "UnitFileState" => nil,
+          }
+          with_systemctl_show(systemctl_path, "--system", {},  nil_and_inactive)
+          expect(provider.systemd_unit_status).to eql(nil_and_inactive_h)
+        end
+
+        it "should not error if '#{systemctl_path} --system show' is run against a template unit" do
+          current_resource.unit_name("foo@.service")
+          template_error = "Failed to get properties: Unit name foo@.service is neither a valid invocation ID nor unit name."
+          systemctl_show = [systemctl_path, "--system", "show", "-p", "UnitFileState", "-p", "ActiveState", "foo@.service"]
+          expect(provider).to receive(:shell_out).with(*systemctl_show).and_return(double(stdout: "", stderr: template_error, exitstatus: 1, error?: true))
+          expect(provider.systemd_unit_status).to eql({})
+        end
+      end
+
+      enabled_and_active = <<-STDOUT
+        ActiveState=active
+        UnitFileState=enabled
+      STDOUT
+      disabled_and_inactive = <<-STDOUT
+        ActiveState=disabled
+        UnitFileState=inactive
+      STDOUT
+
       describe "#active?" do
         before(:each) do
           provider.current_resource = current_resource
@@ -820,33 +864,25 @@ describe Chef::Provider::SystemdUnit, :linux_only do
         context "when a user is specified" do
           it "returns true when unit is active" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-active", unit_name, user_cmd_opts)
-              .and_return(shell_out_success)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.active?).to be true
           end
 
           it "returns false when unit is inactive" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-active", unit_name, user_cmd_opts)
-              .and_return(shell_out_failure)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, disabled_and_inactive)
             expect(provider.active?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when unit is active" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-active", unit_name)
-              .and_return(shell_out_success)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.active?).to be true
           end
 
           it "returns false when unit is not active" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-active", unit_name)
-              .and_return(shell_out_failure)
+            with_systemctl_show(systemctl_path, "--system", {}, disabled_and_inactive)
             expect(provider.active?).to be false
           end
         end
@@ -861,33 +897,25 @@ describe Chef::Provider::SystemdUnit, :linux_only do
         context "when a user is specified" do
           it "returns true when unit is enabled" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_success)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.enabled?).to be true
           end
 
           it "returns false when unit is not enabled" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_disabled)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, disabled_and_inactive)
             expect(provider.enabled?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when unit is enabled" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_success)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.enabled?).to be true
           end
 
           it "returns false when unit is not enabled" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_disabled)
+            with_systemctl_show(systemctl_path, "--system", {}, disabled_and_inactive)
             expect(provider.enabled?).to be false
           end
         end
@@ -899,36 +927,33 @@ describe Chef::Provider::SystemdUnit, :linux_only do
           allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
+        masked_and_inactive = <<-STDOUT
+          ActiveState=inactive
+          UnitFileState=masked
+        STDOUT
+
         context "when a user is specified" do
           it "returns true when the unit is masked" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "status", unit_name, user_cmd_opts)
-              .and_return(shell_out_masked)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, masked_and_inactive)
             expect(provider.masked?).to be true
           end
 
           it "returns false when the unit is not masked" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "status", unit_name, user_cmd_opts)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.masked?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when the unit is masked" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "status", unit_name)
-              .and_return(shell_out_masked)
+            with_systemctl_show(systemctl_path, "--system", {}, masked_and_inactive)
             expect(provider.masked?).to be true
           end
 
           it "returns false when the unit is not masked" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "status", unit_name)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.masked?).to be false
           end
         end
@@ -940,36 +965,33 @@ describe Chef::Provider::SystemdUnit, :linux_only do
           allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
+        static_and_active = <<-STDOUT
+          ActiveState=active
+          UnitFileState=static
+        STDOUT
+
         context "when a user is specified" do
           it "returns true when the unit is static" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, static_and_active)
             expect(provider.static?).to be true
           end
 
           it "returns false when the unit is not static" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_masked)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.static?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when the unit is static" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--system", {}, static_and_active)
             expect(provider.static?).to be true
           end
 
           it "returns false when the unit is not static" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_masked)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.static?).to be false
           end
         end
@@ -981,36 +1003,33 @@ describe Chef::Provider::SystemdUnit, :linux_only do
           allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
+        indirect_and_inactive = <<-STDOUT
+          ActiveState=inactive
+          UnitFileState=indirect
+        STDOUT
+
         context "when a user is specified" do
           it "returns true when the unit is indirect" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_indirect)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, indirect_and_inactive)
             expect(provider.indirect?).to be true
           end
 
           it "returns false when the unit is not indirect" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.indirect?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when the unit is indirect" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_indirect)
+            with_systemctl_show(systemctl_path, "--system", {}, indirect_and_inactive)
             expect(provider.indirect?).to be true
           end
 
           it "returns false when the unit is not indirect" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.indirect?).to be false
           end
         end

data/spec/unit/provider/template_spec.rb

@@ -50,7 +50,7 @@ describe Chef::Provider::Template do
 
   let(:content) do
     content = double("Chef::Provider::File::Content::Template", template_location: "/foo/bar/baz")
-    allow(File).to receive(:exists?).with("/foo/bar/baz").and_return(true)
+    allow(File).to receive(:exist?).with("/foo/bar/baz").and_return(true)
     content
   end
 
@@ -76,7 +76,7 @@ describe Chef::Provider::Template do
     it "stops executing when the local template source can't be found" do
       setup_normal_file
       allow(content).to receive(:template_location).and_return("/baz/bar/foo")
-      allow(File).to receive(:exists?).with("/baz/bar/foo").and_return(false)
+      allow(File).to receive(:exist?).with("/baz/bar/foo").and_return(false)
       expect { provider.run_action(:create) }.to raise_error Chef::Mixin::WhyRun::ResourceRequirements::Assertion::AssertionFailure
     end
 

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

@@ -70,4 +70,59 @@ describe Chef::Provider::User::Linux do
       expect( provider.useradd_options ).to eql(["-m"])
     end
   end
+
+  describe "compare_user_linux" do
+    before(:each) do
+      @new_resource = Chef::Resource::User::LinuxUser.new("notarealuser")
+      @current_resource = Chef::Resource::User::LinuxUser.new("notarealuser")
+    end
+
+    let(:mapping) do
+      {
+        "username" => %w{notarealuser notarealuser},
+        "comment" => ["Nota Realuser", "Not a Realuser"],
+        "uid" => [1000, 1001],
+        "gid" => [1000, 1001],
+        "home" => ["/home/notarealuser", "/Users/notarealuser"],
+        "shell" => ["/usr/bin/zsh", "/bin/bash"],
+        "password" => %w{abcd 12345},
+        "sensitive" => [true],
+      }
+    end
+
+    %w{uid gid comment home shell password}.each do |property|
+      it "should return true if #{property} doesn't match" do
+        @new_resource.send(property, mapping[property][0])
+        @current_resource.send(property, mapping[property][1])
+        expect(provider.compare_user).to eql(true)
+      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")
+        @current_resource.send(property, 100)
+        expect(provider.compare_user).to eql(false)
+      end
+    end
+
+    it "should return false if the objects are identical" do
+      expect(provider.compare_user).to eql(false)
+    end
+
+    it "should ignore differences in trailing slash in home paths" do
+      @new_resource.home "/home/notarealuser"
+      @current_resource.home "/home/notarealuser/"
+      expect(provider.compare_user).to eql(false)
+    end
+  end
 end

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

@@ -74,7 +74,7 @@ describe Chef::Provider::User::Solaris do
       allow(Tempfile).to receive(:new).with("shadow", "/etc").and_return(temp_file)
       new_resource.password "verysecurepassword"
       provider.manage_user
-      expect(::File.open(password_file.path, "r").read).to match(/adam:verysecurepassword:/)
+      expect(::File.read(password_file.path)).to match(/adam:verysecurepassword:/)
       password_file.unlink
     end
   end

data/spec/unit/provider/user_spec.rb

@@ -170,6 +170,7 @@ describe Chef::Provider::User do
                                                     sp_warn: 7, sp_inact: -1, sp_expire: -1, sp_flag: -1)
               expect(Shadow::Passwd).to receive(:getspnam).with("notarealuser").and_return(passwd_info)
               @provider.load_current_resource
+              @provider.action = :create
               @provider.define_resource_requirements
               @provider.process_resource_requirements
             end
@@ -180,6 +181,7 @@ describe Chef::Provider::User do
       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

data/spec/unit/provider/windows_env_spec.rb

@@ -358,7 +358,7 @@ describe "windows_env provider", :windows_only do
   context "when environment is PATH" do
     describe "for PATH" do
       let(:system_root) { "%SystemRoot%" }
-      let(:system_root_value) { 'D:\Windows' }
+      let(:system_root_value) { "D:\\Windows" }
       let(:new_resource) do
         new_resource = Chef::Resource::WindowsEnv.new("PATH", run_context)
         new_resource.value(system_root)

data/spec/unit/provider/zypper_repository_spec.rb

@@ -96,21 +96,14 @@ describe Chef::Provider::ZypperRepository do
     it "skips key import if gpgautoimportkeys is false" do
       new_resource.gpgautoimportkeys(false)
       expect(provider).to receive(:declare_resource)
-      expect(logger).to receive(:trace)
+      expect(logger).to receive(:debug)
       provider.run_action(:create)
     end
   end
 
   describe "#escaped_repo_name" do
     it "returns an escaped repo name" do
-      expect(provider.escaped_repo_name).to eq('Nginx\\ Repository')
-    end
-  end
-
-  describe "#cookbook_name" do
-    it "returns 'test' when the cookbook property is set" do
-      new_resource.cookbook("test")
-      expect(provider.cookbook_name).to eq("test")
+      expect(provider.escaped_repo_name).to eq("Nginx\\ Repository")
     end
   end
 
@@ -167,10 +160,10 @@ describe Chef::Provider::ZypperRepository do
     end
   end
 
-  describe "#install_gpg_key" do
-    it "skips installing the key if a nil value for key is passed" do
-      expect(logger).to receive(:trace)
-      provider.install_gpg_key(nil)
+  describe "#install_gpg_keys" do
+    it "skips installing the key if an empty array for key URL is passed" do
+      expect(logger).to receive(:debug)
+      provider.install_gpg_keys([])
     end
   end
 end

data/spec/unit/provider_spec.rb

@@ -32,6 +32,21 @@ class NoWhyrunDemonstrator < Chef::Provider
   end
 end
 
+class ActionDescriptionDemonstrator < Chef::Provider
+  def load_current_resource; end
+
+  action :foo, description: "foo described" do
+    true
+  end
+
+  action :foo2 do
+    true
+  end
+
+end
+
+context "blah" do
+end
 class ConvergeActionDemonstrator < Chef::Provider
   attr_reader :system_state_altered
 
@@ -98,6 +113,14 @@ describe Chef::Provider do
     expect(@provider.action_nothing).to eql(true)
   end
 
+  it "should return an action description for action_description when one is available" do
+    expect(ActionDescriptionDemonstrator.action_description(:foo)).to eq "foo described"
+  end
+
+  it "should return nil for action_description when no description is available" do
+    expect(ActionDescriptionDemonstrator.action_description(:none)).to eq nil
+  end
+
   it "evals embedded recipes with a pristine resource collection" do
     @provider.run_context.instance_variable_set(:@resource_collection, "doesn't matter what this is")
     temporary_collection = nil
@@ -189,12 +212,4 @@ describe Chef::Provider do
 
     end
   end
-
-  context "when using use_inline_resources" do
-    it "should log a deprecation warning" do
-      pending Chef::VERSION.start_with?("14.1")
-      expect(Chef).to receive(:deprecated).with(:use_inline_resources, kind_of(String))
-      Class.new(described_class) { use_inline_resources }
-    end
-  end
 end