chef 14.14.29-universal-mingw32 → 14.15.6-universal-mingw32

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

@@ -41,8 +41,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
       tag_id: 0,
       dependencies: ["Winmgmt"],
       service_start_name: "LocalSystem",
-      display_name: "Chef Client Service"
-    )
+      display_name: "Chef Client Service")
   end
 
   # Actual response from Win32::Service.services
@@ -73,8 +72,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
       command: nil,
       num_actions: 0,
       actions: nil,
-      delayed_start: 1
-    )
+      delayed_start: 1)
   end
 
   let(:provider) do
@@ -98,7 +96,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     allow(Win32::Service).to receive(:start).with(any_args).and_return(Win32::Service)
     allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-      double("StatusStruct", current_state: "running"))
+      double("StatusStruct", current_state: "running")
+    )
     allow(Win32::Service).to receive(:config_info).with(new_resource.service_name)
       .and_return(chef_service_config_info)
 
@@ -176,8 +175,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
           tag_id: 0,
           dependencies: %w{NSI Tdx Afd},
           service_start_name: 'NT Authority\\LocalService',
-          display_name: "DHCP Client"
-        ))
+          display_name: "DHCP Client")
+      )
     end
 
     context "startup_type is neither :automatic or :disabled" do
@@ -192,8 +191,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
             tag_id: 0,
             dependencies: %w{NSI Tdx Afd},
             service_start_name: 'NT Authority\\LocalService',
-            display_name: "DHCP Client"
-          ))
+            display_name: "DHCP Client")
+        )
       end
 
       it "does not set the current resources enabled" do
@@ -385,14 +384,14 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
       # properties that are Strings
       %i{binary_path_name load_order_group dependencies run_as_user
          display_name description}.each do |attr|
-        it "configures service if #{attr} has changed" do
-          provider.current_resource.send("#{attr}=", "old value")
-          provider.new_resource.send("#{attr}=", "new value")
+           it "configures service if #{attr} has changed" do
+             provider.current_resource.send("#{attr}=", "old value")
+             provider.new_resource.send("#{attr}=", "new value")
 
-          expect(Win32::Service).to receive(:configure)
-          provider.action_configure
-        end
-      end
+             expect(Win32::Service).to receive(:configure)
+             provider.action_configure
+           end
+         end
 
       # properties that are Integers
       %i{service_type error_control}.each do |attr|
@@ -503,7 +502,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
     before(:each) do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", current_state: "stopped"),
-        double("StatusStruct", current_state: "running"))
+        double("StatusStruct", current_state: "running")
+      )
     end
 
     context "run_as_user user is specified" do
@@ -553,7 +553,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "does nothing if the service is running" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", current_state: "running"))
+        double("StatusStruct", current_state: "running")
+      )
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       provider.start_service
@@ -562,7 +563,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "raises an error if the service is paused" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", current_state: "paused"))
+        double("StatusStruct", current_state: "paused")
+      )
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       expect { provider.start_service }.to raise_error( Chef::Exceptions::Service )
@@ -573,7 +575,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", current_state: "start pending"),
         double("StatusStruct", current_state: "start pending"),
-        double("StatusStruct", current_state: "running"))
+        double("StatusStruct", current_state: "running")
+      )
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       provider.start_service
@@ -582,7 +585,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "fails if the service is in stop_pending" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", current_state: "stop pending"))
+        double("StatusStruct", current_state: "stop pending")
+      )
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       expect { provider.start_service }.to raise_error( Chef::Exceptions::Service )
@@ -623,7 +627,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
     before(:each) do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", current_state: "running"),
-        double("StatusStruct", current_state: "stopped"))
+        double("StatusStruct", current_state: "stopped")
+      )
     end
 
     it "calls the stop command if one is specified" do
@@ -648,7 +653,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "does nothing if the service is stopped" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", current_state: "stopped"))
+        double("StatusStruct", current_state: "stopped")
+      )
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
       provider.stop_service
