chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

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

@@ -69,9 +69,9 @@ describe "Chef::Provider::Service::Redhat" do
         expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
         chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:on  6:off", :stderr => "")
         expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
-        expect(@provider.instance_variable_get("@service_missing")).to be_false
+        expect(@provider.instance_variable_get("@service_missing")).to be_falsey
         @provider.load_current_resource
-        expect(@current_resource.enabled).to be_true
+        expect(@current_resource.enabled).to be_truthy
       end
 
       it "sets the current enabled status to false if the regex does not match" do
@@ -79,9 +79,9 @@ describe "Chef::Provider::Service::Redhat" do
         expect(@provider).to receive(:shell_out).with("/sbin/service chef status").and_return(status)
         chkconfig = double("Chkconfig", :exitstatus => 0, :stdout => "chef    0:off   1:off   2:off   3:off   4:off   5:off   6:off", :stderr => "")
         expect(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", :returns => [0,1]).and_return(chkconfig)
-        expect(@provider.instance_variable_get("@service_missing")).to be_false
+        expect(@provider.instance_variable_get("@service_missing")).to be_falsey
         expect(@provider.load_current_resource).to eql(@current_resource)
-        expect(@current_resource.enabled).to be_false
+        expect(@current_resource.enabled).to be_falsey
       end
     end
 

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

@@ -82,13 +82,13 @@ NOMOCKINGSTRINGSPLZ
       @status = double("Status", :exitstatus => 0, :stdout => @stdout)
       allow(@provider).to receive(:shell_out!).and_return(@status)
       @provider.load_current_resource
-      expect(@current_resource.running).to be_true
+      expect(@current_resource.running).to be_truthy
     end
 
     it "should set running to false if the regex doesn't match" do
       allow(@provider).to receive(:shell_out!).and_return(@status)
       @provider.load_current_resource
-      expect(@current_resource.running).to be_false
+      expect(@current_resource.running).to be_falsey
     end
 
     it "should raise an exception if ps fails" do

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

@@ -85,14 +85,14 @@ describe Chef::Provider::Service::Solaris do
       it "should not mark service as maintenance" do
         allow(@provider).to receive(:shell_out!).and_return(@status)
         @provider.load_current_resource
-        expect(@provider.maintenance).to be_false
+        expect(@provider.maintenance).to be_falsey
       end
 
       it "should mark service as maintenance" do
         @status = double("Status", :exitstatus => 0, :stdout => 'state maintenance')
         allow(@provider).to receive(:shell_out!).and_return(@status)
         @provider.load_current_resource
-        expect(@provider.maintenance).to be_true
+        expect(@provider.maintenance).to be_truthy
       end
     end
 
@@ -105,15 +105,15 @@ describe Chef::Provider::Service::Solaris do
       it "should call svcadm enable -s chef" do
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm clear #{@current_resource.service_name}")
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm enable -s #{@current_resource.service_name}").and_return(@status)
-        expect(@provider.enable_service).to be_true
-        expect(@current_resource.enabled).to be_true
+        expect(@provider.enable_service).to be_truthy
+        expect(@current_resource.enabled).to be_truthy
       end
 
       it "should call svcadm enable -s chef for start_service" do
         expect(@provider).not_to receive(:shell_out!).with("/usr/sbin/svcadm clear #{@current_resource.service_name}")
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm enable -s #{@current_resource.service_name}").and_return(@status)
-        expect(@provider.start_service).to be_true
-        expect(@current_resource.enabled).to be_true
+        expect(@provider.start_service).to be_truthy
+        expect(@current_resource.enabled).to be_truthy
       end
 
       it "should call svcadm clear chef for start_service when state maintenance" do
@@ -122,8 +122,8 @@ describe Chef::Provider::Service::Solaris do
         @provider.load_current_resource
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm clear #{@current_resource.service_name}").and_return(@status)
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm enable -s #{@current_resource.service_name}").and_return(@status)
-        expect(@provider.enable_service).to be_true
-        expect(@current_resource.enabled).to be_true
+        expect(@provider.enable_service).to be_truthy
+        expect(@current_resource.enabled).to be_truthy
       end
     end
 
@@ -135,14 +135,14 @@ describe Chef::Provider::Service::Solaris do
 
       it "should call svcadm disable -s chef" do
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm disable -s chef").and_return(@status)
-        expect(@provider.disable_service).to be_true
-        expect(@current_resource.enabled).to be_false
+        expect(@provider.disable_service).to be_truthy
+        expect(@current_resource.enabled).to be_falsey
       end
 
       it "should call svcadm disable -s chef for stop_service" do
         expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm disable -s chef").and_return(@status)
-        expect(@provider.stop_service).to be_true
-        expect(@current_resource.enabled).to be_false
+        expect(@provider.stop_service).to be_truthy
+        expect(@current_resource.enabled).to be_falsey
       end
 
     end
@@ -170,13 +170,13 @@ describe Chef::Provider::Service::Solaris do
       it "should be marked not running" do
         expect(@provider).to receive(:shell_out!).with("/bin/svcs -l chef", {:returns=>[0, 1]}).and_return(@status)
         @provider.service_status
-        expect(@current_resource.running).to be_false
+        expect(@current_resource.running).to be_falsey
       end
 
       it "should be marked not enabled" do
         expect(@provider).to receive(:shell_out!).with("/bin/svcs -l chef", {:returns=>[0, 1]}).and_return(@status)
         @provider.service_status
-        expect(@current_resource.enabled).to be_false
+        expect(@current_resource.enabled).to be_falsey
       end
 
     end

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

@@ -257,14 +257,22 @@ describe Chef::Provider::Service::Systemd do
         end
       end
 
-      it "should return true if '#{systemctl_path} is-enabled service_name' returns 0" do
-        expect(provider).to receive(:shell_out).with("#{systemctl_path} is-enabled #{service_name} --quiet").and_return(shell_out_success)
-        expect(provider.is_enabled?).to be true
-      end
+      describe "is_enabled?" do
+        before(:each) do
+          provider.current_resource = current_resource
+          current_resource.service_name(service_name)
+          allow(provider).to receive(:which).with("systemctl").and_return("#{systemctl_path}")
+        end
+
+        it "should return true if '#{systemctl_path} is-enabled service_name' returns 0" do
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} is-enabled #{service_name} --quiet").and_return(shell_out_success)
+          expect(provider.is_enabled?).to be true
+        end
 
