chef 12.5.1-universal-mingw32 → 12.6.0-universal-mingw32

data/spec/unit/provider/remote_file/cache_control_data_spec.rb

@@ -20,12 +20,12 @@ require 'spec_helper'
 require 'uri'
 
 CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH = 64
-CACHE_FILE_MD5_HEX_LENGTH = 32
+CACHE_FILE_CHECKSUM_HEX_LENGTH = 32
 CACHE_FILE_JSON_FILE_EXTENSION_LENGTH = 5
 CACHE_FILE_PATH_LIMIT =
   CACHE_FILE_TRUNCATED_FRIENDLY_FILE_NAME_LENGTH +
   1 +
-  CACHE_FILE_MD5_HEX_LENGTH +
+  CACHE_FILE_CHECKSUM_HEX_LENGTH +
   CACHE_FILE_JSON_FILE_EXTENSION_LENGTH # {friendly}-{md5hex}.json == 102
 
 describe Chef::Provider::RemoteFile::CacheControlData do
@@ -36,7 +36,8 @@ describe Chef::Provider::RemoteFile::CacheControlData do
     Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, current_file_checksum)
   end
 
-  let(:cache_path) { "remote_file/http___www_google_com_robots_txt-9839677abeeadf0691026e0cabca2339.json" }
+  let(:cache_path) { "remote_file/http___www_google_com_robots_txt-6dc1b24315d0cff764d30344199c6f7b.json" }
+  let(:old_cache_path) { "remote_file/http___www_google_com_robots_txt-9839677abeeadf0691026e0cabca2339.json" }
 
   # the checksum of the file we have on disk already
   let(:current_file_checksum) { "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" }
@@ -44,7 +45,8 @@ describe Chef::Provider::RemoteFile::CacheControlData do
   context "when loading data for an unknown URI" do
 
     before do
-      expect(Chef::FileCache).to receive(:load).with(cache_path).and_raise(Chef::Exceptions::FileNotFound, "nope")
+      expect(Chef::FileCache).to receive(:has_key?).with(cache_path).and_return(false)
+      expect(Chef::FileCache).to receive(:has_key?).with(old_cache_path).and_return(false)
     end
 
     context "and there is no current copy of the file" do
@@ -64,7 +66,8 @@ describe Chef::Provider::RemoteFile::CacheControlData do
     context "and the URI contains a password" do
 
       let(:uri) { URI.parse("http://bob:password@example.org/") }
-      let(:cache_path) { "remote_file/http___bob_XXXX_example_org_-f121caacb74c05a35bcefdf578ed5fc9.json" }
+      let(:cache_path) { "remote_file/http___bob_XXXX_example_org_-44be109aa176a165ef599c12d97af792.json" }
+      let(:old_cache_path) { "remote_file/http___bob_XXXX_example_org_-f121caacb74c05a35bcefdf578ed5fc9.json" }
 
       it "loads the cache data from a path based on a sanitized URI" do
         Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, current_file_checksum)
@@ -88,51 +91,73 @@ describe Chef::Provider::RemoteFile::CacheControlData do
       Chef::JSONCompat.to_json(cache)
     end
 
-    before do
-      expect(Chef::FileCache).to receive(:load).with(cache_path).and_return(cache_json_data)
-    end
-
-    context "and there is no on-disk copy of the file" do
-      let(:current_file_checksum) { nil }
-
-      it "returns empty cache control data" do
-        expect(cache_control_data.etag).to be_nil
-        expect(cache_control_data.mtime).to be_nil
+    context "when the cache control data uses sha256 for its name" do
+      before do
+        expect(Chef::FileCache).to receive(:has_key?).with(cache_path).and_return(true)
+        expect(Chef::FileCache).to receive(:load).with(cache_path).and_return(cache_json_data)
       end
-    end
 
-    context "and the cached checksum does not match the on-disk copy" do
-      let(:current_file_checksum) { "e2a8938cc31754f6c067b35aab1d0d4864272e9bf8504536ef3e79ebf8432305" }
+      context "and there is no on-disk copy of the file" do
+        let(:current_file_checksum) { nil }
 
-      it "returns empty cache control data" do
-        expect(cache_control_data.etag).to be_nil
-        expect(cache_control_data.mtime).to be_nil
+        it "returns empty cache control data" do
+          expect(cache_control_data.etag).to be_nil
+          expect(cache_control_data.mtime).to be_nil
+        end
       end
-    end
 
-    context "and the cached checksum matches the on-disk copy" do
+      context "and the cached checksum does not match the on-disk copy" do
+        let(:current_file_checksum) { "e2a8938cc31754f6c067b35aab1d0d4864272e9bf8504536ef3e79ebf8432305" }
 