@@ -657,7 +663,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "raises an error if the service is paused" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", current_state: "paused"))
+        double("StatusStruct", current_state: "paused")
+      )
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(new_resource.service_name)
       expect { provider.stop_service }.to raise_error( Chef::Exceptions::Service )
@@ -668,7 +675,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", current_state: "stop pending"),
         double("StatusStruct", current_state: "stop pending"),
-        double("StatusStruct", current_state: "stopped"))
+        double("StatusStruct", current_state: "stopped")
+      )
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
       provider.stop_service
@@ -677,7 +685,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "fails if the service is in start_pending" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", current_state: "start pending"))
+        double("StatusStruct", current_state: "start pending")
+      )
       provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(new_resource.service_name)
       expect { provider.stop_service }.to raise_error( Chef::Exceptions::Service )
@@ -686,7 +695,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
 
     it "passes custom timeout to the stop command if provided" do
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
-        double("StatusStruct", current_state: "running"))
+        double("StatusStruct", current_state: "running")
+      )
       new_resource.timeout 1
       expect(Win32::Service).to receive(:stop).with(new_resource.service_name)
       Timeout.timeout(2) do
@@ -711,7 +721,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
         double("StatusStruct", current_state: "running"),
         double("StatusStruct", current_state: "stopped"),
         double("StatusStruct", current_state: "stopped"),
-        double("StatusStruct", current_state: "running"))
+        double("StatusStruct", current_state: "running")
+      )
       expect(Win32::Service).to receive(:stop).with(new_resource.service_name)
       expect(Win32::Service).to receive(:start).with(new_resource.service_name)
       provider.restart_service
@@ -722,7 +733,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
       allow(Win32::Service).to receive(:status).with(new_resource.service_name).and_return(
         double("StatusStruct", current_state: "stopped"),
         double("StatusStruct", current_state: "stopped"),
-        double("StatusStruct", current_state: "running"))
+        double("StatusStruct", current_state: "running")
+      )
       expect(Win32::Service).to receive(:start).with(new_resource.service_name)
       provider.restart_service
       expect(new_resource.updated_by_last_action?).to be_truthy
@@ -741,7 +753,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "enable_service" do
     before(:each) do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", start_type: "disabled"))
+        double("ConfigStruct", start_type: "disabled")
+      )
     end
 
     it "enables service" do
@@ -761,14 +774,16 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "action_enable" do
     it "does nothing if the service is enabled" do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", start_type: "auto start"))
+        double("ConfigStruct", start_type: "auto start")
+      )
       expect(provider).not_to receive(:enable_service)
       provider.action_enable
     end
 
     it "enables the service if it is not set to automatic start" do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", start_type: "disabled"))
+        double("ConfigStruct", start_type: "disabled")
+      )
       expect(provider).to receive(:enable_service)
       provider.action_enable
     end
@@ -777,14 +792,16 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "action_disable" do
     it "does nothing if the service is disabled" do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", start_type: "disabled"))
+        double("ConfigStruct", start_type: "disabled")
+      )
       expect(provider).not_to receive(:disable_service)
       provider.action_disable
     end
 
     it "disables the service if it is not set to disabled" do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", start_type: "auto start"))
+        double("ConfigStruct", start_type: "auto start")
+      )
       expect(provider).to receive(:disable_service)
       provider.action_disable
     end
@@ -793,7 +810,8 @@ describe Chef::Provider::Service::Windows, "load_current_resource", :windows_onl
   describe Chef::Provider::Service::Windows, "disable_service" do
     before(:each) do
       allow(Win32::Service).to receive(:config_info).with(new_resource.service_name).and_return(
-        double("ConfigStruct", start_type: "auto start"))
+        double("ConfigStruct", start_type: "auto start")
+      )
     end
 
     it "disables service" do

data/spec/unit/provider/subversion_spec.rb

@@ -277,7 +277,8 @@ describe Chef::Provider::Subversion do
       allow(ChefConfig).to receive(:windows?) { false }
       expect(@provider).to receive(:svn_binary).and_return("svn")
       expect(@provider.export_command).to eql(
-        "svn export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir")
+        "svn export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
+      )
     end
 
     it "selects an svn binary with an exe extension on windows" do