-      it "should return false if '#{systemctl_path} is-enabled service_name' returns anything except 0" do
-        expect(provider).to receive(:shell_out).with("#{systemctl_path} is-enabled #{service_name} --quiet").and_return(shell_out_failure)
-        expect(provider.is_enabled?).to be false
+        it "should return false if '#{systemctl_path} is-enabled service_name' returns anything except 0" do
+          expect(provider).to receive(:shell_out).with("#{systemctl_path} is-enabled #{service_name} --quiet").and_return(shell_out_failure)
+          expect(provider.is_enabled?).to be false
+        end
       end
     end
   end

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

@@ -108,14 +108,14 @@ describe Chef::Provider::Service::Upstart do
         @stdout = StringIO.new("rsyslog start/running")
         allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        expect(@current_resource.running).to be_true
+        expect(@current_resource.running).to be_truthy
       end
 
       it "should set running to false if the status command returns anything except 0" do
         @stdout = StringIO.new("rsyslog stop/waiting")
         allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        expect(@current_resource.running).to be_false
+        expect(@current_resource.running).to be_falsey
       end
     end
 
@@ -124,14 +124,14 @@ describe Chef::Provider::Service::Upstart do
         @stdout = StringIO.new("rsyslog (start) running, process 32225")
         allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        expect(@current_resource.running).to be_true
+        expect(@current_resource.running).to be_truthy
       end
 
       it "should set running to false if the status command returns anything except 0" do
         @stdout = StringIO.new("rsyslog (stop) waiting")
         allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        expect(@current_resource.running).to be_false
+        expect(@current_resource.running).to be_falsey
       end
     end
 

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

@@ -18,6 +18,7 @@
 #
 
 require 'spec_helper'
+require 'mixlib/shellout'
 
 describe Chef::Provider::Service::Windows, "load_current_resource" do
   before(:each) do
@@ -38,6 +39,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     allow(Win32::Service).to receive(:config_info).with(@new_resource.service_name).and_return(
       double("ConfigStruct", :start_type => "auto start"))
     allow(Win32::Service).to receive(:exists?).and_return(true)
+    allow(Win32::Service).to receive(:configure).and_return(Win32::Service)
   end
 
   it "should set the current resources service name to the new resources service name" do