-      it "populates the cache control data" do
-        expect(cache_control_data.etag).to eq(etag)
-        expect(cache_control_data.mtime).to eq(mtime)
+        it "returns empty cache control data" do
+          expect(cache_control_data.etag).to be_nil
+          expect(cache_control_data.mtime).to be_nil
+        end
       end
-    end
-
-    context "and the cached checksum data is corrupted" do
-      let(:cache_json_data) { '{"foo",,"bar" []}' }
 
-      it "returns empty cache control data" do
-        expect(cache_control_data.etag).to be_nil
-        expect(cache_control_data.mtime).to be_nil
+      context "and the cached checksum matches the on-disk copy" do
+        context "when the filename uses sha256" do
+          before do
+            expect(Chef::FileCache).not_to receive(:has_key?).with(old_cache_path)
+          end
+          it "populates the cache control data" do
+            expect(cache_control_data.etag).to eq(etag)
+            expect(cache_control_data.mtime).to eq(mtime)
+          end
+        end
       end
 
-      context "and it still is valid JSON" do
-        let(:cache_json_data) { '' }
+      context "and the cached checksum data is corrupted" do
+        let(:cache_json_data) { '{"foo",,"bar" []}' }
 
         it "returns empty cache control data" do
           expect(cache_control_data.etag).to be_nil
           expect(cache_control_data.mtime).to be_nil
         end
+
+        context "and it still is valid JSON" do
+          let(:cache_json_data) { '' }
+
+          it "returns empty cache control data" do
+            expect(cache_control_data.etag).to be_nil
+            expect(cache_control_data.mtime).to be_nil
+          end
+        end
+      end
+    end
+
+    context "when the filename uses md5" do
+      before do
+        expect(Chef::FileCache).to receive(:has_key?).with(cache_path).and_return(false)
+        expect(Chef::FileCache).to receive(:has_key?).with(old_cache_path).and_return(true)
+        expect(Chef::FileCache).to receive(:load).with(old_cache_path).and_return(cache_json_data)
+      end
+
+      it "populates the cache control data and creates the cache control data file with the correct path" do
+        expect(Chef::FileCache).to receive(:store).with(cache_path, cache_json_data)
+        expect(Chef::FileCache).to receive(:delete).with(old_cache_path)
+        expect(cache_control_data.etag).to eq(etag)
+        expect(cache_control_data.mtime).to eq(mtime)
       end
     end
   end
@@ -174,7 +199,8 @@ describe Chef::Provider::RemoteFile::CacheControlData do
     context "and the URI contains a password" do
 
       let(:uri) { URI.parse("http://bob:password@example.org/") }
-      let(:cache_path) { "remote_file/http___bob_XXXX_example_org_-f121caacb74c05a35bcefdf578ed5fc9.json" }
+      let(:cache_path) { "remote_file/http___bob_XXXX_example_org_-44be109aa176a165ef599c12d97af792.json" }
+      let(:old_cache_path) { "remote_file/http___bob_XXXX_example_org_-f121caacb74c05a35bcefdf578ed5fc9.json" }
 
       it "writes the data to the cache with a sanitized path name" do
         json_data = cache_control_data.json_data

data/spec/unit/provider/script_spec.rb

@@ -88,11 +88,11 @@ describe Chef::Provider::Script, "action_run" do
 
     describe "when running the script" do
       let (:default_opts) {
-        {timeout: 3600, returns: 0, log_level: :info, log_tag: "script[run some perl code]", live_stream: STDOUT}
+        { timeout: 3600, returns: 0, log_level: :info, log_tag: "script[run some perl code]" }
       }
 
       before do
-        allow(STDOUT).to receive(:tty?).and_return(true)
+        allow(STDOUT).to receive(:tty?).and_return(false)
       end
 
       it 'should set the command to "interpreter"  "tempfile"' do

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

@@ -31,66 +31,126 @@ describe Chef::Provider::Service::Solaris do
     @provider = Chef::Provider::Service::Solaris.new(@new_resource, @run_context)
     allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
 