@@ -285,21 +286,24 @@ describe Chef::Provider::Subversion do
       allow(ChefConfig).to receive(:windows?) { true }
       expect(@provider).to receive(:svn_binary).and_return("svn.exe")
       expect(@provider.export_command).to eql(
-        "svn.exe export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir")
+        "svn.exe export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
+      )
     end
 
     it "uses a custom svn binary as part of the svn command" do
       @resource.svn_binary "teapot"
       expect(@provider).to receive(:svn_binary).and_return("teapot")
       expect(@provider.export_command).to eql(
-        "teapot export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir")
+        "teapot export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
+      )
     end
 
     it "wraps custom svn binary with quotes if it contains whitespace" do
       @resource.svn_binary "c:/program files (x86)/subversion/svn.exe"
       expect(@provider).to receive(:svn_binary).and_return("c:/program files (x86)/subversion/svn.exe")
       expect(@provider.export_command).to eql(
-        '"c:/program files (x86)/subversion/svn.exe" export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir')
+        '"c:/program files (x86)/subversion/svn.exe" export --force -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir'
+      )
     end
 
   end

data/spec/unit/provider/systemd_unit_spec.rb

@@ -83,8 +83,8 @@ describe Chef::Provider::SystemdUnit do
   before(:each) do
     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)
+      .with(unit_name)
+      .and_return(current_resource)
   end
 
   describe "define_resource_requirements" do
@@ -121,8 +121,8 @@ describe Chef::Provider::SystemdUnit do
 
     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)
+        .with(unit_name)
+        .and_return(current_resource)
       provider.load_current_resource
     end
 
@@ -196,26 +196,26 @@ describe Chef::Provider::SystemdUnit do
 
     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)
+        .with(unit_path_system)
+        .and_return(true)
       allow(File).to receive(:read)
-                         .with(unit_path_system)
-                         .and_return(unit_content_string)
+        .with(unit_path_system)
+        .and_return(unit_content_string)
 
       expect(File).to receive(:exist?)
-                        .with(unit_path_system)
+        .with(unit_path_system)
       expect(File).to receive(:read)
-                        .with(unit_path_system)
+        .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)
+        .with(unit_path_system)
+        .and_return(false)
       expect(File).to_not receive(:read)
-                            .with(unit_path_system)
+        .with(unit_path_system)
       provider.load_current_resource
       expect(current_resource.content).to eq(nil)
     end
@@ -223,15 +223,15 @@ describe Chef::Provider::SystemdUnit do
     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)
+        .with(unit_path_user)
+        .and_return(true)
       allow(File).to receive(:read)
-                       .with(unit_path_user)
-                       .and_return(unit_content_string)
+        .with(unit_path_user)
+        .and_return(unit_content_string)
       expect(File).to receive(:exist?)
-                        .with(unit_path_user)
+        .with(unit_path_user)
       expect(File).to receive(:read)
-                        .with(unit_path_user)
+        .with(unit_path_user)
       provider.load_current_resource
       expect(current_resource.content).to eq(unit_content_string)
     end
@@ -239,10 +239,10 @@ describe Chef::Provider::SystemdUnit do
     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)
+        .with(unit_path_user)
+        .and_return(false)
       expect(File).to_not receive(:read)
-                            .with(unit_path_user)
+        .with(unit_path_user)
       provider.load_current_resource
       expect(current_resource.content).to eq(nil)
     end
@@ -253,27 +253,27 @@ describe Chef::Provider::SystemdUnit do
       before(:each) do
         provider.current_resource = current_resource
         allow(provider).to receive(:which)
-                             .with("systemctl")
-                             .and_return(systemctl_path)
+          .with("systemctl")
+          .and_return(systemctl_path)
       end
 
       describe "creates/deletes/presets/reverts 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)
+            .with(:create)
+            .and_return(true)
           allow(provider).to receive(:daemon_reload)
