chef 14.1.12-universal-mingw32 → 14.2.0-universal-mingw32

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

@@ -1,7 +1,7 @@
 #
 # Author:: Stephen Haynes (<sh@nomitor.com>)
 # Author:: Davide Cavalca (<dcavalca@fb.com>)
-# Copyright:: Copyright 2011-2016, Chef Software Inc.
+# Copyright:: Copyright 2011-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -36,18 +36,18 @@ describe Chef::Provider::Service::Systemd do
   let(:provider) { Chef::Provider::Service::Systemd.new(new_resource, run_context) }
 
   let(:shell_out_success) do
-    double("shell_out_with_systems_locale", :exitstatus => 0, :error? => false)
+    double("shell_out", :exitstatus => 0, :error? => false)
   end
 
   let(:shell_out_failure) do
-    double("shell_out_with_systems_locale", :exitstatus => 1, :error? => true)
+    double("shell_out", :exitstatus => 1, :error? => true)
   end
 
   let(:current_resource) { Chef::Resource::Service.new(service_name) }
 
   before(:each) do
     allow(Chef::Resource::Service).to receive(:new).with(service_name).and_return(current_resource)
-    allow(Etc).to receive(:getpwuid).and_return(OpenStruct.new(uid: 10000))
+    allow(Etc).to receive(:getpwnam).and_return(OpenStruct.new(uid: 10000))
   end
 
   describe "load_current_resource" do
@@ -170,19 +170,19 @@ describe Chef::Provider::Service::Systemd do
 
         it "should call the start command if one is specified" do
           allow(new_resource).to receive(:start_command).and_return("/sbin/rsyslog startyousillysally")