@@ -51,12 +53,12 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
 
   it "should set the current resources status" do
     @provider.load_current_resource
-    expect(@provider.current_resource.running).to be_true
+    expect(@provider.current_resource.running).to be_truthy
   end
 
   it "should set the current resources start type" do
     @provider.load_current_resource
-    expect(@provider.current_resource.enabled).to be_true
+    expect(@provider.current_resource.enabled).to be_truthy
   end
 
   it "does not set the current resources start type if it is neither AUTO START or DISABLED" do
@@ -77,20 +79,20 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @new_resource.start_command "sc start chef"
       expect(@provider).to receive(:shell_out!).with("#{@new_resource.start_command}").and_return("Starting custom service")
       @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should use the built-in command if no start command is specified" do
       expect(Win32::Service).to receive(:start).with(@new_resource.service_name)
       @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should do nothing if the service does not exist" do
       allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
       expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should do nothing if the service is running" do
@@ -99,7 +101,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should raise an error if the service is paused" do
@@ -108,7 +110,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       expect { @provider.start_service }.to raise_error( Chef::Exceptions::Service )
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should wait and continue if the service is in start_pending" do
@@ -119,7 +121,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       @provider.start_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should fail if the service is in stop_pending" do
@@ -128,9 +130,29 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       expect { @provider.start_service }.to raise_error( Chef::Exceptions::Service )
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
+    describe "running as a different account" do
+      let(:old_run_as_user) { @new_resource.run_as_user }
+      let(:old_run_as_password) { @new_resource.run_as_password }
+
+      before {
+        @new_resource.run_as_user(".\\wallace")
+        @new_resource.run_as_password("Wensleydale")
+      }
+
+      after {
+        @new_resource.run_as_user(old_run_as_user)
+        @new_resource.run_as_password(old_run_as_password)
+      }
+
+      it "should call #grant_service_logon if the :run_as_user and :run_as_password attributes are present" do
+        expect(Win32::Service).to receive(:start)
+        expect(@provider).to receive(:grant_service_logon).and_return(true)
+        @provider.start_service
+      end
+    end
   end
 
 
@@ -146,20 +168,20 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @new_resource.stop_command "sc stop chef"
       expect(@provider).to receive(:shell_out!).with("#{@new_resource.stop_command}").and_return("Stopping custom service")
       @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should use the built-in command if no stop command is specified" do
       expect(Win32::Service).to receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should do nothing if the service does not exist" do
       allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
       expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should do nothing if the service is stopped" do
@@ -168,7 +190,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should raise an error if the service is paused" do
@@ -177,7 +199,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.load_current_resource
       expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       expect { @provider.stop_service }.to raise_error( Chef::Exceptions::Service )
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should wait and continue if the service is in stop_pending" do
@@ -188,7 +210,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       @provider.stop_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should fail if the service is in start_pending" do
@@ -197,7 +219,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @provider.load_current_resource
       expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       expect { @provider.stop_service }.to raise_error( Chef::Exceptions::Service )
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
     it "should pass custom timeout to the stop command if provided" do
@@ -208,7 +230,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       Timeout.timeout(2) do
         expect { @provider.stop_service }.to raise_error(Timeout::Error)
       end
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
   end
@@ -219,7 +241,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       @new_resource.restart_command "sc restart"
       expect(@provider).to receive(:shell_out!).with("#{@new_resource.restart_command}")
       @provider.restart_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should stop then start the service if it is running" do
@@ -231,7 +253,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       expect(Win32::Service).to receive(:stop).with(@new_resource.service_name)
       expect(Win32::Service).to receive(:start).with(@new_resource.service_name)
       @provider.restart_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should just start the service if it is stopped" do
@@ -241,7 +263,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
         double("StatusStruct", :current_state => "running"))
       expect(Win32::Service).to receive(:start).with(@new_resource.service_name)
       @provider.restart_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should do nothing if the service does not exist" do
@@ -249,7 +271,7 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       expect(Win32::Service).not_to receive(:stop).with(@new_resource.service_name)
       expect(Win32::Service).not_to receive(:start).with(@new_resource.service_name)
       @provider.restart_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
 
   end