-                               .and_return(true)
+            .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)
+            .with(:create)
+            .and_return(true)
           allow(provider).to receive(:daemon_reload)
-                               .and_return(true)
+            .and_return(true)
           expect(provider).to receive(:manage_unit_file).with(:create)
           provider.action_create
         end
@@ -282,7 +282,7 @@ describe Chef::Provider::SystemdUnit 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)
+            .and_return(true)
           expect(provider).to_not receive(:manage_unit_file)
           provider.action_create
         end
@@ -294,20 +294,20 @@ describe Chef::Provider::SystemdUnit do
             expect(new_resource.triggers_reload).to eq true
             allow(provider).to receive(:shell_out_compacted!)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "daemon-reload", **user_cmd_opts, default_env: false)
+              .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
             new_resource.user("joe")
             allow(File).to receive(:exist?)
-                             .with(unit_path_user)
-                             .and_return(true)
+              .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_compacted!)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "daemon-reload", **user_cmd_opts, default_env: false)
+              .with(systemctl_path, "--user", "daemon-reload", **user_cmd_opts, default_env: false)
             provider.action_delete
           end
 
@@ -317,7 +317,7 @@ describe Chef::Provider::SystemdUnit do
             allow(provider).to receive(:manage_unit_file).with(:create)
             allow(provider).to receive(:shell_out_compacted!)
             expect(provider).to_not receive(:shell_out_compacted!)
-                                      .with(systemctl_path, "--user", "daemon-reload", **user_cmd_opts, default_env: false)
+              .with(systemctl_path, "--user", "daemon-reload", **user_cmd_opts, default_env: false)
             provider.action_create
           end
 
@@ -325,23 +325,23 @@ describe Chef::Provider::SystemdUnit do
             new_resource.user("joe")
             new_resource.triggers_reload(false)
             allow(File).to receive(:exist?)
-                             .with(unit_path_user)
-                             .and_return(true)
+              .with(unit_path_user)
+              .and_return(true)
             allow(provider).to receive(:manage_unit_file).with(:delete)
             allow(provider).to receive(:shell_out_compacted!)
             expect(provider).to_not receive(:shell_out_compacted!)
-                                      .with(systemctl_path, "--user", "daemon-reload", **user_cmd_opts, default_env: false)
+              .with(systemctl_path, "--user", "daemon-reload", **user_cmd_opts, default_env: false)
             provider.action_delete
           end
 
           it "deletes the file when it exists" do
             new_resource.user("joe")
             allow(File).to receive(:exist?)
-                             .with(unit_path_user)
-                             .and_return(true)
+              .with(unit_path_user)
+              .and_return(true)
             allow(provider).to receive(:manage_unit_file)
-                                 .with(:delete)
-                                 .and_return(true)
+              .with(:delete)
+              .and_return(true)
             allow(provider).to receive(:daemon_reload)
             expect(provider).to receive(:manage_unit_file).with(:delete)
             provider.action_delete
@@ -350,8 +350,8 @@ describe Chef::Provider::SystemdUnit do
           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)
+              .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
@@ -360,16 +360,16 @@ describe Chef::Provider::SystemdUnit do
           it "presets the unit" do
             new_resource.user("joe")
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "preset", unit_name, **user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "preset", unit_name, **user_cmd_opts)
+              .and_return(shell_out_success)
             provider.action_preset
           end
 
           it "reverts the unit" do
             new_resource.user("joe")
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "revert", unit_name, **user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "revert", unit_name, **user_cmd_opts)
+              .and_return(shell_out_success)
             provider.action_revert
           end
         end
@@ -380,19 +380,19 @@ describe Chef::Provider::SystemdUnit do
             expect(new_resource.triggers_reload).to eq true
             allow(provider).to receive(:shell_out_compacted!)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "daemon-reload", default_env: false)
+              .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)
+              .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_compacted!)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "daemon-reload", default_env: false)
+              .with(systemctl_path, "--system", "daemon-reload", default_env: false)
             provider.action_delete
           end
 