-          expect(provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog startyousillysally")
+          expect(provider).to receive(:shell_out!).with("/sbin/rsyslog startyousillysally", default_env: false)
           provider.start_service
         end
 
         context "when a user is not specified" do
           it "should call '#{systemctl_path} --system start service_name' if no start command is specified" do
-            expect(provider).to receive(:shell_out_with_systems_locale!).with("#{systemctl_path} --system start #{service_name_escaped}", {}).and_return(shell_out_success)
+            expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system start #{service_name_escaped}", default_env: false).and_return(shell_out_success)
             provider.start_service
           end
 
           it "should not call '#{systemctl_path} --system start service_name' if it is already running" do
             current_resource.running(true)
-            expect(provider).not_to receive(:shell_out_with_systems_locale!).with("#{systemctl_path} --system start #{service_name_escaped}", {})
+            expect(provider).not_to receive(:shell_out!).with("#{systemctl_path} --system start #{service_name_escaped}", {})
             provider.start_service
           end
         end
@@ -190,14 +190,14 @@ describe Chef::Provider::Service::Systemd do
         context "when a user is specified" do
           it "should call '#{systemctl_path} --user start service_name' if no start command is specified" do
             current_resource.user("joe")
-            expect(provider).to receive(:shell_out_with_systems_locale!).with("#{systemctl_path} --user start #{service_name_escaped}", { :environment => { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, :user => "joe" }).and_return(shell_out_success)
+            expect(provider).to receive(:shell_out!).with("#{systemctl_path} --user start #{service_name_escaped}", { :environment => { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, :user => "joe", default_env: false }).and_return(shell_out_success)
             provider.start_service
           end
 
           it "should not call '#{systemctl_path} --user start service_name' if it is already running" do
             current_resource.running(true)
             current_resource.user("joe")
-            expect(provider).not_to receive(:shell_out_with_systems_locale!).with("#{systemctl_path} --user start #{service_name_escaped}", { :environment => { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, :user => "joe" })
+            expect(provider).not_to receive(:shell_out!).with("#{systemctl_path} --user start #{service_name_escaped}", { :environment => { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, :user => "joe" })
             provider.start_service
           end
         end
@@ -205,13 +205,13 @@ describe Chef::Provider::Service::Systemd do
         it "should call the restart command if one is specified" do
           current_resource.running(true)
           allow(new_resource).to receive(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
-          expect(provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog restartyousillysally")
+          expect(provider).to receive(:shell_out!).with("/sbin/rsyslog restartyousillysally", default_env: false)
           provider.restart_service
         end
 
         it "should call '#{systemctl_path} --system restart service_name' if no restart command is specified" do
           current_resource.running(true)
-          expect(provider).to receive(:shell_out_with_systems_locale!).with("#{systemctl_path} --system restart #{service_name_escaped}", {}).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system restart #{service_name_escaped}", default_env: false).and_return(shell_out_success)
           provider.restart_service
         end
 
@@ -220,7 +220,7 @@ describe Chef::Provider::Service::Systemd do
             it "should call the reload command" do
               current_resource.running(true)
               allow(new_resource).to receive(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
-              expect(provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog reloadyousillysally")
+              expect(provider).to receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally", default_env: false)
               provider.reload_service
             end
           end
@@ -228,7 +228,7 @@ describe Chef::Provider::Service::Systemd do
           context "when a reload command is not specified" do
             it "should call '#{systemctl_path} --system reload service_name' if the service is running" do
               current_resource.running(true)
-              expect(provider).to receive(:shell_out_with_systems_locale!).with("#{systemctl_path} --system reload #{service_name_escaped}", {}).and_return(shell_out_success)
+              expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system reload #{service_name_escaped}", default_env: false).and_return(shell_out_success)
               provider.reload_service
             end
 
@@ -243,19 +243,19 @@ describe Chef::Provider::Service::Systemd do
         it "should call the stop command if one is specified" do
           current_resource.running(true)
           allow(new_resource).to receive(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
-          expect(provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog stopyousillysally")
+          expect(provider).to receive(:shell_out!).with("/sbin/rsyslog stopyousillysally", default_env: false)
           provider.stop_service
         end
 
         it "should call '#{systemctl_path} --system stop service_name' if no stop command is specified" do
           current_resource.running(true)
-          expect(provider).to receive(:shell_out_with_systems_locale!).with("#{systemctl_path} --system stop #{service_name_escaped}", {}).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system stop #{service_name_escaped}", default_env: false).and_return(shell_out_success)
           provider.stop_service
         end
 
         it "should not call '#{systemctl_path} --system stop service_name' if it is already stopped" do
           current_resource.running(false)
-          expect(provider).not_to receive(:shell_out_with_systems_locale!).with("#{systemctl_path} --system stop #{service_name_escaped}", {})
+          expect(provider).not_to receive(:shell_out!).with("#{systemctl_path} --system stop #{service_name_escaped}", {})
           provider.stop_service
         end
       end

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

@@ -20,7 +20,7 @@ require "spec_helper"
 
 describe Chef::Provider::Service::Upstart do
   let(:shell_out_success) do
-    double("shell_out_with_systems_locale", :exitstatus => 0, :error? => false)
+    double("shell_out", :exitstatus => 0, :error? => false)
   end
 
   before(:each) do
@@ -267,19 +267,19 @@ describe Chef::Provider::Service::Upstart do
     it "should call the start command if one is specified" do
       @provider.upstart_service_running = false
       @new_resource.start_command("/sbin/rsyslog startyousillysally")
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog startyousillysally")
+      expect(@provider).to receive(:shell_out!).with("/sbin/rsyslog startyousillysally", default_env: false)
       @provider.start_service()
     end
 
     it "should call '/sbin/start service_name' if no start command is specified" do
       @provider.upstart_service_running = false
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(shell_out_success)
+      expect(@provider).to receive(:shell_out!).with("/sbin/start #{@new_resource.service_name}", default_env: false).and_return(shell_out_success)
       @provider.start_service()
     end
 
     it "should not call '/sbin/start service_name' if it is already running" do
       @provider.upstart_service_running = true
-      expect(@provider).not_to receive(:shell_out_with_systems_locale!)
+      expect(@provider).not_to receive(:shell_out!)
       @provider.start_service()
     end
 
@@ -288,14 +288,14 @@ describe Chef::Provider::Service::Upstart do
       @new_resource.parameters({ "OSD_ID" => "2" })
       @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
       @provider.current_resource = @current_resource
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start rsyslog OSD_ID=2").and_return(shell_out_success)
+      expect(@provider).to receive(:shell_out!).with("/sbin/start rsyslog OSD_ID=2", default_env: false).and_return(shell_out_success)
       @provider.start_service()
     end
 
     it "should call the restart command if one is specified" do
       allow(@current_resource).to receive(:running).and_return(true)
       @new_resource.restart_command("/sbin/rsyslog restartyousillysally")
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog restartyousillysally")
+      expect(@provider).to receive(:shell_out!).with("/sbin/rsyslog restartyousillysally", default_env: false)
       @provider.restart_service()
     end
 
@@ -310,40 +310,40 @@ describe Chef::Provider::Service::Upstart do
     it "should call '/sbin/start service_name' if restart_service is called for a stopped service" do
       @provider.upstart_service_running = false
       allow(@current_resource).to receive(:running).and_return(false)
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(shell_out_success)
+      expect(@provider).to receive(:shell_out!).with("/sbin/start #{@new_resource.service_name}", default_env: false).and_return(shell_out_success)
       @provider.restart_service()
     end
 
     it "should call the reload command if one is specified" do
       allow(@current_resource).to receive(:running).and_return(true)
       @new_resource.reload_command("/sbin/rsyslog reloadyousillysally")
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog reloadyousillysally")
+      expect(@provider).to receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally", default_env: false)
       @provider.reload_service()
     end
 
     it "should call '/sbin/reload service_name' if no reload command is specified" do
       allow(@current_resource).to receive(:running).and_return(true)
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/reload #{@new_resource.service_name}").and_return(shell_out_success)
+      expect(@provider).to receive(:shell_out!).with("/sbin/reload #{@new_resource.service_name}", default_env: false).and_return(shell_out_success)
       @provider.reload_service()
     end
 
     it "should call the stop command if one is specified" do
       @provider.upstart_service_running = true
       @new_resource.stop_command("/sbin/rsyslog stopyousillysally")
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog stopyousillysally")
+      expect(@provider).to receive(:shell_out!).with("/sbin/rsyslog stopyousillysally", default_env: false)
       @provider.stop_service()
     end
 
     it "should call '/sbin/stop service_name' if no stop command is specified" do
       @provider.upstart_service_running = true
-      expect(@provider).to receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}").and_return(shell_out_success)
+      expect(@provider).to receive(:shell_out!).with("/sbin/stop #{@new_resource.service_name}", default_env: false).and_return(shell_out_success)
       @provider.stop_service()
     end
 
     it "should not call '/sbin/stop service_name' if it is already stopped" do
       @provider.upstart_service_running = false
       allow(@current_resource).to receive(:running).and_return(false)
-      expect(@provider).not_to receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}")
+      expect(@provider).not_to receive(:shell_out!).with("/sbin/stop #{@new_resource.service_name}", default_env: false)
       @provider.stop_service()
       expect(@upstart_service_running).to be_falsey
     end

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

@@ -801,6 +801,11 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
         provider.action_configure_startup
       end
     end
+
+    it "calls converge_delayed_start" do
+      expect(provider).to receive(:converge_delayed_start)
+      provider.action_configure_startup
+    end
   end
 
   describe Chef::Provider::Service::Windows, "set_start_type" do

data/spec/unit/provider/systemd_unit_spec.rb

@@ -58,23 +58,23 @@ describe Chef::Provider::SystemdUnit do
   end
 
   let(:shell_out_success) do
-    double("shell_out_with_systems_locale", :exitstatus => 0, :error? => false)
+    double("shell_out", :exitstatus => 0, :error? => false)
   end
 
   let(:shell_out_failure) do
-    double("shell_out_with_systems_locale", :exitstatus => 1, :error? => true)
+    double("shell_out", :exitstatus => 1, :error? => true)
   end
 
   let(:shell_out_masked) do
-    double("shell_out_with_systems_locale", :exit_status => 0, :error? => false, :stdout => "masked")
+    double("shell_out", :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")
+    double("shell_out", :exit_status => 0, :error? => false, :stdout => "static")
   end
 
   before(:each) do
-    allow(Etc).to receive(:getpwuid).and_return(OpenStruct.new(uid: 1000))
+    allow(Etc).to receive(:getpwnam).and_return(OpenStruct.new(uid: 1000))
     allow(Chef::Resource::SystemdUnit).to receive(:new)
                                             .with(unit_name)
                                             .and_return(current_resource)
@@ -280,49 +280,53 @@ describe Chef::Provider::SystemdUnit do
           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
+        context "when a user is specified" do
+          it "triggers a daemon-reload when creating a unit with triggers_reload" do
+            new_resource.user("joe")
+            allow(provider).to receive(:manage_unit_file).with(:create)
+            expect(new_resource.triggers_reload).to eq true
+            allow(provider).to receive(:shell_out!)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user daemon-reload", **user_cmd_opts, default_env: false)
+            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 "triggers a daemon-reload when deleting a unit with triggers_reload" 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)
+            expect(new_resource.triggers_reload).to eq true
+            allow(provider).to receive(:shell_out!)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user daemon-reload", **user_cmd_opts, default_env: false)
+            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 creating a unit without triggers_reload" do
+            new_resource.user("joe")
+            new_resource.triggers_reload(false)
+            allow(provider).to receive(:manage_unit_file).with(:create)
+            allow(provider).to receive(:shell_out!)
+            expect(provider).to_not receive(:shell_out!)
+                                      .with("#{systemctl_path} --user daemon-reload", **user_cmd_opts, default_env: false)
+            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
+          it "does not trigger a daemon-reload when deleting a unit without triggers_reload" do
+            new_resource.user("joe")
+            new_resource.triggers_reload(false)
+            allow(File).to receive(:exist?)
+                             .with(unit_path_user)
+                             .and_return(true)
+            allow(provider).to receive(:manage_unit_file).with(:delete)
+            allow(provider).to receive(:shell_out!)
+            expect(provider).to_not receive(:shell_out!)
+                                      .with("#{systemctl_path} --user daemon-reload", **user_cmd_opts, default_env: false)
+            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?)
@@ -348,22 +352,63 @@ describe Chef::Provider::SystemdUnit do
 
           it "presets the unit" do
             new_resource.user("joe")
-            expect(provider).to receive(:shell_out_with_systems_locale!)
-                                  .with("#{systemctl_path} --user preset #{unit_name_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user preset #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_preset
           end
 
           it "reverts the unit" do
             new_resource.user("joe")
-            expect(provider).to receive(:shell_out_with_systems_locale!)
-                                  .with("#{systemctl_path} --user revert #{unit_name_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user revert #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_revert
           end
         end
 
         context "when no user is specified" do
+          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!)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system daemon-reload", default_env: false)
+            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!)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system daemon-reload", default_env: false)
+            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!)
+            expect(provider).to_not receive(:shell_out!)
+                                      .with("#{systemctl_path} --system daemon-reload", default_env: false)
+            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!)
+            expect(provider).to_not receive(:shell_out!)
+                                      .with("#{systemctl_path} --system daemon-reload", default_env: false)
+            provider.action_delete
+          end
           it "deletes the file when it exists" do
             allow(File).to receive(:exist?)
                              .with(unit_path_system)
@@ -386,15 +431,15 @@ describe Chef::Provider::SystemdUnit do
           end
 
           it "presets the unit" do
-            expect(provider).to receive(:shell_out_with_systems_locale!)
-                                  .with("#{systemctl_path} --system preset #{unit_name_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system preset #{unit_name_escaped}", default_env: false)
                                   .and_return(shell_out_success)
             provider.action_preset
           end
 
           it "reverts the unit" do
-            expect(provider).to receive(:shell_out_with_systems_locale!)
-                                  .with("#{systemctl_path} --system revert #{unit_name_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system revert #{unit_name_escaped}", default_env: false)
                                   .and_return(shell_out_success)
             provider.action_revert
           end
@@ -405,8 +450,8 @@ describe Chef::Provider::SystemdUnit do
         context "when a user is specified" do
           it "reenables the unit" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_with_systems_locale!)
-                                  .with("#{systemctl_path} --user reenable #{unit_name_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user reenable #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_reenable
           end
@@ -414,8 +459,8 @@ describe Chef::Provider::SystemdUnit 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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user enable #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_enable
           end
@@ -423,22 +468,22 @@ describe Chef::Provider::SystemdUnit do
           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!)
+            expect(provider).not_to receive(:shell_out!)
             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!)
+            expect(provider).not_to receive(:shell_out!)
             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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user disable #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_disable
           end
@@ -446,64 +491,64 @@ describe Chef::Provider::SystemdUnit do
           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!)
+            expect(provider).not_to receive(:shell_out!)
             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!)
+            expect(provider).not_to receive(:shell_out!)
             provider.action_disable
           end
         end
 
         context "when no user is specified" do
           it "reenables the unit" do
-            expect(provider).to receive(:shell_out_with_systems_locale!)
-                                  .with("#{systemctl_path} --system reenable #{unit_name_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system reenable #{unit_name_escaped}", default_env: false)
                                   .and_return(shell_out_success)
             provider.action_reenable
           end
 
           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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system enable #{unit_name_escaped}", default_env: false)
                                   .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!)
+            expect(provider).not_to receive(:shell_out!)
             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!)