-    @stdin = StringIO.new
-    @stdout = StringIO.new
-    @stderr = StringIO.new
-    @pid = 2342
-    @stdout_string = "state disabled"
-    allow(@stdout).to receive(:gets).and_return(@stdout_string)
-    @status = double("Status", :exitstatus => 0, :stdout => @stdout)
-    allow(@provider).to receive(:shell_out!).and_return(@status)
+    # enabled / started service (svcs -l chef)
+    enabled_svc_stdout = [
+      'fmri         svc:/application/chef:default',
+      'name         chef service',
+      'enabled      true',
+      'state        online',
+      'next_state   none',
+      'state_time   April  2, 2015 04:25:19 PM EDT',
+      'logfile      /var/svc/log/application-chef:default.log',
+      'restarter    svc:/system/svc/restarter:default',
+      'contract_id  1115271',
+      'dependency   require_all/error svc:/milestone/multi-user:default (online)'
+    ].join("\n")
+
+    # disabled / stopped service (svcs -l chef)
+    disabled_svc_stdout = [
+      'fmri         svc:/application/chef:default',
+      'name         chef service',
+      'enabled      false',
+      'state        disabled',
+      'next_state   none',
+      'state_time   April  2, 2015 04:25:19 PM EDT',
+      'logfile      /var/svc/log/application-chef:default.log',
+      'restarter    svc:/system/svc/restarter:default',
+      'contract_id  1115271',
+      'dependency   require_all/error svc:/milestone/multi-user:default (online)'
+    ].join("\n")
+
+    # disabled / stopped service (svcs -l chef)
+    maintenance_svc_stdout = [
+      'fmri         svc:/application/chef:default',
+      'name         chef service',
+      'enabled      true',
+      'state        maintenance',
+      'next_state   none',
+      'state_time   April  2, 2015 04:25:19 PM EDT',
+      'logfile      /var/svc/log/application-chef:default.log',
+      'restarter    svc:/system/svc/restarter:default',
+      'contract_id  1115271',
+      'dependency   require_all/error svc:/milestone/multi-user:default (online)'
+    ].join("\n")
+
+    # shell_out! return value for a service that is running
+    @enabled_svc_status = double("Status", :exitstatus => 0, :stdout => enabled_svc_stdout, :stdin => '', :stderr => '')
+
+    # shell_out! return value for a service that is disabled
+    @disabled_svc_status = double("Status", :exitstatus => 0, :stdout => disabled_svc_stdout, :stdin => '', :stderr => '')
+
+    # shell_out! return value for a service that is in maintenance mode
+    @maintenance_svc_status = double("Status", :exitstatus => 0, :stdout => maintenance_svc_stdout, :stdin => '', :stderr => '')
+
+    # shell_out! return value for a service that does not exist
+    @no_svc_status = double("Status", :exitstatus => 1, :stdout => '', :stdin => '', :stderr => "svcs: Pattern 'chef' doesn't match any instances\n")
+
+    # shell_out! return value for a successful execution
+    @success = double("clear", :exitstatus => 0, :stdout => '', :stdin => '', :stderr => '')
   end
 
-  it "should raise an error if /bin/svcs does not exist" do
-    expect(File).to receive(:exists?).with("/bin/svcs").and_return(false)
+  it "should raise an error if /bin/svcs and /usr/sbin/svcadm are not executable" do
+    allow(File).to receive(:executable?).with("/bin/svcs").and_return(false)
+    allow(File).to receive(:executable?).with("/usr/sbin/svcadm").and_return(false)
     expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Service)
   end
 
-  describe "on a host with /bin/svcs" do
+  it "should raise an error if /bin/svcs is not executable" do
+    allow(File).to receive(:executable?).with("/bin/svcs").and_return(false)
+    allow(File).to receive(:executable?).with("/usr/sbin/svcadm").and_return(true)
+    expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Service)
+  end
+
+  it "should raise an error if /usr/sbin/svcadm is not executable" do
+    allow(File).to receive(:executable?).with("/bin/svcs").and_return(true)
+    allow(File).to receive(:executable?).with("/usr/sbin/svcadm").and_return(false)
+    expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Service)
+  end
+
+  describe "on a host with /bin/svcs and /usr/sbin/svcadm" do
 
     before do
-      allow(File).to receive(:exists?).with('/bin/svcs').and_return(true)
+      allow(File).to receive(:executable?).with("/bin/svcs").and_return(true)
+      allow(File).to receive(:executable?).with("/usr/sbin/svcadm").and_return(true)
     end
 
     describe "when discovering the current service state" do
       it "should create a current resource with the name of the new resource" do
-        allow(@provider).to receive(:shell_out!).with("/bin/svcs -l chef").and_return(@status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@enabled_svc_status)
         expect(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
         @provider.load_current_resource
       end
 
       it "should return the current resource" do
-        allow(@provider).to receive(:shell_out!).with("/bin/svcs -l chef").and_return(@status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@enabled_svc_status)
         expect(@provider.load_current_resource).to eql(@current_resource)
       end
 
       it "should call '/bin/svcs -l service_name'" do
-        expect(@provider).to receive(:shell_out!).with("/bin/svcs -l chef", {:returns=>[0, 1]}).and_return(@status)
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@enabled_svc_status)
         @provider.load_current_resource
       end
 
       it "should mark service as not running" do