@@ -263,14 +285,14 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     it "should enable service" do
       expect(Win32::Service).to receive(:configure).with(:service_name => @new_resource.service_name, :start_type => Win32::Service::AUTO_START)
       @provider.enable_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should do nothing if the service does not exist" do
       allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
       expect(Win32::Service).not_to receive(:configure)
       @provider.enable_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
   end
 
@@ -315,14 +337,14 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
     it "should disable service" do
       expect(Win32::Service).to receive(:configure)
       @provider.disable_service
-      expect(@new_resource.updated_by_last_action?).to be_true
+      expect(@new_resource.updated_by_last_action?).to be_truthy
     end
 
     it "should do nothing if the service does not exist" do
       allow(Win32::Service).to receive(:exists?).with(@new_resource.service_name).and_return(false)
       expect(Win32::Service).not_to receive(:configure)
       @provider.disable_service
-      expect(@new_resource.updated_by_last_action?).to be_false
+      expect(@new_resource.updated_by_last_action?).to be_falsey
     end
   end
 
@@ -364,4 +386,76 @@ describe Chef::Provider::Service::Windows, "load_current_resource" do
       expect { @provider.send(:set_startup_type, :fire_truck) }.to raise_error(Chef::Exceptions::ConfigurationError)
     end
   end
+
+  shared_context "testing private methods" do
+
+    let(:private_methods) {
+      described_class.private_instance_methods
+    }
+
+    before {
+      described_class.send(:public, *private_methods)
+    }
+
+    after {
+      described_class.send(:private, *private_methods)
+    }
+  end
+
+  describe "grant_service_logon" do
+    include_context "testing private methods"
+
+    let(:username) { "unit_test_user" }
+    let(:success_string) { "The task has completed successfully.\r\nSee logfile etc." }
+    let(:failure_string) { "Look on my works, ye Mighty, and despair!" }
+    let(:command) {
+      dbfile = @provider.grant_dbfile_name(username)
+      policyfile = @provider.grant_policyfile_name(username)
+      logfile = @provider.grant_logfile_name(username)
+
+      %Q{secedit.exe /configure /db "#{dbfile}" /cfg "#{policyfile}" /areas USER_RIGHTS SECURITYPOLICY SERVICES /log "#{logfile}"}
+    }
+    let(:shellout_env) { {:environment=>{"LC_ALL"=>"en_US.UTF-8"}} }
+
+    before {
+      expect_any_instance_of(described_class).to receive(:shell_out).with(command).and_call_original
+      expect_any_instance_of(Mixlib::ShellOut).to receive(:run_command).and_return(nil)
+    }
+
+    after {
+      # only needed for the second test.
+      ::File.delete(@provider.grant_policyfile_name(username)) rescue nil
+      ::File.delete(@provider.grant_logfile_name(username)) rescue nil
+      ::File.delete(@provider.grant_dbfile_name(username)) rescue nil
+    }
+
+    it "calls Mixlib::Shellout with the correct command string" do
+      expect_any_instance_of(Mixlib::ShellOut).to receive(:exitstatus).and_return(0)
+      expect(@provider.grant_service_logon(username)).to equal true
+    end
+
+    it "raises an exception when the grant command fails" do
+      expect_any_instance_of(Mixlib::ShellOut).to receive(:exitstatus).and_return(1)
+      expect_any_instance_of(Mixlib::ShellOut).to receive(:stdout).and_return(failure_string)
+      expect { @provider.grant_service_logon(username) }.to raise_error(Chef::Exceptions::Service)
+    end
+  end
+
+  describe "cleaning usernames" do
+    include_context "testing private methods"
+
+    it "correctly reformats usernames to create valid filenames" do
+      expect(@provider.clean_username_for_path("\\\\problem username/oink.txt")).to eq("_problem_username_oink_txt")
+      expect(@provider.clean_username_for_path("boring_username")).to eq("boring_username")
+    end
+
+    it "correctly reformats usernames for the policy file" do
+      expect(@provider.canonicalize_username(".\\maryann")).to eq("maryann")
+      expect(@provider.canonicalize_username("maryann")).to eq("maryann")
+
+      expect(@provider.canonicalize_username("\\\\maryann")).to eq("maryann")
+      expect(@provider.canonicalize_username("mydomain\\\\maryann")).to eq("mydomain\\\\maryann")
+      expect(@provider.canonicalize_username("\\\\mydomain\\\\maryann")).to eq("mydomain\\\\maryann")
+    end
+  end
 end