+            expect(provider).not_to receive(:shell_out!)
             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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system disable #{unit_name_escaped}", default_env: false)
                                   .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!)
+            expect(provider).not_to receive(:shell_out!)
             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!)
+            expect(provider).not_to receive(:shell_out!)
             provider.action_disable
           end
         end
@@ -514,8 +559,8 @@ describe Chef::Provider::SystemdUnit 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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user mask #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_mask
           end
@@ -523,15 +568,15 @@ describe Chef::Provider::SystemdUnit do
           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!)
+            expect(provider).not_to receive(:shell_out!)
             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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user unmask #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_unmask
           end
@@ -539,7 +584,7 @@ describe Chef::Provider::SystemdUnit do
           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!)
+            expect(provider).not_to receive(:shell_out!)
             provider.action_unmask
           end
         end
@@ -547,29 +592,29 @@ describe Chef::Provider::SystemdUnit do
         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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system mask #{unit_name_escaped}", default_env: false)
                                   .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!)
+            expect(provider).not_to receive(:shell_out!)
             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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system unmask #{unit_name_escaped}", default_env: false)
                                   .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!)
+            expect(provider).not_to receive(:shell_out!)
             provider.action_unmask
           end
         end
@@ -580,8 +625,8 @@ describe Chef::Provider::SystemdUnit 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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user start #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_start
           end
