chef 15.1.36-universal-mingw32 → 15.2.20-universal-mingw32

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

@@ -75,8 +75,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
@@ -113,8 +113,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
 
@@ -188,26 +188,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
@@ -215,15 +215,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
@@ -231,10 +231,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
@@ -245,27 +245,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
@@ -274,7 +274,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
@@ -286,20 +286,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
 
@@ -309,7 +309,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
 
@@ -317,23 +317,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
@@ -342,8 +342,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
@@ -352,16 +352,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
@@ -372,19 +372,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
 
@@ -393,27 +393,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
@@ -421,8 +421,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)
@@ -431,15 +431,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
@@ -450,8 +450,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
 
@@ -459,8 +459,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
 
@@ -482,8 +482,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
 
@@ -505,16 +505,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
 
@@ -533,8 +533,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
 
@@ -559,8 +559,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
 
@@ -575,8 +575,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
 
@@ -592,8 +592,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
 
@@ -606,8 +606,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
 
@@ -625,8 +625,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
 
@@ -641,8 +641,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
 
@@ -658,8 +658,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
 
@@ -672,8 +672,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
 
@@ -690,8 +690,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
 
@@ -699,8 +699,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
 
@@ -715,16 +715,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
 
@@ -741,8 +741,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
@@ -750,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_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
@@ -762,8 +762,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
@@ -771,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_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
@@ -783,8 +783,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
@@ -792,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_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
@@ -809,16 +809,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
@@ -826,15 +826,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
@@ -850,16 +850,16 @@ 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
 
           it "returns false when unit is not enabled" do
             current_resource.user(user_name)
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-                                  .and_return(shell_out_failure)
+              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
+              .and_return(shell_out_failure)
             expect(provider.enabled?).to be false
           end
         end
@@ -867,15 +867,15 @@ 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
 
           it "returns false when unit is not enabled" do
             expect(provider).to receive(:shell_out_compacted)
-                                  .with(systemctl_path, "--system", "is-enabled", unit_name)
-                                  .and_return(shell_out_failure)
+              .with(systemctl_path, "--system", "is-enabled", unit_name)
+              .and_return(shell_out_failure)
             expect(provider.enabled?).to be false
           end
         end
@@ -891,16 +891,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
@@ -908,15 +908,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
@@ -932,16 +932,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
@@ -949,15 +949,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