chef 15.11.3-universal-mingw32 → 16.1.16-universal-mingw32

data/spec/unit/provider/package/windows/exe_spec.rb

@@ -126,7 +126,7 @@ describe Chef::Provider::Package::Windows::Exe do
       it "removes installed package and quotes uninstall string" do
         new_resource.timeout = 300
         allow(::File).to receive(:exist?).with("uninst_dir/uninst_file").and_return(true)
-        expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"uninst_dir/uninst_file\" /S /NCRC & exit %%%%ERRORLEVEL%%%%}, default_env: false, timeout: 300, returns: [0])
+        expect(provider).to receive(:shell_out!).with(%r{start \"\" /wait \"uninst_dir/uninst_file\" /S /NCRC & exit %%%%ERRORLEVEL%%%%}, default_env: false, timeout: 300, returns: [0, 3010])
         provider.remove_package
       end
     end

data/spec/unit/provider/powershell_script_spec.rb

@@ -53,73 +53,33 @@ describe Chef::Provider::PowershellScript, "action_run" do
   end
 
   context "when setting interpreter flags" do
-    context "on nano" do
-      before(:each) do
-        allow(Chef::Platform).to receive(:windows_nano_server?).and_return(true)
-        allow(provider).to receive(:is_forced_32bit).and_return(false)
-        os_info_double = double("os_info")
-        allow(provider.run_context.node["kernel"]).to receive(:[]).with("os_info").and_return(os_info_double)
-        allow(os_info_double).to receive(:[]).with("system_directory").and_return("C:\\Windows\\system32")
-      end
-
-      it "sets the -Command flag as the last flag" do
-        flags = provider.command.split(" ").keep_if { |flag| flag =~ /^-/ }
-        expect(flags.pop).to eq("-Command")
-      end
+    before(:each) do
+      allow(provider).to receive(:is_forced_32bit).and_return(false)
+      os_info_double = double("os_info")
+      allow(provider.run_context.node["kernel"]).to receive(:[]).with("os_info").and_return(os_info_double)
+      allow(os_info_double).to receive(:[]).with("system_directory").and_return("C:\\Windows\\system32")
     end
 
-    context "not on nano" do
-      before(:each) do
-        allow(Chef::Platform).to receive(:windows_nano_server?).and_return(false)
-        allow(provider).to receive(:is_forced_32bit).and_return(false)
-        os_info_double = double("os_info")
-        allow(provider.run_context.node["kernel"]).to receive(:[]).with("os_info").and_return(os_info_double)
-        allow(os_info_double).to receive(:[]).with("system_directory").and_return("C:\\Windows\\system32")
-      end
-
-      it "sets the -File flag as the last flag" do
-        flags = provider.command.split(" ").keep_if { |flag| flag =~ /^-/ }
-        expect(flags.pop).to eq("-File")
-      end
-
-      let(:execution_policy_flag) do
-        provider_flags = provider.flags.split(" ")
-        # Last occurance of "executionpolicy"
-        execution_policy_index = provider_flags.map(&:downcase).rindex("-executionpolicy")
+    it "sets the -File flag as the last flag" do
+      flags = provider.command.split(" ").keep_if { |flag| flag =~ /^-/ }
+      expect(flags.pop).to eq("-File")
+    end
 
-        execution_policy_index ? provider_flags[execution_policy_index + 1] : nil
-      end
+    let(:execution_policy_flag) do
+      provider_flags = provider.flags.split(" ")
+      # Last occurance of "executionpolicy"
+      execution_policy_index = provider_flags.map(&:downcase).rindex("-executionpolicy")
 
-      context "when running with an unspecified PowerShell version" do
-        let(:powershell_version) { nil }
-        it "sets default -ExecutionPolicy flag to 'Unrestricted'" do
-          expect(execution_policy_flag.downcase).to eq("unrestricted".downcase)
-        end
-        it "sets user defined -ExecutionPolicy flag to 'RemoteSigned'" do
-          set_user_defined_flag
-          expect(execution_policy_flag.downcase).to eq("RemoteSigned".downcase)
-        end
-      end
+      execution_policy_index ? provider_flags[execution_policy_index + 1] : nil
+    end
 
-      { "2.0" => "Unrestricted",
-        "2.5" => "Unrestricted",
-        "3.0" => "Bypass",
-        "3.6" => "Bypass",
-        "4.0" => "Bypass",
-        "5.0" => "Bypass" }.each do |version_policy|
-          let(:powershell_version) { version_policy[0].to_f }
-          context "when running PowerShell version #{version_policy[0]}" do
-            let(:powershell_version) { version_policy[0].to_f }
+    it "sets default -ExecutionPolicy flag to 'Bypass'" do
+      expect(execution_policy_flag).to eq("Bypass")
+    end
 
-            it "sets default -ExecutionPolicy flag to '#{version_policy[1]}'" do
-              expect(execution_policy_flag.downcase).to eq(version_policy[1].downcase)
-            end
-            it "sets user defined -ExecutionPolicy flag to 'RemoteSigned'" do
-              set_user_defined_flag
-              expect(execution_policy_flag.downcase).to eq("RemoteSigned".downcase)
-            end
-          end
-        end
+    it "sets user defined -ExecutionPolicy flag to 'RemoteSigned'" do
+      set_user_defined_flag
+      expect(execution_policy_flag).to eq("RemoteSigned")
     end
   end
 end

data/spec/unit/provider/remote_file_spec.rb

@@ -34,10 +34,9 @@ describe Chef::Provider::RemoteFile do
     content = double("Chef::Provider::File::Content::RemoteFile")
   end
 
-  let(:node) { double("Chef::Node") }
-  let(:events) { double("Chef::Events").as_null_object } # mock all the methods
-  let(:logger) { double("Mixlib::Log::Child").as_null_object }
-  let(:run_context) { double("Chef::RunContext", node: node, events: events, logger: logger) }
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:enclosing_directory) do
     canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
   end

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

@@ -1,6 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@hjksolutions.com>)
-# Copyright:: Copyright 2008-2016, HJK Solutions, LLC
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -183,21 +183,21 @@ describe Chef::Provider::Service::Debian do
   describe "enable_service" do
     let(:service_name) { @new_resource.service_name }
     context "when the service doesn't set a priority" do