@@ -589,15 +634,15 @@ describe Chef::Provider::SystemdUnit do
           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!)
+            expect(provider).not_to receive(:shell_out!)
             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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user stop #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_stop
           end
@@ -605,7 +650,7 @@ describe Chef::Provider::SystemdUnit do
           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!)
+            expect(provider).not_to receive(:shell_out!)
             provider.action_stop
           end
         end
@@ -613,29 +658,29 @@ describe Chef::Provider::SystemdUnit do
         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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system start #{unit_name_escaped}", default_env: false)
                                   .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!)
+            expect(provider).to_not receive(:shell_out!)
             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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system stop #{unit_name_escaped}", default_env: false)
                                   .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!)
+            expect(provider).not_to receive(:shell_out!)
             provider.action_stop
           end
         end
@@ -645,8 +690,8 @@ describe Chef::Provider::SystemdUnit 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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user restart #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_restart
           end
@@ -654,8 +699,8 @@ describe Chef::Provider::SystemdUnit do
           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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user reload #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_reload
           end
@@ -663,30 +708,30 @@ describe Chef::Provider::SystemdUnit do
           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!)
+            expect(provider).not_to receive(:shell_out!)
             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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system restart #{unit_name_escaped}", default_env: false)
                                   .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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system reload #{unit_name_escaped}", default_env: false)
                                   .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!)
