chef 12.13.37-universal-mingw32 → 12.14.60-universal-mingw32

data/spec/integration/recipes/resource_load_spec.rb

@@ -18,7 +18,7 @@ describe "Resource.load_current_value" do
   before { Namer.incrementing_value = 0 }
 
   let(:resource_name) { :"load_current_value_dsl#{Namer.current_index}" }
-  let(:resource_class) {
+  let(:resource_class) do
     result = Class.new(Chef::Resource) do
       def self.to_s; resource_name.to_s; end
 
@@ -37,7 +37,7 @@ describe "Resource.load_current_value" do
     end
     result.resource_name resource_name
     result
-  }
+  end
 
   # Pull on resource_class to initialize it
   before { resource_class }
@@ -56,11 +56,11 @@ describe "Resource.load_current_value" do
       let(:resource) do
         e = self
         r = nil
-        converge {
+        converge do
           r = public_send(e.resource_name, "blah") do
             x "desired"
           end
-        }
+        end
         r
       end
 
@@ -83,17 +83,17 @@ describe "Resource.load_current_value" do
       end
 
       context "and identity: :i and :d with desired_state: false" do
-        before {
+        before do
           resource_class.class_eval do
             property :i, identity: true
             property :d, desired_state: false
           end
-        }
+        end
 
-        before {
+        before do
           resource.i "desired_i"
           resource.d "desired_d"
-        }
+        end
 
         it "i, name and d are passed to load_current_value, but not x" do
           expect(resource.current_value.x).to eq "loaded 2 (d=desired_d, i=desired_i, name=blah)"
@@ -101,17 +101,17 @@ describe "Resource.load_current_value" do
       end
 
       context "and name_property: :i and :d with desired_state: false" do
-        before {
+        before do
           resource_class.class_eval do
             property :i, name_property: true
             property :d, desired_state: false
           end
-        }
+        end
 
-        before {
+        before do
           resource.i "desired_i"
           resource.d "desired_d"
-        }
+        end
 
         it "i, name and d are passed to load_current_value, but not x" do
           expect(resource.current_value.x).to eq "loaded 2 (d=desired_d, i=desired_i, name=blah)"
@@ -123,10 +123,10 @@ describe "Resource.load_current_value" do
       let(:resource) do
         e = self
         r = nil
-        converge {
+        converge do
           r = public_send(e.resource_name, "blah") do
           end
-        }
+        end
         r
       end
 
@@ -135,16 +135,16 @@ describe "Resource.load_current_value" do
       end
     end
 
-    let (:subresource_name) {
+    let (:subresource_name) do
       :"load_current_value_subresource_dsl#{Namer.current_index}"
-    }
-    let (:subresource_class) {
+    end
+    let (:subresource_class) do
       r = Class.new(resource_class) do
         property :y, default: lazy { "default_y #{Namer.incrementing_value}" }
       end
       r.resource_name subresource_name
       r
-    }
+    end
 
     # Pull on subresource_class to initialize it
     before { subresource_class }
@@ -152,11 +152,11 @@ describe "Resource.load_current_value" do
     let(:subresource) do
       e = self
       r = nil
-      converge {
+      converge do
         r = public_send(e.subresource_name, "blah") do
           x "desired"
         end
-      }
+      end
       r
     end
 
@@ -170,14 +170,14 @@ describe "Resource.load_current_value" do
     end
 
     context "And a child resource class with load_current_value" do
-      before {
+      before do
         subresource_class.load_current_value do
           y "loaded_y #{Namer.incrementing_value} (#{self.class.properties.sort_by { |name, p| name }.
             select { |name, p| p.is_set?(self) }.
             map { |name, p| "#{name}=#{p.get(self)}" }.
             join(", ") })"
         end
-      }
+      end
 
       it "the overridden load_current_value is used" do
         current_resource = subresource.current_value
@@ -187,7 +187,7 @@ describe "Resource.load_current_value" do
     end
 
     context "and a child resource class with load_current_value calling super()" do
-      before {
+      before do
         subresource_class.load_current_value do
           super()
           y "loaded_y #{Namer.incrementing_value} (#{self.class.properties.sort_by { |name, p| name }.
@@ -195,7 +195,7 @@ describe "Resource.load_current_value" do
             map { |name, p| "#{name}=#{p.get(self)}" }.
             join(", ") })"
         end
