chef 12.10.24-universal-mingw32 → 12.11.18-universal-mingw32

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

@@ -36,6 +36,7 @@ describe Chef::Provider::Package::Chocolatey do
   # installed packages (ConEmu is upgradable)
   let(:local_list_stdout) do
     <<-EOF
+Chocolatey v0.9.9.11
 chocolatey|0.9.9.11
 ConEmu|15.10.25.0
     EOF
@@ -50,6 +51,7 @@ ConEmu|15.10.25.0
 
   def allow_remote_list(package_names, args = nil)
     remote_list_stdout = <<-EOF
+Chocolatey v0.9.9.11
 chocolatey|0.9.9.11
 ConEmu|15.10.25.1
 Git|2.6.1
@@ -57,7 +59,7 @@ Git|2.6.2
 munin-node|1.6.1.20130823
     EOF
     remote_list_obj = double(stdout: remote_list_stdout)
-    allow(provider).to receive(:shell_out!).with("#{choco_exe} list -ar #{package_names.join ' '}#{args}", { timeout: timeout }).and_return(remote_list_obj)
+    allow(provider).to receive(:shell_out!).with("#{choco_exe} list -r #{package_names.join ' '}#{args}", { timeout: timeout }).and_return(remote_list_obj)
   end
 
   describe "#initialize" do
@@ -82,12 +84,6 @@ munin-node|1.6.1.20130823
       expect(provider.candidate_version).to eql(["2.6.1"])
     end
 
-    it "should set the candidate_version to nill if pinning to bogus version" do
-      allow_remote_list(["git"])
-      new_resource.version("2.5.0")
-      expect(provider.candidate_version).to eql([nil])
-    end
-
     it "should set the candidate_version to nil if there is no candidate" do
       allow_remote_list(["vim"])
       new_resource.package_name("vim")
@@ -299,14 +295,6 @@ munin-node|1.6.1.20130823
       expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
     end
 
-    it "installing a package version that does not exist throws an error" do
-      allow_remote_list(["git"])
-      new_resource.package_name("git")
-      new_resource.version("2.7.0")
-      provider.load_current_resource
-      expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
-    end
-
     it "installing multiple packages with a package that does not exist throws an error" do
       allow_remote_list(["git", "package-does-not-exist"])
       new_resource.package_name(["git", "package-does-not-exist"])

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

@@ -56,6 +56,12 @@ describe Chef::Provider::Package::Portage, "load_current_resource" do
       expect(@provider.current_resource.version).to eq("1.0.0-r1")
     end
 