+            expect(provider).not_to receive(:shell_out!)
             provider.action_reload
           end
         end
@@ -696,8 +741,8 @@ describe Chef::Provider::SystemdUnit 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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user try-restart #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_try_restart
           end
@@ -705,8 +750,8 @@ describe Chef::Provider::SystemdUnit do
 
         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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system try-restart #{unit_name_escaped}", default_env: false)
                                   .and_return(shell_out_success)
             provider.action_try_restart
           end
@@ -717,8 +762,8 @@ describe Chef::Provider::SystemdUnit 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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user reload-or-restart #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_reload_or_restart
           end
@@ -726,8 +771,8 @@ describe Chef::Provider::SystemdUnit do
 
         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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system reload-or-restart #{unit_name_escaped}", default_env: false)
                                   .and_return(shell_out_success)
             provider.action_reload_or_restart
           end
@@ -738,8 +783,8 @@ describe Chef::Provider::SystemdUnit 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_escaped}", user_cmd_opts)
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --user reload-or-try-restart #{unit_name_escaped}", **user_cmd_opts, default_env: false)
                                   .and_return(shell_out_success)
             provider.action_reload_or_try_restart
           end
@@ -747,8 +792,8 @@ describe Chef::Provider::SystemdUnit do
 
         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_escaped}", {})
+            expect(provider).to receive(:shell_out!)
+                                  .with("#{systemctl_path} --system reload-or-try-restart #{unit_name_escaped}", default_env: false)
                                   .and_return(shell_out_success)
             provider.action_reload_or_try_restart
           end