-      }
+      end
 
       it "the original load_current_value is called as well as the child one" do
         current_resource = subresource.current_value

data/spec/integration/solo/solo_spec.rb

@@ -112,7 +112,11 @@ EOM
       file "cookbooks/x/recipes/default.rb", <<EOM
 ruby_block "sleeping" do
   block do
-    sleep 10
+    retries = 200
+    while IO.read(Chef::Config[:log_location]) !~ /Chef client [0-9]+ is running, will wait for it to finish and then run./
+      sleep 0.1
+      raise "we ran out of retries" if ( retries -= 1 ) <= 0
+    end
   end
 end
 EOM
@@ -125,51 +129,38 @@ file_cache_path "#{path_to('config/cache')}"
 EOM
       # We have a timeout protection here so that if due to some bug
       # run_lock gets stuck we can discover it.
-      expect {
+      expect do
         Timeout.timeout(120) do
           chef_dir = File.join(File.dirname(__FILE__), "..", "..", "..")
 
-          # Instantiate the first chef-solo run
-          s1 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \
--l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
+          threads = []
 
-          # Give it some time to progress
-          sleep 5
+          # Instantiate the first chef-solo run
+          threads << Thread.new do
+            s1 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default'  -l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
+            Process.waitpid(s1)
+          end
 
           # Instantiate the second chef-solo run
-          s2 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default' \
--l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
+          threads << Thread.new do
+            s2 = Process.spawn("#{chef_solo} -c \"#{path_to('config/solo.rb')}\" -o 'x::default'  -l debug -L #{path_to('logs/runs.log')}", :chdir => chef_dir)
+            Process.waitpid(s2)
+          end
 
-          Process.waitpid(s1)
-          Process.waitpid(s2)
+          threads.each(&:join)
         end
-      }.not_to raise_error
+      end.not_to raise_error
 
       # Unfortunately file / directory helpers in integration tests
       # are implemented using before(:each) so we need to do all below
       # checks in one example.
       run_log = File.read(path_to("logs/runs.log"))
 
+      # second run should have a message which indicates it's waiting for the first run
+      expect(run_log).to match(/Chef client [0-9]+ is running, will wait for it to finish and then run./)
+
       # both of the runs should succeed
       expect(run_log.lines.reject { |l| !l.include? "INFO: Chef Run complete in" }.length).to eq(2)
-
-      # second run should have a message which indicates it's waiting for the first run
-      pid_lines = run_log.lines.reject { |l| !l.include? "Chef-client pid:" }
-      expect(pid_lines.length).to eq(2)
-      pids = pid_lines.map { |l| l.split(" ").last }
-      expect(run_log).to include("Chef client #{pids[0]} is running, will wait for it to finish and then run.")
-
-      # second run should start after first run ends
-      starts = [ ]
-      ends = [ ]
-      run_log.lines.each_with_index do |line, index|
-        if line.include? "Chef-client pid:"
-          starts << index
-        elsif line.include? "INFO: Chef Run complete in"
-          ends << index
-        end
-      end
-      expect(starts[1]).to be > ends[0]
     end
 
   end

data/spec/scripts/ssl-serve.rb

@@ -42,6 +42,6 @@ webrick_opts = DEFAULT_OPTIONS.merge(server_opts)
 pp :webrick_opts => webrick_opts
 
 server = WEBrick::HTTPServer.new(webrick_opts)
-trap "INT" do server.shutdown end
+trap("INT") { server.shutdown }
 
 server.start

data/spec/spec_helper.rb

@@ -152,6 +152,7 @@ RSpec.configure do |config|
   config.filter_run_excluding :solaris_only => true unless solaris?
   config.filter_run_excluding :system_windows_service_gem_only => true unless system_windows_service_gem?
   config.filter_run_excluding :unix_only => true unless unix?
+  config.filter_run_excluding :linux_only => true unless linux?
   config.filter_run_excluding :aix_only => true unless aix?
   config.filter_run_excluding :debian_family_only => true unless debian_family?
   config.filter_run_excluding :supports_cloexec => true unless supports_cloexec?

data/spec/stress/win32/security_spec.rb

@@ -49,21 +49,21 @@ describe "Chef::ReservedNames::Win32::Security", :windows_only do
   end
 
   it "should not leak when retrieving and reading the ACE from a file", :volatile do