-      it "calls update-rc.d 'service_name' defaults" do
+      it "assumes default priority 20 and calls update-rc.d remove => defaults 20 80" do
         expect_commands(@provider, [
           "/usr/sbin/update-rc.d -f #{service_name} remove",
-          "/usr/sbin/update-rc.d #{service_name} defaults",
+          "/usr/sbin/update-rc.d #{service_name} defaults 20 80",
         ])
         @provider.enable_service
       end
     end
 
-    context "when the service sets a simple priority" do
+    context "when the service sets a simple priority 75" do
       before do
         @new_resource.priority(75)
       end
 
-      it "calls update-rc.d 'service_name' defaults" do
+      it "calls update-rc.d remove => defaults 75 25" do
         expect_commands(@provider, [
           "/usr/sbin/update-rc.d -f #{service_name} remove",
           "/usr/sbin/update-rc.d #{service_name} defaults 75 25",
@@ -206,15 +206,17 @@ describe Chef::Provider::Service::Debian do
       end
     end
 
-    context "when the service sets complex priorities" do
+    context "when the service sets complex priorities using Hash" do
       before do
         @new_resource.priority(2 => [:start, 20], 3 => [:stop, 55])
       end
 
-      it "calls update-rc.d 'service_name' with those priorities" do
+      it "calls update-rc.d remove => defaults => enable|disable <runlevel>" do
         expect_commands(@provider, [
           "/usr/sbin/update-rc.d -f #{service_name} remove",
-          "/usr/sbin/update-rc.d #{service_name} start 20 2 . stop 55 3 . ",
+          "/usr/sbin/update-rc.d #{service_name} defaults",
+          "/usr/sbin/update-rc.d #{service_name} enable 2",
+          "/usr/sbin/update-rc.d #{service_name} disable 3",
         ])
         @provider.enable_service
       end
@@ -223,25 +225,44 @@ describe Chef::Provider::Service::Debian do
 
   describe "disable_service" do
     let(:service_name) { @new_resource.service_name }
+
     context "when the service doesn't set a priority" do
-      it "calls update-rc.d -f 'service_name' remove + stop with default priority" do
+      it "calls update-rc.d remove => defaults => disable" do
         expect_commands(@provider, [
           "/usr/sbin/update-rc.d -f #{service_name} remove",
-          "/usr/sbin/update-rc.d -f #{service_name} stop 80 2 3 4 5 .",
+          "/usr/sbin/update-rc.d #{service_name} defaults",
+          "/usr/sbin/update-rc.d #{service_name} disable",
         ])
         @provider.disable_service
       end
     end
 
-    context "when the service sets a simple priority" do
+    context "when the service sets a simple priority 75" do
       before do
         @new_resource.priority(75)
       end
 
-      it "calls update-rc.d -f 'service_name' remove + stop with the specified priority" do
+      it "ignores priority and calls update-rc.d remove => defaults => disable" do
         expect_commands(@provider, [
           "/usr/sbin/update-rc.d -f #{service_name} remove",
-          "/usr/sbin/update-rc.d -f #{service_name} stop #{100 - @new_resource.priority} 2 3 4 5 .",
+          "/usr/sbin/update-rc.d #{service_name} defaults",
+          "/usr/sbin/update-rc.d #{service_name} disable",
+        ])
+        @provider.disable_service
+      end
+    end
+
+    context "when the service sets complex priorities using Hash" do
+      before do
+        @new_resource.priority(2 => [:start, 20], 3 => [:stop, 55])
+      end
+
+      it "ignores priority and calls update-rc.d remove => defaults => enable|disable <runlevel>" do
+        expect_commands(@provider, [
+          "/usr/sbin/update-rc.d -f #{service_name} remove",
+          "/usr/sbin/update-rc.d #{service_name} defaults",
+          "/usr/sbin/update-rc.d #{service_name} enable 2",
+          "/usr/sbin/update-rc.d #{service_name} disable 3",
         ])
         @provider.disable_service
       end

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

@@ -1,6 +1,7 @@
 #
 # Author:: Igor Afonov <afonov@gmail.com>
 # Copyright:: Copyright 2011-2016, Igor Afonov
+# Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -61,276 +62,271 @@ describe Chef::Provider::Service::Macosx do
 
     %w{Daemon Agent}.each do |service_type|
       ["redis-server", "io.redis.redis-server"].each do |service_name|
-        ["10.9", "10.10", "10.11"].each do |platform_version|
-          let(:plist) { "/Library/LaunchDaemons/io.redis.redis-server.plist" }
-          let(:session) { StringIO.new }
-          if service_type == "Agent"
-            let(:plist) { "/Library/LaunchAgents/io.redis.redis-server.plist" }
-            let(:session) { "-S Aqua " }
-            let(:su_cmd) { "su -l igor -c" }
-            if platform_version == "10.9"
-              let(:su_cmd) { "su igor -c" }
-            end
-          end
-          let(:service_label) { "io.redis.redis-server" }
-          before do
-            allow(run_context).to receive(:logger).and_return(logger)
-            allow(Dir).to receive(:glob).and_return([plist], [])
-            @stat = double("File::Stat", { uid: 501 })
-            allow(File).to receive(:stat).and_return(@stat)
-            @getpwuid = double("Etc::Passwd", { name: "mikedodge04" })
-            allow(Etc).to receive(:getpwuid).and_return(@getpwuid)
-            allow(node).to receive(:[]).with("platform_version").and_return(platform_version)
-            cmd = "launchctl list #{service_label}"
-            allow(provider).to receive(:shell_out)
-              .with(/(#{su_cmd} '#{cmd}'|#{cmd})/, default_env: false)
-              .and_return(double("Status",
-                stdout: launchctl_stdout, exitstatus: 0))
-            allow(File).to receive(:exists?).and_return([true], [])
-            allow(provider).to receive(:shell_out!)
-              .with(/plutil -convert xml1 -o/, default_env: false)
-              .and_return(double("Status", stdout: plutil_stdout))
-          end
+        let(:plist) { "/Library/LaunchDaemons/io.redis.redis-server.plist" }
+        let(:session) { StringIO.new }
+        if service_type == "Agent"
+          let(:plist) { "/Library/LaunchAgents/io.redis.redis-server.plist" }
+          let(:session) { "-S Aqua " }
+          let(:su_cmd) { "su -l igor -c" }
+        end
+        let(:service_label) { "io.redis.redis-server" }
+        before do
+          allow(run_context).to receive(:logger).and_return(logger)
+          allow(Dir).to receive(:glob).and_return([plist], [])
+          @stat = double("File::Stat", { uid: 501 })
+          allow(File).to receive(:stat).and_return(@stat)
+          @getpwuid = double("Etc::Passwd", { name: "mikedodge04" })
+          allow(Etc).to receive(:getpwuid).and_return(@getpwuid)
+          allow(node).to receive(:[]).with("platform_version").and_return("10.11.1")
+          cmd = "launchctl list #{service_label}"
+          allow(provider).to receive(:shell_out)
+            .with(/(#{su_cmd} '#{cmd}'|#{cmd})/, default_env: false)
+            .and_return(double("Status",
+              stdout: launchctl_stdout, exitstatus: 0))
+          allow(File).to receive(:exists?).and_return([true], [])
+          allow(provider).to receive(:shell_out!)
+            .with(/plutil -convert xml1 -o/, default_env: false)
+            .and_return(double("Status", stdout: plutil_stdout))
+        end
 
-          context "#{service_name} that is a #{service_type} running Osx #{platform_version}" do
-            let(:new_resource) { Chef::Resource::MacosxService.new(service_name) }
-            let!(:current_resource) { Chef::Resource::MacosxService.new(service_name) }
+        context "#{service_name} that is a #{service_type}" do
+          let(:new_resource) { Chef::Resource::MacosxService.new(service_name) }
+          let!(:current_resource) { Chef::Resource::MacosxService.new(service_name) }
 
-            describe "#load_current_resource" do
+          describe "#load_current_resource" do
 
-              # CHEF-5223 "you can't glob for a file that hasn't been converged
-              # onto the node yet."
-              context "when the plist doesn't exist" do
+            # CHEF-5223 "you can't glob for a file that hasn't been converged
+            # onto the node yet."
+            context "when the plist doesn't exist" do
 
-                def run_resource_setup_for_action(action)
-                  new_resource.action(action)
-                  provider.action = action
-                  provider.load_current_resource
-                  provider.define_resource_requirements
-                  provider.process_resource_requirements
-                end
+              def run_resource_setup_for_action(action)
+                new_resource.action(action)
+                provider.action = action
+                provider.load_current_resource
+                provider.define_resource_requirements
+                provider.process_resource_requirements
+              end
 
-                before do
-                  allow(Dir).to receive(:glob).and_return([])
-                  allow(File).to receive(:exists?).and_return([true], [])
-                  allow(provider).to receive(:shell_out!)
-                    .with(/plutil -convert xml1 -o/)
-                    .and_raise(Mixlib::ShellOut::ShellCommandFailed)
-                end
+              before do
+                allow(Dir).to receive(:glob).and_return([])
+                allow(File).to receive(:exists?).and_return([true], [])
+                allow(provider).to receive(:shell_out!)
+                  .with(/plutil -convert xml1 -o/)
+                  .and_raise(Mixlib::ShellOut::ShellCommandFailed)
+              end
 
-                it "works for action :nothing" do
-                  expect { run_resource_setup_for_action(:nothing) }.not_to raise_error
-                end
+              it "works for action :nothing" do
+                expect { run_resource_setup_for_action(:nothing) }.not_to raise_error
+              end
 
-                it "works for action :start" do
-                  expect { run_resource_setup_for_action(:start) }.not_to raise_error
-                end
+              it "works for action :start" do
+                expect { run_resource_setup_for_action(:start) }.not_to raise_error
+              end
 
-                it "errors if action is :enable" do
-                  expect { run_resource_setup_for_action(:enable) }.to raise_error(Chef::Exceptions::Service)
-                end
+              it "errors if action is :enable" do
+                expect { run_resource_setup_for_action(:enable) }.to raise_error(Chef::Exceptions::Service)
+              end
 
-                it "errors if action is :disable" do
-                  expect { run_resource_setup_for_action(:disable) }.to raise_error(Chef::Exceptions::Service)
-                end
+              it "errors if action is :disable" do
+                expect { run_resource_setup_for_action(:disable) }.to raise_error(Chef::Exceptions::Service)
               end
+            end
 
-              context "when launchctl returns pid in service list" do
-                let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
-                  {
-                    "LimitLoadToSessionType" = "System";
-                    "Label" = "io.redis.redis-server";
-                    "TimeOut" = 30;
-                    "OnDemand" = false;
-                    "LastExitStatus" = 0;
-                    "PID" = 62803;
-                    "Program" = "do_some.sh";
-                    "ProgramArguments" = (
-                      "path/to/do_something.sh";
-                      "-f";
-                    );
-                  };
-                SVC_LIST
+            context "when launchctl returns pid in service list" do
+              let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
+                {
+                  "LimitLoadToSessionType" = "System";
+                  "Label" = "io.redis.redis-server";
+                  "TimeOut" = 30;
+                  "OnDemand" = false;
+                  "LastExitStatus" = 0;
+                  "PID" = 62803;
+                  "Program" = "do_some.sh";
+                  "ProgramArguments" = (
+                    "path/to/do_something.sh";
+                    "-f";
+                  );
+                };
+              SVC_LIST
 
-                before do
-                  provider.load_current_resource
-                end
+              before do
+                provider.load_current_resource
+              end
 
-                it "sets resource running state to true" do
-                  expect(provider.current_resource.running).to be_truthy
-                end
+              it "sets resource running state to true" do
+                expect(provider.current_resource.running).to be_truthy
+              end
 
-                it "sets resouce enabled state to true" do
-                  expect(provider.current_resource.enabled).to be_truthy
-                end
+              it "sets resouce enabled state to true" do
+                expect(provider.current_resource.enabled).to be_truthy
               end
+            end
 
-              describe "running unsupported actions" do
-                before do
-                  allow(Dir).to receive(:glob).and_return([(plist).to_s], [])
-                  allow(File).to receive(:exists?).and_return([true], [])
-                end
-                it "should throw an exception when reload action is attempted" do
-                  expect { provider.run_action(:reload) }.to raise_error(Chef::Exceptions::UnsupportedAction)
-                end
+            describe "running unsupported actions" do
+              before do
+                allow(Dir).to receive(:glob).and_return([(plist).to_s], [])
+                allow(File).to receive(:exists?).and_return([true], [])
               end
-              context "when launchctl returns empty service pid" do
-                let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
-                  {
-                    "LimitLoadToSessionType" = "System";
-                    "Label" = "io.redis.redis-server";
-                    "TimeOut" = 30;
-                    "OnDemand" = false;
-                    "LastExitStatus" = 0;
-                    "Program" = "do_some.sh";
-                    "ProgramArguments" = (
-                      "path/to/do_something.sh";
-                      "-f";
-                    );
-                  };
-                SVC_LIST
+              it "should throw an exception when reload action is attempted" do
+                expect { provider.run_action(:reload) }.to raise_error(Chef::Exceptions::UnsupportedAction)
+              end
+            end
+            context "when launchctl returns empty service pid" do
+              let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
+                {
+                  "LimitLoadToSessionType" = "System";
+                  "Label" = "io.redis.redis-server";
+                  "TimeOut" = 30;
+                  "OnDemand" = false;
+                  "LastExitStatus" = 0;
+                  "Program" = "do_some.sh";
+                  "ProgramArguments" = (
+                    "path/to/do_something.sh";
+                    "-f";
+                  );
+                };
+              SVC_LIST
 
-                before do
-                  provider.load_current_resource
-                end
+              before do
+                provider.load_current_resource
+              end
 
-                it "sets resource running state to false" do
-                  expect(provider.current_resource.running).to be_falsey
-                end
+              it "sets resource running state to false" do
+                expect(provider.current_resource.running).to be_falsey
+              end
 
-                it "sets resouce enabled state to true" do
-                  expect(provider.current_resource.enabled).to be_truthy
-                end
+              it "sets resouce enabled state to true" do
+                expect(provider.current_resource.enabled).to be_truthy
               end
+            end
 
-              context "when launchctl doesn't return service entry at all" do
-                let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
-                  Could not find service "io.redis.redis-server" in domain for system
-                SVC_LIST
+            context "when launchctl doesn't return service entry at all" do
+              let(:launchctl_stdout) { StringIO.new <<~SVC_LIST }
+                Could not find service "io.redis.redis-server" in domain for system
+              SVC_LIST
 
-                it "sets service running state to false" do
+              it "sets service running state to false" do
+                provider.load_current_resource
+                expect(provider.current_resource.running).to be_falsey
+              end
+
+              context "and plist for service is not available" do
+                before do
+                  allow(Dir).to receive(:glob).and_return([])
                   provider.load_current_resource
-                  expect(provider.current_resource.running).to be_falsey
                 end
 
-                context "and plist for service is not available" do
-                  before do
-                    allow(Dir).to receive(:glob).and_return([])
-                    provider.load_current_resource
-                  end
-
-                  it "sets resouce enabled state to false" do
-                    expect(provider.current_resource.enabled).to be_falsey
-                  end
+                it "sets resouce enabled state to false" do
+                  expect(provider.current_resource.enabled).to be_falsey
                 end
+              end
 
-                context "and plist for service is available" do
-                  before do
-                    allow(Dir).to receive(:glob).and_return([(plist).to_s], [])
-                    provider.load_current_resource
-                  end
+              context "and plist for service is available" do
+                before do
+                  allow(Dir).to receive(:glob).and_return([(plist).to_s], [])
+                  provider.load_current_resource
+                end
 
-                  it "sets resouce enabled state to true" do
-                    expect(provider.current_resource.enabled).to be_truthy
-                  end
+                it "sets resouce enabled state to true" do
+                  expect(provider.current_resource.enabled).to be_truthy
                 end
+              end
 
-                describe "and several plists match service name" do
-                  it "throws exception" do
-                    allow(Dir).to receive(:glob).and_return([(plist).to_s,
-                                                "/Users/wtf/something.plist"])
-                    provider.load_current_resource
-                    provider.define_resource_requirements
-                    expect { provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
-                  end
+              describe "and several plists match service name" do
+                it "throws exception" do
+                  allow(Dir).to receive(:glob).and_return([(plist).to_s,
+                                              "/Users/wtf/something.plist"])
+                  provider.load_current_resource
+                  provider.define_resource_requirements
+                  expect { provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Service)
                 end
               end
             end
-            describe "#start_service" do
-              before do
-                allow(Chef::Resource::MacosxService).to receive(:new).and_return(current_resource)
-                provider.load_current_resource
-                allow(current_resource).to receive(:running).and_return(false)
-              end
+          end
+          describe "#start_service" do
+            before do
+              allow(Chef::Resource::MacosxService).to receive(:new).and_return(current_resource)
+              provider.load_current_resource
+              allow(current_resource).to receive(:running).and_return(false)
+            end
 
-              it "calls the start command if one is specified and service is not running" do
-                allow(new_resource).to receive(:start_command).and_return("cowsay dirty")
+            it "calls the start command if one is specified and service is not running" do
+              allow(new_resource).to receive(:start_command).and_return("cowsay dirty")
 
-                expect(provider).to receive(:shell_out!).with("cowsay dirty", default_env: false)
-                provider.start_service
-              end
+              expect(provider).to receive(:shell_out!).with("cowsay dirty", default_env: false)
+              provider.start_service
+            end
 
-              it "shows warning message if service is already running" do
-                allow(current_resource).to receive(:running).and_return(true)
-                expect(logger).to receive(:trace).with("macosx_service[#{service_name}] already running, not starting")
+            it "shows warning message if service is already running" do
+              allow(current_resource).to receive(:running).and_return(true)
+              expect(logger).to receive(:trace).with("macosx_service[#{service_name}] already running, not starting")
 
-                provider.start_service
-              end
+              provider.start_service
+            end
 
-              it "starts service via launchctl if service found" do
-                cmd = "launchctl load -w " + session + plist
-                expect(provider).to receive(:shell_out)
-                  .with(/(#{su_cmd} .#{cmd}.|#{cmd})/, default_env: false)
-                  .and_return(0)
+            it "starts service via launchctl if service found" do
+              cmd = "launchctl load -w " + session + plist
+              expect(provider).to receive(:shell_out)
+                .with(/(#{su_cmd} .#{cmd}.|#{cmd})/, default_env: false)
+                .and_return(0)
 
-                provider.start_service
-              end
+              provider.start_service
             end
+          end
 
-            describe "#stop_service" do
-              before do
-                allow(Chef::Resource::MacosxService).to receive(:new).and_return(current_resource)
+          describe "#stop_service" do
+            before do
+              allow(Chef::Resource::MacosxService).to receive(:new).and_return(current_resource)
 
-                provider.load_current_resource
-                allow(current_resource).to receive(:running).and_return(true)
-              end
+              provider.load_current_resource
+              allow(current_resource).to receive(:running).and_return(true)
+            end
 
-              it "calls the stop command if one is specified and service is running" do
-                allow(new_resource).to receive(:stop_command).and_return("kill -9 123")
+            it "calls the stop command if one is specified and service is running" do
+              allow(new_resource).to receive(:stop_command).and_return("kill -9 123")
 
-                expect(provider).to receive(:shell_out!).with("kill -9 123", default_env: false)
-                provider.stop_service
-              end
+              expect(provider).to receive(:shell_out!).with("kill -9 123", default_env: false)
+              provider.stop_service
+            end
 
-              it "shows warning message if service is not running" do
-                allow(current_resource).to receive(:running).and_return(false)
-                expect(logger).to receive(:trace).with("macosx_service[#{service_name}] not running, not stopping")
+            it "shows warning message if service is not running" do
+              allow(current_resource).to receive(:running).and_return(false)
+              expect(logger).to receive(:trace).with("macosx_service[#{service_name}] not running, not stopping")
 
-                provider.stop_service
-              end
+              provider.stop_service
+            end
 
-              it "stops the service via launchctl if service found" do
-                cmd = "launchctl unload -w " + plist
-                expect(provider).to receive(:shell_out)
-                  .with(/(#{su_cmd} .#{cmd}.|#{cmd})/, default_env: false)
-                  .and_return(0)
+            it "stops the service via launchctl if service found" do
+              cmd = "launchctl unload -w " + plist
+              expect(provider).to receive(:shell_out)
+                .with(/(#{su_cmd} .#{cmd}.|#{cmd})/, default_env: false)
+                .and_return(0)
 
-                provider.stop_service
-              end
+              provider.stop_service
             end
+          end
 
-            describe "#restart_service" do
-              before do
-                allow(Chef::Resource::Service).to receive(:new).and_return(current_resource)
+          describe "#restart_service" do
+            before do
+              allow(Chef::Resource::Service).to receive(:new).and_return(current_resource)
 
-                provider.load_current_resource
-                allow(current_resource).to receive(:running).and_return(true)
-                allow(provider).to receive(:sleep)
-              end
+              provider.load_current_resource
+              allow(current_resource).to receive(:running).and_return(true)
+              allow(provider).to receive(:sleep)
+            end
 
-              it "issues a command if given" do
-                allow(new_resource).to receive(:restart_command).and_return("reload that thing")
+            it "issues a command if given" do
+              allow(new_resource).to receive(:restart_command).and_return("reload that thing")
 
-                expect(provider).to receive(:shell_out!).with("reload that thing", default_env: false)
-                provider.restart_service
-              end
+              expect(provider).to receive(:shell_out!).with("reload that thing", default_env: false)
+              provider.restart_service
+            end
 
-              it "stops and then starts service" do
-                expect(provider).to receive(:unload_service)
-                expect(provider).to receive(:load_service)
+            it "stops and then starts service" do
+              expect(provider).to receive(:unload_service)
+              expect(provider).to receive(:load_service)
 
-                provider.restart_service
-              end
+              provider.restart_service
             end
           end
         end