chef 14.15.6 → 15.0.293

data/spec/unit/provider/subversion_spec.rb

@@ -277,8 +277,7 @@ 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
@@ -286,24 +285,21 @@ 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

@@ -65,26 +65,18 @@ describe Chef::Provider::SystemdUnit do
   end
 
   let(:shell_out_masked) do
-    double("shell_out", exitstatus: 0, error?: false, stdout: "masked")
+    double("shell_out", exit_status: 0, error?: false, stdout: "masked")
   end
 
   let(:shell_out_static) do
-    double("shell_out", exitstatus: 0, error?: false, stdout: "static")
-  end
-
-  let(:shell_out_disabled) do
-    double("shell_out", exitstatus: 1, error?: true, stdout: "disabled")
-  end
-
-  let(:shell_out_indirect) do
-    double("shell_out", exitstatus: 0, error?: true, stdout: "indirect")
+    double("shell_out", exit_status: 0, error?: false, stdout: "static")
   end
 
   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 +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
 
@@ -196,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
@@ -223,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
@@ -239,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
@@ -253,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
@@ -282,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
@@ -294,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
 
@@ -317,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
 
@@ -325,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
@@ -350,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
@@ -360,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
@@ -380,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
 
@@ -401,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
@@ -429,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)
@@ -439,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
@@ -458,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
 
@@ -467,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
 
@@ -490,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
 
@@ -513,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
 
@@ -541,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
 
@@ -567,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
 
@@ -583,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
 
@@ -600,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
 
@@ -614,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
 
@@ -633,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
 
@@ -649,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
 
@@ -666,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
 
@@ -680,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
 
@@ -698,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
 
@@ -707,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
 
@@ -723,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
 
@@ -749,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
@@ -758,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
@@ -770,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
@@ -779,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
@@ -791,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
@@ -800,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
@@ -817,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
@@ -834,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
@@ -858,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_disabled)
+                                  .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
+                                  .and_return(shell_out_failure)
             expect(provider.enabled?).to be false
           end
         end
@@ -875,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_disabled)
+                                  .with(systemctl_path, "--system", "is-enabled", unit_name)
+                                  .and_return(shell_out_failure)
             expect(provider.enabled?).to be false
           end
         end
@@ -899,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
@@ -916,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
@@ -940,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
@@ -957,60 +949,19 @@ 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
       end
-
-      describe "#indirect?" do
-        before(:each) do
-          provider.current_resource = current_resource
-          allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
-        end
-
-        context "when a user is specified" do
-          it "returns true when the unit is indirect" do
-            current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_indirect)
-            expect(provider.indirect?).to be true
-          end
-
-          it "returns false when the unit is not indirect" do
-            current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_static)
-            expect(provider.indirect?).to be false
-          end
-        end
-
-        context "when no user is specified" do
-          it "returns true when the unit is indirect" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_indirect)
-            expect(provider.indirect?).to be true
-          end
-
-          it "returns false when the unit is not indirect" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_static)
-            expect(provider.indirect?).to be false
-          end
-        end
-      end
     end
   end
 end