-    expect {
+    expect do
       sids = Chef::ReservedNames::Win32::Security::SecurableObject.new(@monkeyfoo).security_descriptor.dacl.select { |ace| ace.sid }
       GC.start
-    }.not_to leak_memory(:warmup => 50, :iterations => 100)
+    end.not_to leak_memory(:warmup => 50, :iterations => 100)
   end
 
   it "should not leak when creating a new ACL and setting it on a file", :volatile do
     securable_object = Security::SecurableObject.new(@monkeyfoo)
-    expect {
+    expect do
       securable_object.dacl = Chef::ReservedNames::Win32::Security::ACL.create([
         Chef::ReservedNames::Win32::Security::ACE.access_allowed(Chef::ReservedNames::Win32::Security::SID.Everyone, Chef::ReservedNames::Win32::API::Security::GENERIC_READ),
         Chef::ReservedNames::Win32::Security::ACE.access_denied(Chef::ReservedNames::Win32::Security::SID.from_account("Users"), Chef::ReservedNames::Win32::API::Security::GENERIC_ALL),
       ])
       GC.start
-    }.not_to leak_memory(:warmup => 50, :iterations => 100)
+    end.not_to leak_memory(:warmup => 50, :iterations => 100)
   end
 
 end

data/spec/support/chef_helpers.rb

@@ -84,6 +84,28 @@ def canonicalize_path(path)
   windows? ? path.tr("/", '\\') : path
 end
 
+# Makes a temp directory with a canonical path on any platform.
+# Only really needed to work around an issue on Windows where
+# Ruby's temp library generates paths with short names.
+def make_canonical_temp_directory
+  temp_directory = Dir.mktmpdir
+  if windows?
+    # On Windows, temporary file / directory path names may have shortened
+    # subdirectory names due to reliance on the TMP and TEMP environment variables
+    # in some Windows APIs and duplicated logic in Ruby's temp file implementation.
+    # To work around this in the unit test context, we obtain the long (canonical)
+    # path name via a Windows system call so that this path name can be used
+    # in expectations that assume the ability to canonically name paths in comparisons.
+    # Note that this was not an issue prior to Ruby 2.2 -- with Ruby 2.2,
+    # some Chef code started to use long file names, while Ruby's temp file implementation
+    # continued to return the shortened names -- this would cause these particular tests to
+    # fail if the username happened to be longer than 8 characters.
+    Chef::ReservedNames::Win32::File.get_long_path_name(temp_directory)
+  else
+    temp_directory
+  end
+end
+
 # Check if a cmd exists on the PATH
 def which(cmd)
   paths = ENV["PATH"].split(File::PATH_SEPARATOR) + [ "/bin", "/usr/bin", "/sbin", "/usr/sbin" ]

data/spec/support/platform_helpers.rb

@@ -126,6 +126,10 @@ def unix?
   !windows?
 end
 
+def linux?
+  !!(RUBY_PLATFORM =~ /linux/)
+end
+
 def os_x?
   !!(RUBY_PLATFORM =~ /darwin/)
 end
@@ -169,7 +173,7 @@ def selinux_enabled?
     when 0
       return true
     else
-      raise RuntimeError, "Unknown exit code from command #{selinuxenabled_path}: #{cmd.exitstatus}"
+      raise "Unknown exit code from command #{selinuxenabled_path}: #{cmd.exitstatus}"
     end
   else
     # We assume selinux is not enabled if selinux utils are not

data/spec/support/shared/context/client.rb

@@ -230,8 +230,9 @@ shared_context "audit phase failed with error" do
 end
 
 shared_context "audit phase completed with failed controls" do
-  let(:audit_runner) { instance_double("Chef::Audit::Runner", :failed? => true,
-                                                              :num_failed => 1, :num_total => 3) }
+  let(:audit_runner) do
+    instance_double("Chef::Audit::Runner", :failed? => true,
+                                           :num_failed => 1, :num_total => 3) end
 
   let(:audit_error) do
     err = Chef::Exceptions::AuditsFailed.new(audit_runner.num_failed, audit_runner.num_total)

data/spec/support/shared/functional/file_resource.rb

@@ -400,9 +400,9 @@ shared_examples_for "a configured file resource" do
   end
 
   context "when the target file is a symlink", :not_supported_on_win2k3 do