@@ -401,27 +401,27 @@ describe Chef::Provider::SystemdUnit do
             allow(provider).to receive(:manage_unit_file).with(:create)
             allow(provider).to receive(:shell_out_compacted!)
             expect(provider).to_not receive(:shell_out_compacted!)
-                                      .with(systemctl_path, "--system", "daemon-reload", default_env: false)
+              .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)
+              .with(unit_path_system)
+              .and_return(true)
             allow(provider).to receive(:manage_unit_file).with(:delete)
             allow(provider).to receive(:shell_out_compacted!)
             expect(provider).to_not receive(:shell_out_compacted!)
-                                      .with(systemctl_path, "--system", "daemon-reload", default_env: false)
+              .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)
-                             .and_return(true)
+              .with(unit_path_system)
+              .and_return(true)
             allow(provider).to receive(:manage_unit_file)
-                                 .with(:delete)
+              .with(:delete)
             allow(provider).to receive(:daemon_reload)
             expect(provider).to receive(:manage_unit_file).with(:delete)
             provider.action_delete
@@ -429,8 +429,8 @@ describe Chef::Provider::SystemdUnit do
 
           it "does not delete the file when it is absent" do
             allow(File).to receive(:exist?)
-                             .with(unit_path_system)
-                             .and_return(false)
+              .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)
@@ -439,15 +439,15 @@ describe Chef::Provider::SystemdUnit do
 
           it "presets the unit" do
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "preset", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "preset", unit_name)
+              .and_return(shell_out_success)
             provider.action_preset
           end
 
           it "reverts the unit" do
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "revert", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "revert", unit_name)
+              .and_return(shell_out_success)
             provider.action_revert
           end
         end
@@ -458,8 +458,8 @@ describe Chef::Provider::SystemdUnit do
           it "reenables the unit" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "reenable", unit_name, **user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "reenable", unit_name, **user_cmd_opts)
+              .and_return(shell_out_success)
             provider.action_reenable
           end
 
@@ -467,8 +467,8 @@ describe Chef::Provider::SystemdUnit do
             current_resource.user(user_name)
             current_resource.enabled(false)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "enable", unit_name, **user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "enable", unit_name, **user_cmd_opts)
+              .and_return(shell_out_success)
             provider.action_enable
           end
 
@@ -490,8 +490,8 @@ describe Chef::Provider::SystemdUnit do
             current_resource.user(user_name)
             current_resource.enabled(true)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "disable", unit_name, **user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "disable", unit_name, **user_cmd_opts)
+              .and_return(shell_out_success)
             provider.action_disable
           end
 
@@ -513,16 +513,16 @@ describe Chef::Provider::SystemdUnit do
         context "when no user is specified" do
           it "reenables the unit" do
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "reenable", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "reenable", unit_name)
+              .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_compacted!)
-                                  .with(systemctl_path, "--system", "enable", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "enable", unit_name)
+              .and_return(shell_out_success)
             provider.action_enable
           end
 
@@ -541,8 +541,8 @@ describe Chef::Provider::SystemdUnit do
           it "disables the unit when it is enabled" do
             current_resource.enabled(true)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "disable", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "disable", unit_name)
+              .and_return(shell_out_success)
             provider.action_disable
           end
 
@@ -567,8 +567,8 @@ describe Chef::Provider::SystemdUnit do
             current_resource.user(user_name)
             current_resource.masked(false)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "mask", unit_name, **user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "mask", unit_name, **user_cmd_opts)
+              .and_return(shell_out_success)
             provider.action_mask
           end
 
@@ -583,8 +583,8 @@ describe Chef::Provider::SystemdUnit do
             current_resource.user(user_name)
             current_resource.masked(true)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "unmask", unit_name, **user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "unmask", unit_name, **user_cmd_opts)
+              .and_return(shell_out_success)
             provider.action_unmask
           end
 
@@ -600,8 +600,8 @@ describe Chef::Provider::SystemdUnit do
           it "masks the unit when it is unmasked" do
             current_resource.masked(false)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "mask", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "mask", unit_name)