+    it "should return a current resource with the correct version if the package is found with version with character" do
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0d"])
+      @provider.load_current_resource
+      expect(@provider.current_resource.version).to eq("1.0.0d")
+    end
+
     it "should return a current resource with a nil version if the package is not found" do
       allow(::Dir).to receive(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/notgit-1.0.0"])
       @provider.load_current_resource

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

@@ -496,12 +496,36 @@ describe Chef::Provider::Package::Rubygems do
         provider.load_current_resource
       end
 
-      it "does not query for available versions when the current version is the target version" do
-        expect(provider.candidate_version).to be_nil
+      context "when the current version is the target version" do
+        it "does not query for available versions" do
+          # NOTE: odd use case -- we've equality pinned a version, but are calling :upgrade
+          expect(provider.gem_env).not_to receive(:candidate_version_from_remote)
+          expect(provider.gem_env).not_to receive(:install)
+          provider.run_action(:upgrade)
+          expect(new_resource).not_to be_updated_by_last_action
+        end
       end
 
-      context "when the current version is not the target version" do
-        let(:target_version) { "9000.0.2" }
+      context "when the current version satisfies the target version requirement" do
+        let(:target_version) { ">= 0" }
+
+        it "does not query for available versions on install" do
+          expect(provider.gem_env).not_to receive(:candidate_version_from_remote)
+          expect(provider.gem_env).not_to receive(:install)
+          provider.run_action(:install)
+          expect(new_resource).not_to be_updated_by_last_action
+        end
+
+        it "queries for available versions on upgrade" do
+          expect(provider.gem_env).to receive(:candidate_version_from_remote).
+            and_return(Gem::Version.new("9000.0.2"))
+          expect(provider.gem_env).to receive(:install)
+          provider.run_action(:upgrade)
+          expect(new_resource).to be_updated_by_last_action
+        end
+      end
+
+      context "when the requested source is a remote server" do
         let(:source) { "http://mygems.example.com" }
 
         it "determines the candidate version by querying the remote gem servers" do
@@ -669,6 +693,11 @@ describe Chef::Provider::Package::Rubygems do
               expect(provider.gem_env).not_to receive(:install)
               provider.run_action(:install)
             end
+
+            it "performs the upgrade" do
+              expect(provider.gem_env).to receive(:install)
+              provider.run_action(:upgrade)
+            end
           end
 
           context "if the fuzzy operator is used" do
@@ -679,6 +708,11 @@ describe Chef::Provider::Package::Rubygems do
               expect(provider.gem_env).not_to receive(:install)
               provider.run_action(:install)
             end
+
+            it "it upgrades an existing gem" do
+              expect(provider.gem_env).to receive(:install)
+              provider.run_action(:upgrade)
+            end
           end
         end
       end

data/spec/unit/provider/package/yum/yum_cache_spec.rb

@@ -0,0 +1,27 @@
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+
+describe Chef::Provider::Package::Yum::YumCache do
+
+  it "can find yum-dump.py" do
+    expect(File.exist?(Chef::Provider::Package::Yum::YumCache.instance.yum_dump_path)).to be true
+  end
+
+end

data/spec/unit/provider/package_spec.rb

@@ -458,8 +458,18 @@ describe "Subclass with use_multipackage_api" do
     expect(provider.use_multipackage_api?).to be true
   end
 
-  it "offers a_to_s to subclasses to convert an array of strings to a single string" do
-    expect(provider.send(:a_to_s, "a", nil, "b", "", "c", " ", "d e", "f-g")).to eq("a b c   d e f-g")
+  context "#a_to_s utility for subclasses" do
+    it "converts varargs of strings to a single string" do
+      expect(provider.send(:a_to_s, "a", nil, "b", "", "c", " ", "d e", "f-g")).to eq("a b c   d e f-g")
+    end
+
+    it "converts an array of strings to a single string" do
+      expect(provider.send(:a_to_s, ["a", nil, "b", "", "c", " ", "d e", "f-g"])).to eq("a b c   d e f-g")
+    end
+
+    it "converts a mishmash of array args to a single string" do
+      expect(provider.send(:a_to_s, "a", [ nil, "b", "", [ "c" ] ], " ", [ "d e", "f-g" ])).to eq("a b c   d e f-g")
+    end
   end
 
   it "when user passes string to package_name, passes arrays to install_package" do
@@ -566,8 +576,11 @@ describe "Chef::Provider::Package - Multi" do
   let(:new_resource) { Chef::Resource::Package.new(%w{emacs vi}) }
   let(:current_resource) { Chef::Resource::Package.new(%w{emacs vi}) }
   let(:candidate_version) { [ "1.0", "6.2" ] }
+  class MyPackageProvider < Chef::Provider::Package
+    use_multipackage_api
+  end
   let(:provider) do
-    provider = Chef::Provider::Package.new(new_resource, run_context)
+    provider = MyPackageProvider.new(new_resource, run_context)
     provider.current_resource = current_resource
     provider.candidate_version = candidate_version
     provider
@@ -731,7 +744,7 @@ describe "Chef::Provider::Package - Multi" do
 
     it "should remove the packages if all are installed" do
       expect(provider).to be_removing_package
-      expect(provider).to receive(:remove_package).with(%w{emacs vi}, nil)
+      expect(provider).to receive(:remove_package).with(%w{emacs vi}, [nil])
       provider.run_action(:remove)
       expect(new_resource).to be_updated
       expect(new_resource).to be_updated_by_last_action
@@ -740,7 +753,7 @@ describe "Chef::Provider::Package - Multi" do
     it "should remove the packages if some are installed" do
       current_resource.version ["1.0", nil]
       expect(provider).to be_removing_package
-      expect(provider).to receive(:remove_package).with(%w{emacs vi}, nil)
+      expect(provider).to receive(:remove_package).with(%w{emacs vi}, [nil])
       provider.run_action(:remove)
       expect(new_resource).to be_updated
       expect(new_resource).to be_updated_by_last_action
@@ -787,7 +800,7 @@ describe "Chef::Provider::Package - Multi" do
 
     it "should purge the packages if all are installed" do
       expect(provider).to be_removing_package
-      expect(provider).to receive(:purge_package).with(%w{emacs vi}, nil)
+      expect(provider).to receive(:purge_package).with(%w{emacs vi}, [nil])
       provider.run_action(:purge)
       expect(new_resource).to be_updated
       expect(new_resource).to be_updated_by_last_action
@@ -796,7 +809,7 @@ describe "Chef::Provider::Package - Multi" do
     it "should purge the packages if some are installed" do
       current_resource.version ["1.0", nil]
       expect(provider).to be_removing_package
-      expect(provider).to receive(:purge_package).with(%w{emacs vi}, nil)
+      expect(provider).to receive(:purge_package).with(%w{emacs vi}, [nil])
       provider.run_action(:purge)
       expect(new_resource).to be_updated
       expect(new_resource).to be_updated_by_last_action

data/spec/unit/provider/systemd_unit_spec.rb

@@ -0,0 +1,885 @@
+#
+# Author:: Nathan Williams (<nath.e.will@gmail.com>)
+# Copyright:: Copyright (c), Nathan Williams
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+
+describe Chef::Provider::SystemdUnit do
+  let(:node) do
+    Chef::Node.new.tap do |n|
+      n.default["etc"] = {}
+      n.default["etc"]["passwd"] = {
+        "joe" => {
+          "uid" => 1_000,
+        },
+      }
+    end
+  end
+
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:unit_name) { "sysstat-collect.timer" }
+  let(:user_name) { "joe" }
+  let(:current_resource) { Chef::Resource::SystemdUnit.new(unit_name) }
+  let(:new_resource) { Chef::Resource::SystemdUnit.new(unit_name) }
+  let(:provider) { Chef::Provider::SystemdUnit.new(new_resource, run_context) }
+  let(:unit_path_system) { "/etc/systemd/system/sysstat-collect.timer" }
+  let(:unit_path_user) { "/etc/systemd/user/sysstat-collect.timer" }
+  let(:unit_content_string) { "[Unit]\nDescription = Run system activity accounting tool every 10 minutes\n\n[Timer]\nOnCalendar = *:00/10\n\n[Install]\nWantedBy = sysstat.service\n" }
+  let(:malformed_content_string) { "derp" }
+
+  let(:unit_content_hash) do
+    {
+      "Unit" => {
+        "Description" => "Run system activity accounting tool every 10 minutes",
+      },
+      "Timer" => {
+        "OnCalendar" => "*:00/10",
+      },
+      "Install" => {
+        "WantedBy" => "sysstat.service",
+      },
+    }
+  end
+
+  let(:user_cmd_opts) do
+    {
+      "user" => "joe",
+      "environment" => {
+        "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/1000/bus",
+      },
+    }
+  end
+
+  let(:shell_out_success) do
+    double("shell_out_with_systems_locale", :exitstatus => 0, :error? => false)
+  end
+
+  let(:shell_out_failure) do
+    double("shell_out_with_systems_locale", :exitstatus => 1, :error? => true)
+  end
+
+  let(:shell_out_masked) do
+    double("shell_out_with_systems_locale", :exit_status => 0, :error? => false, :stdout => "masked")
+  end
+
+  let(:shell_out_static) do
+    double("shell_out_with_systems_locale", :exit_status => 0, :error? => false, :stdout => "static")
+  end
+
+  before(:each) do
+    allow(Chef::Resource::SystemdUnit).to receive(:new)
+                                            .with(unit_name)
+                                            .and_return(current_resource)
+  end
+
+  describe "define_resource_requirements" do
+    before(:each) do
+      provider.action = :create
+      allow(provider).to receive(:active?).and_return(false)
+      allow(provider).to receive(:enabled?).and_return(false)
+      allow(provider).to receive(:masked?).and_return(false)
+      allow(provider).to receive(:static?).and_return(false)
+    end
+
+    it "accepts valid resource requirements" do
+      new_resource.content(unit_content_string)
+      provider.load_current_resource
+      provider.define_resource_requirements
+      expect { provider.process_resource_requirements }.to_not raise_error
+    end
+
+    it "rejects failed resource requirements" do
+      new_resource.content(malformed_content_string)
+      provider.load_current_resource
+      provider.define_resource_requirements
+      expect { provider.process_resource_requirements }.to raise_error(IniParse::ParseError)
+    end
+  end
+
+  describe "load_current_resource" do
+    before(:each) do
+      allow(provider).to receive(:active?).and_return(false)
+      allow(provider).to receive(:enabled?).and_return(false)
+      allow(provider).to receive(:masked?).and_return(false)
+      allow(provider).to receive(:static?).and_return(false)
+    end
+
+    it "should create a current resource with the name of the new resource" do
+      expect(Chef::Resource::SystemdUnit).to receive(:new)
+                                               .with(unit_name)
+                                               .and_return(current_resource)
+      provider.load_current_resource
+    end
+
+    it "should check if the unit is active" do
+      expect(provider).to receive(:active?)
+      provider.load_current_resource
+    end
+
+    it "sets the active property to true if the unit is active" do
+      allow(provider).to receive(:active?).and_return(true)
+      provider.load_current_resource
+      expect(current_resource.active).to be true
+    end
+
+    it "sets the active property to false if the unit is not active" do
+      allow(provider).to receive(:active?).and_return(false)
+      provider.load_current_resource
+      expect(current_resource.active).to be false
+    end
+
+    it "should check if the unit is enabled" do
+      expect(provider).to receive(:enabled?)
+      provider.load_current_resource
+    end
+
+    it "sets the enabled property to true if the unit is enabled" do
+      allow(provider).to receive(:enabled?).and_return(true)
+      provider.load_current_resource
+      expect(current_resource.enabled).to be true
+    end
+
+    it "sets the enabled property to false if the unit is not enabled" do
+      allow(provider).to receive(:enabled?).and_return(false)
+      provider.load_current_resource
+      expect(current_resource.enabled).to be false
+    end
+
+    it "should check if the unit is masked" do
+      expect(provider).to receive(:masked?)
+      provider.load_current_resource
+    end
+
+    it "sets the masked property to true if the unit is masked" do
+      allow(provider).to receive(:masked?).and_return(true)
+      provider.load_current_resource
+      expect(current_resource.masked).to be true
+    end
+
+    it "sets the masked property to false if the unit is masked" do
+      allow(provider).to receive(:masked?).and_return(false)
+      provider.load_current_resource
+      expect(current_resource.masked).to be false
+    end
+
+    it "should check if the unit is static" do
+      expect(provider).to receive(:static?)
+      provider.load_current_resource
+    end
+
+    it "sets the static property to true if the unit is static" do
+      allow(provider).to receive(:static?).and_return(true)
+      provider.load_current_resource
+      expect(current_resource.static).to be true
+    end
+
+    it "sets the static property to false if the unit is not static" do
+      allow(provider).to receive(:static?).and_return(false)
+      provider.load_current_resource
+      expect(current_resource.static).to be false
+    end
+
+    it "loads the system unit content if the file exists and user is not set" do
+      allow(File).to receive(:exist?)
+                         .with(unit_path_system)
+                         .and_return(true)
+      allow(File).to receive(:read)
+                         .with(unit_path_system)
+                         .and_return(unit_content_string)
+
+      expect(File).to receive(:exist?)
+                        .with(unit_path_system)
+      expect(File).to receive(:read)
+                        .with(unit_path_system)
+      provider.load_current_resource
+      expect(current_resource.content).to eq(unit_content_string)
+    end
+
+    it "does not load the system unit content if the unit file is not present and the user is not set" do
+      allow(File).to receive(:exist?)
+                       .with(unit_path_system)
+                       .and_return(false)
+      expect(File).to_not receive(:read)
+                            .with(unit_path_system)
+      provider.load_current_resource
+      expect(current_resource.content).to eq(nil)
+    end
+
+    it "loads the user unit content if the file exists and user is set" do
+      new_resource.user("joe")
+      allow(File).to receive(:exist?)
+                       .with(unit_path_user)
+                       .and_return(true)
+      allow(File).to receive(:read)
+                       .with(unit_path_user)
+                       .and_return(unit_content_string)
+      expect(File).to receive(:exist?)
+                        .with(unit_path_user)
+      expect(File).to receive(:read)
+                        .with(unit_path_user)
+      provider.load_current_resource
+      expect(current_resource.content).to eq(unit_content_string)
+    end
+
+    it "does not load the user unit if the file does not exist and user is set" do
+      new_resource.user("joe")
+      allow(File).to receive(:exist?)
+                       .with(unit_path_user)
+                       .and_return(false)
+      expect(File).to_not receive(:read)
+                            .with(unit_path_user)
+      provider.load_current_resource
+      expect(current_resource.content).to eq(nil)
+    end
+  end
+
+  %w{/bin/systemctl /usr/bin/systemctl}.each do |systemctl_path|
+    describe "when systemctl path is #{systemctl_path}" do
+      before(:each) do
+        provider.current_resource = current_resource
+        allow(provider).to receive(:which)
+                             .with("systemctl")
+                             .and_return(systemctl_path)
+      end
+
+      describe "creates/deletes the unit" do
+        it "creates the unit file when it does not exist" do
+          allow(provider).to receive(:manage_unit_file)
+                               .with(:create)
+                               .and_return(true)
+          allow(provider).to receive(:daemon_reload)
+                               .and_return(true)
+          expect(provider).to receive(:manage_unit_file).with(:create)
+          provider.action_create
+        end
+
+        it "creates the file when the unit content is different" do
+          allow(provider).to receive(:manage_unit_file)
+                               .with(:create)
+                               .and_return(true)
+          allow(provider).to receive(:daemon_reload)
+                               .and_return(true)
+          expect(provider).to receive(:manage_unit_file).with(:create)
+          provider.action_create
+        end
+
+        it "does not create the unit file when the content is the same" do
+          current_resource.content(unit_content_string)
+          allow(provider).to receive(:manage_unit_file).with(:create)
+          allow(provider).to receive(:daemon_reload)
+                               .and_return(true)
+          expect(provider).to_not receive(:manage_unit_file)
+          provider.action_create
+        end
+
+        it "triggers a daemon-reload when creating a unit with triggers_reload" do
+          allow(provider).to receive(:manage_unit_file).with(:create)
+          expect(new_resource.triggers_reload).to eq true
+          allow(provider).to receive(:shell_out_with_systems_locale!)
+          expect(provider).to receive(:shell_out_with_systems_locale!)
+                                .with("#{systemctl_path} daemon-reload")
+          provider.action_create
+        end
+
+        it "triggers a daemon-reload when deleting a unit with triggers_reload" do
+          allow(File).to receive(:exist?)
+                           .with(unit_path_system)
+                           .and_return(true)
+          allow(provider).to receive(:manage_unit_file).with(:delete)
+          expect(new_resource.triggers_reload).to eq true
+          allow(provider).to receive(:shell_out_with_systems_locale!)
+          expect(provider).to receive(:shell_out_with_systems_locale!)
+                                .with("#{systemctl_path} daemon-reload")
+          provider.action_delete
+        end
+
+        it "does not trigger a daemon-reload when creating a unit without triggers_reload" do
+          new_resource.triggers_reload(false)
+          allow(provider).to receive(:manage_unit_file).with(:create)
+          allow(provider).to receive(:shell_out_with_systems_locale!)
+          expect(provider).to_not receive(:shell_out_with_systems_locale!)
+                                    .with("#{systemctl_path} daemon-reload")
+          provider.action_create
+        end
+
+        it "does not trigger a daemon-reload when deleting a unit without triggers_reload" do
+          new_resource.triggers_reload(false)
+          allow(File).to receive(:exist?)
+                           .with(unit_path_system)
+                           .and_return(true)
+          allow(provider).to receive(:manage_unit_file).with(:delete)
+          allow(provider).to receive(:shell_out_with_systems_locale!)
+          expect(provider).to_not receive(:shell_out_with_systems_locale!)
+                                    .with("#{systemctl_path} daemon-reload")
+          provider.action_delete
+        end
+
+        context "when a user is specified" do
+          it "deletes the file when it exists" do
+            new_resource.user("joe")
+            allow(File).to receive(:exist?)
+                             .with(unit_path_user)
+                             .and_return(true)
+            allow(provider).to receive(:manage_unit_file)
+                                 .with(:delete)
+                                 .and_return(true)
+            allow(provider).to receive(:daemon_reload)
+            expect(provider).to receive(:manage_unit_file).with(:delete)
+            provider.action_delete
+          end
+
+          it "does not delete the file when it is absent" do
+            new_resource.user("joe")
+            allow(File).to receive(:exist?)
+                             .with(unit_path_user)
+                             .and_return(false)
+            allow(provider).to receive(:manage_unit_file).with(:delete)
+            expect(provider).to_not receive(:manage_unit_file)
+            provider.action_delete
+          end
+        end
+
+        context "when no user is specified" do
+          it "deletes the file when it exists" do
+            allow(File).to receive(:exist?)
+                             .with(unit_path_system)
+                             .and_return(true)
+            allow(provider).to receive(:manage_unit_file)
+                                 .with(:delete)
+            allow(provider).to receive(:daemon_reload)
+            expect(provider).to receive(:manage_unit_file).with(:delete)
+            provider.action_delete
+          end
+
+          it "does not delete the file when it is absent" do
+            allow(File).to receive(:exist?)
+                             .with(unit_path_system)
+                             .and_return(false)
+            allow(provider).to receive(:manage_unit_file).with(:delete)
+            allow(provider).to receive(:daemon_reload)
+            expect(provider).to_not receive(:manage_unit_file)
+            provider.action_delete
+          end
+        end
+      end
+
+      describe "enables/disables the unit" do
+        context "when a user is specified" do
+          it "enables the unit when it is disabled" do
+            current_resource.user(user_name)
+            current_resource.enabled(false)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user enable #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_enable
+          end
+
+          it "does not enable the unit when it is enabled" do
+            current_resource.user(user_name)
+            current_resource.enabled(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_enable
+          end
+
+          it "does not enable the unit when it is static" do
+            current_resource.user(user_name)
+            current_resource.static(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_enable
+          end
+
+          it "disables the unit when it is enabled" do
+            current_resource.user(user_name)
+            current_resource.enabled(true)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user disable #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_disable
+          end
+
+          it "does not disable the unit when it is disabled" do
+            current_resource.user(user_name)
+            current_resource.enabled(false)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_disable
+          end
+
+          it "does not disable the unit when it is static" do
+            current_resource.user(user_name)
+            current_resource.static(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_disable
+          end
+        end
+
+        context "when no user is specified" do
+          it "enables the unit when it is disabled" do
+            current_resource.enabled(false)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system enable #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_enable
+          end
+
+          it "does not enable the unit when it is enabled" do
+            current_resource.enabled(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_enable
+          end
+
+          it "does not enable the unit when it is static" do
+            current_resource.static(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_enable
+          end
+
+          it "disables the unit when it is enabled" do
+            current_resource.enabled(true)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system disable #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_disable
+          end
+
+          it "does not disable the unit when it is disabled" do
+            current_resource.enabled(false)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_disable
+          end
+
+          it "does not disable the unit when it is static" do
+            current_resource.user(user_name)
+            current_resource.static(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_disable
+          end
+        end
+      end
+
+      describe "masks/unmasks the unit" do
+        context "when a user is specified" do
+          it "masks the unit when it is unmasked" do
+            current_resource.user(user_name)
+            current_resource.masked(false)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user mask #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_mask
+          end
+
+          it "does not mask the unit when it is masked" do
+            current_resource.user(user_name)
+            current_resource.masked(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_mask
+          end
+
+          it "unmasks the unit when it is masked" do
+            current_resource.user(user_name)
+            current_resource.masked(true)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user unmask #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_unmask
+          end
+
+          it "does not unmask the unit when it is unmasked" do
+            current_resource.user(user_name)
+            current_resource.masked(false)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_unmask
+          end
+        end
+
+        context "when no user is specified" do
+          it "masks the unit when it is unmasked" do
+            current_resource.masked(false)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system mask #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_mask
+          end
+
+          it "does not mask the unit when it is masked" do
+            current_resource.masked(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_mask
+          end
+
+          it "unmasks the unit when it is masked" do
+            current_resource.masked(true)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system unmask #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_unmask
+          end
+
+          it "does not unmask the unit when it is unmasked" do
+            current_resource.masked(false)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_unmask
+          end
+        end
+      end
+
+      describe "starts/stops the unit" do
+        context "when a user is specified" do
+          it "starts the unit when it is inactive" do
+            current_resource.user(user_name)
+            current_resource.active(false)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user start #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_start
+          end
+
+          it "does not start the unit when it is active" do
+            current_resource.user(user_name)
+            current_resource.active(true)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_start
+          end
+
+          it "stops the unit when it is active" do
+            current_resource.user(user_name)
+            current_resource.active(true)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user stop #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_stop
+          end
+
+          it "does not stop the unit when it is inactive" do
+            current_resource.user(user_name)
+            current_resource.active(false)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_stop
+          end
+        end
+
+        context "when no user is specified" do
+          it "starts the unit when it is inactive" do
+            current_resource.active(false)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system start #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_start
+          end
+
+          it "does not start the unit when it is active" do
+            current_resource.active(true)
+            expect(provider).to_not receive(:shell_out_with_systems_locale!)
+            provider.action_start
+          end
+
+          it "stops the unit when it is active" do
+            current_resource.active(true)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system stop #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_stop
+          end
+
+          it "does not stop the unit when it is inactive" do
+            current_resource.active(false)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_stop
+          end
+        end
+      end
+
+      describe "restarts/reloads the unit" do
+        context "when a user is specified" do
+          it "restarts the unit" do
+            current_resource.user(user_name)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user restart #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_restart
+          end
+
+          it "reloads the unit if active" do
+            current_resource.user(user_name)
+            current_resource.active(true)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user reload #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_reload
+          end
+
+          it "does not reload if the unit is inactive" do
+            current_resource.user(user_name)
+            current_resource.active(false)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_reload
+          end
+        end
+
+        context "when no user is specified" do
+          it "restarts the unit" do
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system restart #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_restart
+          end
+
+          it "reloads the unit if active" do
+            current_resource.active(true)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system reload #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_reload
+          end
+
+          it "does not reload the unit if inactive" do
+            current_resource.active(false)
+            expect(provider).not_to receive(:shell_out_with_systems_locale!)
+            provider.action_reload
+          end
+        end
+      end
+
+      describe "try-restarts the unit" do
+        context "when a user is specified" do
+          it "try-restarts the unit" do
+            current_resource.user(user_name)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user try-restart #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_try_restart
+          end
+        end
+
+        context "when no user is specified" do
+          it "try-restarts the unit" do
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system try-restart #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_try_restart
+          end
+        end
+      end
+
+      describe "reload-or-restarts the unit" do
+        context "when a user is specified" do
+          it "reload-or-restarts the unit" do
+            current_resource.user(user_name)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user reload-or-restart #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_reload_or_restart
+          end
+        end
+
+        context "when no user is specified" do
+          it "reload-or-restarts the unit" do
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system reload-or-restart #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_reload_or_restart
+          end
+        end
+      end
+
+      describe "reload-or-try-restarts the unit" do
+        context "when a user is specified" do
+          it "reload-or-try-restarts the unit" do
+            current_resource.user(user_name)
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --user reload-or-try-restart #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            provider.action_reload_or_try_restart
+          end
+        end
+
+        context "when no user is specified" do
+          it "reload-or-try-restarts the unit" do
+            expect(provider).to receive(:shell_out_with_systems_locale!)
+                                  .with("#{systemctl_path} --system reload-or-try-restart #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            provider.action_reload_or_try_restart
+          end
+        end
+      end
+
+      describe "#active?" do
+        before(:each) do
+          provider.current_resource = current_resource
+          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+        end
+
+        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)
+                                  .with("#{systemctl_path} --user is-active #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            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)
+                                  .with("#{systemctl_path} --user is-active #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_failure)
+            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)
+                                  .with("#{systemctl_path} --system is-active #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            expect(provider.active?).to be true
+          end
+
+          it "returns false when unit is not active" do
+            expect(provider).to receive(:shell_out)
+                                  .with("#{systemctl_path} --system is-active #{unit_name}", {})
+                                  .and_return(shell_out_failure)
+            expect(provider.active?).to be false
+          end
+        end
+      end
+
+      describe "#enabled?" do
+        before(:each) do
+          provider.current_resource = current_resource
+          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+        end
+
+        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)
+                                  .with("#{systemctl_path} --user is-enabled #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_success)
+            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)
+                                  .with("#{systemctl_path} --user is-enabled #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_failure)
+            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)
+                                  .with("#{systemctl_path} --system is-enabled #{unit_name}", {})
+                                  .and_return(shell_out_success)
+            expect(provider.enabled?).to be true
+          end
+
+          it "returns false when unit is not enabled" do
+            expect(provider).to receive(:shell_out)
+                                  .with("#{systemctl_path} --system is-enabled #{unit_name}", {})
+                                  .and_return(shell_out_failure)
+            expect(provider.enabled?).to be false
+          end
+        end
+      end
+
+      describe "#masked?" do
+        before(:each) do
+          provider.current_resource = current_resource
+          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+        end
+
+        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)
+                                  .with("#{systemctl_path} --user status #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_masked)
+            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)
+                                  .with("#{systemctl_path} --user status #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_static)
+            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)
+                                  .with("#{systemctl_path} --system status #{unit_name}", {})
+                                  .and_return(shell_out_masked)
+            expect(provider.masked?).to be true
+          end
+
+          it "returns false when the unit is not masked" do
+            expect(provider).to receive(:shell_out)
+                                  .with("#{systemctl_path} --system status #{unit_name}", {})
+                                  .and_return(shell_out_static)
+            expect(provider.masked?).to be false
+          end
+        end
+      end
+
+      describe "#static?" do
+        before(:each) do
+          provider.current_resource = current_resource
+          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+        end
+
+        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)
+                                  .with("#{systemctl_path} --user is-enabled #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_static)
+            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)
+                                  .with("#{systemctl_path} --user is-enabled #{unit_name}", user_cmd_opts)
+                                  .and_return(shell_out_masked)
+            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)
+                                  .with("#{systemctl_path} --system is-enabled #{unit_name}", {})
+                                  .and_return(shell_out_static)
+            expect(provider.static?).to be true
+          end
+
+          it "returns false when the unit is not static" do
+            expect(provider).to receive(:shell_out)
+                                  .with("#{systemctl_path} --system is-enabled #{unit_name}", {})
+                                  .and_return(shell_out_masked)
+            expect(provider.static?).to be false
+          end
+        end
+      end
+    end
+  end
+end