-    let(:symlink_target) {
+    let(:symlink_target) do
       File.join(CHEF_SPEC_DATA, "file-test-target")
-    }
+    end
 
     describe "when configured not to manage symlink's target" do
       before(:each) do
@@ -820,9 +820,9 @@ shared_examples_for "a configured file resource" do
     end
 
     describe "when path is specified with windows separator", :windows_only do
-      let(:path) {
+      let(:path) do
         File.join(test_file_dir, make_tmpname(file_base)).gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR)
-      }
+      end
 
       before do
         @notified_resource = Chef::Resource.new("punk", resource.run_context)
@@ -1035,6 +1035,7 @@ shared_context Chef::Resource::File do
   end
 
   before do
+    FileUtils.rm_rf(test_file_dir)
     FileUtils.mkdir_p(test_file_dir)
   end
 

data/spec/support/shared/functional/http.rb

@@ -52,27 +52,27 @@ module ChefHTTPShared
 
     # just a normal file
     # (expected_content should be uncompressed)
-    @api.get("/nyan_cat.png", 200) {
+    @api.get("/nyan_cat.png", 200) do
       File.open(nyan_uncompressed_filename, "rb") do |f|
         f.read
       end
-    }
+    end
 
     # this ends in .gz, we do not uncompress it and drop it on the filesystem as a .gz file (the internet often lies)
     # (expected_content should be compressed)
-    @api.get("/nyan_cat.png.gz", 200, nil, { "Content-Type" => "application/gzip", "Content-Encoding" => "gzip" } ) {
+    @api.get("/nyan_cat.png.gz", 200, nil, { "Content-Type" => "application/gzip", "Content-Encoding" => "gzip" } ) do
       File.open(nyan_compressed_filename, "rb") do |f|
         f.read
       end
-    }
+    end
 
     # this is an uncompressed file that was compressed by some mod_gzip-ish webserver thingy, so we will expand it
     # (expected_content should be uncompressed)
-    @api.get("/nyan_cat_compressed.png", 200, nil, { "Content-Type" => "application/gzip", "Content-Encoding" => "gzip" } ) {
+    @api.get("/nyan_cat_compressed.png", 200, nil, { "Content-Type" => "application/gzip", "Content-Encoding" => "gzip" } ) do
       File.open(nyan_compressed_filename, "rb") do |f|
         f.read
       end
-    }
+    end
 
     #
     # endpoints that set Content-Length correctly
@@ -83,11 +83,11 @@ module ChefHTTPShared
       {
         "Content-Length" => nyan_uncompressed_size.to_s,
       }
-    ) {
+    ) do
       File.open(nyan_uncompressed_filename, "rb") do |f|
         f.read
       end
-    }
+    end
 
     # (expected_content should be uncompressed)
     @api.get("/nyan_cat_content_length_compressed.png", 200, nil,
@@ -96,11 +96,11 @@ module ChefHTTPShared
         "Content-Type"     => "application/gzip",
         "Content-Encoding" => "gzip",
       }
-    ) {
+    ) do
       File.open(nyan_compressed_filename, "rb") do |f|
         f.read
       end
-    }
+    end
 
     #
     # endpoints that simulate truncated downloads (bad content-length header)
@@ -111,11 +111,11 @@ module ChefHTTPShared
       {
         "Content-Length" => (nyan_uncompressed_size + 1).to_s,
       }
-    ) {
+    ) do
       File.open(nyan_uncompressed_filename, "rb") do |f|
         f.read
       end
-    }
+    end
 
     # (expected_content should be uncompressed)
     @api.get("/nyan_cat_truncated_compressed.png", 200, nil,
@@ -124,11 +124,11 @@ module ChefHTTPShared
         "Content-Type"     => "application/gzip",
         "Content-Encoding" => "gzip",
       }
-    ) {
+    ) do
       File.open(nyan_compressed_filename, "rb") do |f|
         f.read
       end
-    }
+    end
 
     #
     # in the presence of a transfer-encoding header, we must ignore the content-length (this bad content-length should work)
@@ -140,11 +140,11 @@ module ChefHTTPShared
         "Content-Length"    => (nyan_uncompressed_size + 1).to_s,
         "Transfer-Encoding" => "anything",
       }
-    ) {
+    ) do
       File.open(nyan_uncompressed_filename, "rb") do |f|
         f.read
       end
-    }
+    end
 
     #
     # 403 with a Content-Length