+              .and_return(shell_out_success)
             provider.action_mask
           end
 
@@ -614,8 +614,8 @@ describe Chef::Provider::SystemdUnit do
           it "unmasks the unit when it is masked" do
             current_resource.masked(true)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "unmask", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "unmask", unit_name)
+              .and_return(shell_out_success)
             provider.action_unmask
           end
 
@@ -633,8 +633,8 @@ describe Chef::Provider::SystemdUnit do
             current_resource.user(user_name)
             current_resource.active(false)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "start", unit_name, **user_cmd_opts, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "start", unit_name, **user_cmd_opts, default_env: false)
+              .and_return(shell_out_success)
             provider.action_start
           end
 
@@ -649,8 +649,8 @@ describe Chef::Provider::SystemdUnit do
             current_resource.user(user_name)
             current_resource.active(true)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "stop", unit_name, **user_cmd_opts, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "stop", unit_name, **user_cmd_opts, default_env: false)
+              .and_return(shell_out_success)
             provider.action_stop
           end
 
@@ -666,8 +666,8 @@ describe Chef::Provider::SystemdUnit do
           it "starts the unit when it is inactive" do
             current_resource.active(false)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "start", unit_name, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "start", unit_name, default_env: false)
+              .and_return(shell_out_success)
             provider.action_start
           end
 
@@ -680,8 +680,8 @@ describe Chef::Provider::SystemdUnit do
           it "stops the unit when it is active" do
             current_resource.active(true)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "stop", unit_name, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "stop", unit_name, default_env: false)
+              .and_return(shell_out_success)
             provider.action_stop
           end
 
@@ -698,8 +698,8 @@ describe Chef::Provider::SystemdUnit do
           it "restarts the unit" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "restart", unit_name, **user_cmd_opts, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "restart", unit_name, **user_cmd_opts, default_env: false)
+              .and_return(shell_out_success)
             provider.action_restart
           end
 
@@ -707,8 +707,8 @@ describe Chef::Provider::SystemdUnit do
             current_resource.user(user_name)
             current_resource.active(true)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "reload", unit_name, **user_cmd_opts, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "reload", unit_name, **user_cmd_opts, default_env: false)
+              .and_return(shell_out_success)
             provider.action_reload
           end
 
@@ -723,16 +723,16 @@ describe Chef::Provider::SystemdUnit do
         context "when no user is specified" do
           it "restarts the unit" do
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--system", "restart", unit_name, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "restart", unit_name, 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_compacted!)
-                                  .with(systemctl_path, "--system", "reload", unit_name, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "reload", unit_name, default_env: false)
+              .and_return(shell_out_success)
             provider.action_reload
           end
 
@@ -749,8 +749,8 @@ describe Chef::Provider::SystemdUnit do
           it "try-restarts the unit" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "try-restart", unit_name, **user_cmd_opts, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "try-restart", unit_name, **user_cmd_opts, default_env: false)
+              .and_return(shell_out_success)
             provider.action_try_restart
           end
         end
@@ -758,8 +758,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_compacted!)
-                                  .with(systemctl_path, "--system", "try-restart", unit_name, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "try-restart", unit_name, default_env: false)
+              .and_return(shell_out_success)
             provider.action_try_restart
           end
         end
@@ -770,8 +770,8 @@ describe Chef::Provider::SystemdUnit do
           it "reload-or-restarts the unit" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "reload-or-restart", unit_name, **user_cmd_opts, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "reload-or-restart", unit_name, **user_cmd_opts, default_env: false)
+              .and_return(shell_out_success)
             provider.action_reload_or_restart
           end
         end
@@ -779,8 +779,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_compacted!)
-                                  .with(systemctl_path, "--system", "reload-or-restart", unit_name, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "reload-or-restart", unit_name, default_env: false)
+              .and_return(shell_out_success)
             provider.action_reload_or_restart
           end
         end
@@ -791,8 +791,8 @@ describe Chef::Provider::SystemdUnit do
           it "reload-or-try-restarts the unit" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted!)