-        allow(@provider).to receive(:shell_out!).and_return(@status)
+        expect(@provider).to receive(:shell_out!).and_return(@disabled_svc_status)
         expect(@current_resource).to receive(:running).with(false)
         @provider.load_current_resource
       end
 
       it "should mark service as running" do
-        @status = double("Status", :exitstatus => 0, :stdout => 'state online')
-        allow(@provider).to receive(:shell_out!).and_return(@status)
+        expect(@provider).to receive(:shell_out!).and_return(@enabled_svc_status)
         expect(@current_resource).to receive(:running).with(true)
         @provider.load_current_resource
       end
 
       it "should not mark service as maintenance" do
-        allow(@provider).to receive(:shell_out!).and_return(@status)
+        expect(@provider).to receive(:shell_out!).and_return(@enabled_svc_status)
         @provider.load_current_resource
         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)
+        expect(@provider).to receive(:shell_out!).and_return(@maintenance_svc_status)
         @provider.load_current_resource
         expect(@provider.maintenance).to be_truthy
       end
@@ -99,30 +159,41 @@ describe Chef::Provider::Service::Solaris do
     describe "when enabling the service" do
       before(:each) do
         @provider.current_resource = @current_resource
-        @current_resource.enabled(true)
       end
 
       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).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@enabled_svc_status)
+        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(@success)
+        @provider.load_current_resource
+
         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).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@enabled_svc_status)
+        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(@success)
+        @provider.load_current_resource
         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
-        @status = double("Status", :exitstatus => 0, :stdout => 'state maintenance')
-        allow(@provider).to receive(:shell_out!).and_return(@status)
+        # we are in maint mode
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@maintenance_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "clear", @current_resource.service_name).and_return(@success)
+        expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "enable", "-s", @current_resource.service_name).and_return(@success)
+
+        # load the resource, then enable it
         @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_truthy
+
+        # now we are enabled
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@enabled_svc_status)
+        @provider.load_current_resource
+
         expect(@current_resource.enabled).to be_truthy
       end
     end
@@ -130,17 +201,20 @@ describe Chef::Provider::Service::Solaris do
     describe "when disabling the service" do
       before(:each) do
         @provider.current_resource = @current_resource
-        @current_resource.enabled(false)
       end
 
       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).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@disabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "disable", "-s", "chef").and_return(@success)
+        @provider.load_current_resource
         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).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@disabled_svc_status)
+        expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "disable", "-s", "chef").and_return(@success)
+        @provider.load_current_resource
         expect(@provider.stop_service).to be_truthy
         expect(@current_resource.enabled).to be_falsey
       end
@@ -149,12 +223,12 @@ describe Chef::Provider::Service::Solaris do
 
     describe "when reloading the service" do
       before(:each) do
-        @status = double("Process::Status", :exitstatus => 0)
         @provider.current_resource = @current_resource
+        allow(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@enabled_svc_status)
       end
 
       it "should call svcadm refresh chef" do
-        expect(@provider).to receive(:shell_out_with_systems_locale!).with("/usr/sbin/svcadm refresh chef").and_return(@status)
+        expect(@provider).to receive(:shell_out!).with("/usr/sbin/svcadm", "refresh", "chef")
         @provider.reload_service
       end
 
@@ -162,19 +236,16 @@ describe Chef::Provider::Service::Solaris do
 
     describe "when the service doesn't exist" do
       before(:each) do
-        @stdout_string = ""
-        @status = double("Status", :exitstatus => 1, :stdout => @stdout)
         @provider.current_resource = @current_resource
+        expect(@provider).to receive(:shell_out!).with("/bin/svcs", "-l", "chef", {:returns=>[0, 1]}).and_return(@no_svc_status)
       end
 
       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_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_falsey
       end

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

@@ -123,6 +123,25 @@ describe Chef::Provider::Service::Upstart do
       end
     end
 
+    describe "when the status command uses the new format with an instance" do
+      before do
+      end
+
+      it "should set running to true if the status command returns 0" do
+        @stdout = StringIO.new("rsyslog (test) start/running, process 100")
+        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        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 (test) stop/waiting, process 100")
+        allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.load_current_resource
+        expect(@current_resource.running).to be_falsey
+      end
+    end
+
     describe "when the status command uses the old format" do
       it "should set running to true if the status command returns 0" do
         @stdout = StringIO.new("rsyslog (start) running, process 32225")