-                                  .with(systemctl_path, "--user", "reload-or-try-restart", unit_name, **user_cmd_opts, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "reload-or-try-restart", unit_name, **user_cmd_opts, default_env: false)
+              .and_return(shell_out_success)
             provider.action_reload_or_try_restart
           end
         end
@@ -800,8 +800,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_compacted!)
-                                  .with(systemctl_path, "--system", "reload-or-try-restart", unit_name, default_env: false)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "reload-or-try-restart", unit_name, default_env: false)
+              .and_return(shell_out_success)
             provider.action_reload_or_try_restart
           end
         end
@@ -817,16 +817,16 @@ describe Chef::Provider::SystemdUnit do
           it "returns true when unit is active" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--user", "is-active", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_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_compacted)
-                                  .with(systemctl_path, "--user", "is-active", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_failure)
+              .with(systemctl_path, "--user", "is-active", unit_name, user_cmd_opts)
+              .and_return(shell_out_failure)
             expect(provider.active?).to be false
           end
         end
@@ -834,15 +834,15 @@ describe Chef::Provider::SystemdUnit do
         context "when no user is specified" do
           it "returns true when unit is active" do
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--system", "is-active", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_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_compacted)
-                                  .with(systemctl_path, "--system", "is-active", unit_name)
-                                  .and_return(shell_out_failure)
+              .with(systemctl_path, "--system", "is-active", unit_name)
+              .and_return(shell_out_failure)
             expect(provider.active?).to be false
           end
         end
@@ -858,8 +858,8 @@ describe Chef::Provider::SystemdUnit do
           it "returns true when unit is enabled" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
+              .and_return(shell_out_success)
             expect(provider.enabled?).to be true
           end
 
@@ -875,8 +875,8 @@ describe Chef::Provider::SystemdUnit do
         context "when no user is specified" do
           it "returns true when unit is enabled" do
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--system", "is-enabled", unit_name)
-                                  .and_return(shell_out_success)
+              .with(systemctl_path, "--system", "is-enabled", unit_name)
+              .and_return(shell_out_success)
             expect(provider.enabled?).to be true
           end
 
@@ -899,16 +899,16 @@ describe Chef::Provider::SystemdUnit do
           it "returns true when the unit is masked" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--user", "status", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_masked)
+              .with(systemctl_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_compacted)
-                                  .with(systemctl_path, "--user", "status", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_static)
+              .with(systemctl_path, "--user", "status", unit_name, user_cmd_opts)
+              .and_return(shell_out_static)
             expect(provider.masked?).to be false
           end
         end
@@ -916,15 +916,15 @@ describe Chef::Provider::SystemdUnit do
         context "when no user is specified" do
           it "returns true when the unit is masked" do
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--system", "status", unit_name)
-                                  .and_return(shell_out_masked)
+              .with(systemctl_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_compacted)
-                                  .with(systemctl_path, "--system", "status", unit_name)
-                                  .and_return(shell_out_static)
+              .with(systemctl_path, "--system", "status", unit_name)
+              .and_return(shell_out_static)
             expect(provider.masked?).to be false
           end
         end
@@ -940,16 +940,16 @@ describe Chef::Provider::SystemdUnit do
           it "returns true when the unit is static" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_static)
+              .with(systemctl_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_compacted)
-                                  .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_masked)
+              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
+              .and_return(shell_out_masked)
             expect(provider.static?).to be false
           end
         end
@@ -957,15 +957,15 @@ describe Chef::Provider::SystemdUnit do
         context "when no user is specified" do
           it "returns true when the unit is static" do
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--system", "is-enabled", unit_name)
-                                  .and_return(shell_out_static)
+              .with(systemctl_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_compacted)
-                                  .with(systemctl_path, "--system", "is-enabled", unit_name)
-                                  .and_return(shell_out_masked)
+              .with(systemctl_path, "--system", "is-enabled", unit_name)
+              .and_return(shell_out_masked)
             expect(provider.static?).to be false
           end
         end