chef 14.2.0 → 14.3.37

data/spec/unit/chef_fs/diff_spec.rb

@@ -28,62 +28,62 @@ def remove_os_differences(diff)
   diff.gsub(/^@@ -\d(,\d)? \+\d(,\d)? @@/, "CONTEXT_LINE_NUMBERS")
 end
 
-describe "diff", :uses_diff => true do
+describe "diff", uses_diff: true do
   include FileSystemSupport
 
   context "with two filesystems with all types of difference" do
     let(:a) do
       memory_fs("a", {
-        :both_dirs => {
-          :sub_both_dirs => { :subsub => nil },
-          :sub_both_files => nil,
-          :sub_both_files_different => "a\n",
-          :sub_both_dirs_empty => {},
-          :sub_dirs_empty_in_a_filled_in_b => {},
-          :sub_dirs_empty_in_b_filled_in_a => { :subsub => nil },
-          :sub_a_only_dir => { :subsub => nil },
-          :sub_a_only_file => nil,
-          :sub_dir_in_a_file_in_b => {},
-          :sub_file_in_a_dir_in_b => nil,
+        both_dirs: {
+          sub_both_dirs: { subsub: nil },
+          sub_both_files: nil,
+          sub_both_files_different: "a\n",
+          sub_both_dirs_empty: {},
+          sub_dirs_empty_in_a_filled_in_b: {},
+          sub_dirs_empty_in_b_filled_in_a: { subsub: nil },
+          sub_a_only_dir: { subsub: nil },
+          sub_a_only_file: nil,
+          sub_dir_in_a_file_in_b: {},
+          sub_file_in_a_dir_in_b: nil,
         },
-        :both_files => nil,
-        :both_files_different => "a\n",
-        :both_dirs_empty => {},
-        :dirs_empty_in_a_filled_in_b => {},
-        :dirs_empty_in_b_filled_in_a => { :subsub => nil },
-        :dirs_in_a_cannot_be_in_b => {},
-        :file_in_a_cannot_be_in_b => nil,
-        :a_only_dir => { :subsub => nil },
-        :a_only_file => nil,
-        :dir_in_a_file_in_b => {},
-        :file_in_a_dir_in_b => nil,
+        both_files: nil,
+        both_files_different: "a\n",
+        both_dirs_empty: {},
+        dirs_empty_in_a_filled_in_b: {},
+        dirs_empty_in_b_filled_in_a: { subsub: nil },
+        dirs_in_a_cannot_be_in_b: {},
+        file_in_a_cannot_be_in_b: nil,
+        a_only_dir: { subsub: nil },
+        a_only_file: nil,
+        dir_in_a_file_in_b: {},
+        file_in_a_dir_in_b: nil,
       }, /cannot_be_in_a/)
     end
     let(:b) do
       memory_fs("b", {
-        :both_dirs => {
-          :sub_both_dirs => { :subsub => nil },
-          :sub_both_files => nil,
-          :sub_both_files_different => "b\n",
-          :sub_both_dirs_empty => {},
-          :sub_dirs_empty_in_a_filled_in_b => { :subsub => nil },
-          :sub_dirs_empty_in_b_filled_in_a => {},
-          :sub_b_only_dir => { :subsub => nil },
-          :sub_b_only_file => nil,
-          :sub_dir_in_a_file_in_b => nil,
-          :sub_file_in_a_dir_in_b => {},
+        both_dirs: {
+          sub_both_dirs: { subsub: nil },
+          sub_both_files: nil,
+          sub_both_files_different: "b\n",
+          sub_both_dirs_empty: {},
+          sub_dirs_empty_in_a_filled_in_b: { subsub: nil },
+          sub_dirs_empty_in_b_filled_in_a: {},
+          sub_b_only_dir: { subsub: nil },
+          sub_b_only_file: nil,
+          sub_dir_in_a_file_in_b: nil,
+          sub_file_in_a_dir_in_b: {},
         },
-        :both_files => nil,
-        :both_files_different => "b\n",
-        :both_dirs_empty => {},
-        :dirs_empty_in_a_filled_in_b => { :subsub => nil },
-        :dirs_empty_in_b_filled_in_a => {},
-        :dirs_in_b_cannot_be_in_a => {},
-        :file_in_b_cannot_be_in_a => nil,
-        :b_only_dir => { :subsub => nil },
-        :b_only_file => nil,
-        :dir_in_a_file_in_b => nil,
-        :file_in_a_dir_in_b => {},
+        both_files: nil,
+        both_files_different: "b\n",
+        both_dirs_empty: {},
+        dirs_empty_in_a_filled_in_b: { subsub: nil },
+        dirs_empty_in_b_filled_in_a: {},
+        dirs_in_b_cannot_be_in_a: {},
+        file_in_b_cannot_be_in_a: nil,
+        b_only_dir: { subsub: nil },
+        b_only_file: nil,
+        dir_in_a_file_in_b: nil,
+        file_in_a_dir_in_b: {},
       }, /cannot_be_in_b/)
     end
     it "Chef::ChefFS::CommandLine.diff_print(/)" do

data/spec/unit/chef_fs/file_pattern_spec.rb

@@ -157,7 +157,7 @@ describe Chef::ChefFS::FilePattern do
     end
   end
 
-  context 'with simple pattern "a\*\b"', :skip => (Chef::Platform.windows?) do
+  context 'with simple pattern "a\*\b"', skip: (Chef::Platform.windows?) do
     let(:pattern) { Chef::ChefFS::FilePattern.new('a\*\b') }
     it "match?" do
       expect(pattern.match?("a*b")).to be_truthy
@@ -264,7 +264,7 @@ describe Chef::ChefFS::FilePattern do
     end
   end
 
-  context 'with star pattern "/abc/d[a-z][0-9]f/ghi"', :skip => (Chef::Platform.windows?) do
+  context 'with star pattern "/abc/d[a-z][0-9]f/ghi"', skip: (Chef::Platform.windows?) do
     let(:pattern) { Chef::ChefFS::FilePattern.new("/abc/d[a-z][0-9]f/ghi") }
     it "match?" do
       expect(pattern.match?("/abc/de1f/ghi")).to be_truthy

data/spec/unit/chef_fs/file_system/repository/directory_spec.rb

@@ -22,7 +22,7 @@ require "chef/chef_fs/file_system/base_fs_object"
 require "chef/chef_fs/file_system/exceptions"
 require "chef/chef_fs/file_system/nonexistent_fs_object"
 
-CHILD_FILES = %w{ test1.json test2.json skip test3.json skip2 test4 }
+CHILD_FILES = %w{ test1.json test2.json skip test3.json skip2 test4 }.freeze
 
 class TestDirectory < Chef::ChefFS::FileSystem::Repository::Directory
   def make_child_entry(name)
@@ -88,7 +88,7 @@ describe Chef::ChefFS::FileSystem::Repository::Directory do
     end
 
     it "returns a non existent object otherwise" do
-      file_double = instance_double(TestFile, :name_valid? => false)
+      file_double = instance_double(TestFile, name_valid?: false)
       expect(TestFile).to receive(:new).with("test_child", test_directory).and_return(file_double)
       expect(test_directory.child("test_child")).to be_an_instance_of(Chef::ChefFS::FileSystem::NonexistentFSObject)
     end

data/spec/unit/chef_fs/file_system_spec.rb

@@ -57,17 +57,17 @@ describe Chef::ChefFS::FileSystem do
   context "with a populated filesystem" do
     let(:fs) do
       memory_fs("", {
-        :a => {
-          :aa => {
-            :c => "",
-            :zz => "",
+        a: {
+          aa: {
+            c: "",
+            zz: "",
           },
-          :ab => {
-            :c => "",
+          ab: {
+            c: "",
           },
         },
-        :x => "",
-        :y => {},
+        x: "",
+        y: {},
       })
     end
     context "list" do

data/spec/unit/chef_fs/parallelizer.rb

@@ -20,7 +20,7 @@ describe Chef::ChefFS::Parallelizer do
     end
 
     def parallelize(inputs, options = {}, &block)
-      parallelizer.parallelize(inputs, { :main_thread_processing => false }.merge(options), &block)
+      parallelizer.parallelize(inputs, { main_thread_processing: false }.merge(options), &block)
     end
 
     it "parallel_do creates unordered output as soon as it is available" do
@@ -35,14 +35,14 @@ describe Chef::ChefFS::Parallelizer do
 
     context "With :ordered => false (unordered output)" do
       it "An empty input produces an empty output" do
-        expect(parallelize([], :ordered => false) do
+        expect(parallelize([], ordered: false) do
           sleep 10
         end.to_a).to eql([])
         expect(elapsed_time).to be < 0.1
       end
 
       it "10 sleep(0.2)s complete within 0.5 seconds" do
-        expect(parallelize(1.upto(10), :ordered => false) do |i|
+        expect(parallelize(1.upto(10), ordered: false) do |i|
           sleep 0.2
           "x"
         end.to_a).to eq(%w{x x x x x x x x x x})
@@ -50,7 +50,7 @@ describe Chef::ChefFS::Parallelizer do
       end
 
       it "The output comes as soon as it is available" do
-        enum = parallelize([0.5, 0.3, 0.1], :ordered => false) do |val|
+        enum = parallelize([0.5, 0.3, 0.1], ordered: false) do |val|
           sleep val
           val
         end
@@ -64,7 +64,7 @@ describe Chef::ChefFS::Parallelizer do
         input = TestEnumerable.new(0.5, 0.3, 0.1) do
           raise "hi"
         end
-        enum = parallelize(input, :ordered => false) { |x| sleep(x); x }
+        enum = parallelize(input, ordered: false) { |x| sleep(x); x }
         results = []
         expect { enum.each { |value| results << value } }.to raise_error "hi"
         expect(results).to eq([ 0.1, 0.3, 0.5 ])
@@ -73,7 +73,7 @@ describe Chef::ChefFS::Parallelizer do
 
       it "Exceptions in output are raised after all processing is done" do
         processed = 0
-        enum = parallelize([1, 2, "x", 3], :ordered => false) do |x|
+        enum = parallelize([1, 2, "x", 3], ordered: false) do |x|
           if x == "x"
             sleep 0.1
             raise "hi"
@@ -91,7 +91,7 @@ describe Chef::ChefFS::Parallelizer do
 
       it "Exceptions with :stop_on_exception are raised after all processing is done" do
         processed = 0
-        parallelized = parallelize([0.3, 0.3, "x", 0.3, 0.3, 0.3, 0.3, 0.3], :ordered => false, :stop_on_exception => true) do |x|
+        parallelized = parallelize([0.3, 0.3, "x", 0.3, 0.3, 0.3, 0.3, 0.3], ordered: false, stop_on_exception: true) do |x|
           if x == "x"
             sleep(0.1)
             raise "hi"
@@ -114,7 +114,7 @@ describe Chef::ChefFS::Parallelizer do
       end
 
       it "10 sleep(0.2)s complete within 0.5 seconds" do
-        expect(parallelize(1.upto(10), :ordered => true) do |i|
+        expect(parallelize(1.upto(10), ordered: true) do |i|
           sleep 0.2
           "x"
         end.to_a).to eq(%w{x x x x x x x x x x})
@@ -163,7 +163,7 @@ describe Chef::ChefFS::Parallelizer do
 
       it "Exceptions with :stop_on_exception are raised after all processing is done" do
         processed = 0
-        parallelized = parallelize([0.3, 0.3, "x", 0.3, 0.3, 0.3, 0.3, 0.3], :ordered => false, :stop_on_exception => true) do |x|
+        parallelized = parallelize([0.3, 0.3, "x", 0.3, 0.3, 0.3, 0.3, 0.3], ordered: false, stop_on_exception: true) do |x|
           if x == "x"
             sleep(0.1)
             raise "hi"
@@ -205,7 +205,7 @@ describe Chef::ChefFS::Parallelizer do
         started = false
         @occupying_job_finished = occupying_job_finished = [ false ]
         @thread = Thread.new do
-          parallelizer.parallelize([0], :main_thread_processing => false) do |x|
+          parallelizer.parallelize([0], main_thread_processing: false) do |x|
             started = true
             sleep(0.3)
             occupying_job_finished[0] = true
@@ -229,7 +229,7 @@ describe Chef::ChefFS::Parallelizer do
       end
 
       it "parallelize with :main_thread_processing = false waits for the job to finish" do
-        expect(parallelizer.parallelize([1], :main_thread_processing => false) do |x|
+        expect(parallelizer.parallelize([1], main_thread_processing: false) do |x|
           sleep(0.1)
           x + 1
         end.to_a).to eq([ 2 ])
@@ -434,7 +434,7 @@ describe Chef::ChefFS::Parallelizer do
     end
 
     it "does not have contention issues with large numbers of inputs with ordering off" do
-      expect(parallelizer.parallelize(1.upto(500), :ordered => false) { |x| x + 1 }.to_a.sort).to eq(2.upto(501).to_a)
+      expect(parallelizer.parallelize(1.upto(500), ordered: false) { |x| x + 1 }.to_a.sort).to eq(2.upto(501).to_a)
     end
 
     it "does not have contention issues with large numbers of jobs and inputs with ordering off" do

data/spec/unit/client_spec.rb

@@ -179,12 +179,12 @@ describe Chef::Client do
 
     context "when an override run list is given" do
       it "permits spaces in overriding run list" do
-        Chef::Client.new(nil, :override_runlist => "role[a], role[b]")
+        Chef::Client.new(nil, override_runlist: "role[a], role[b]")
       end
 
       describe "calling run" do
         include_examples "a successful client run" do
-          let(:client_opts) { { :override_runlist => "recipe[override_recipe]" } }
+          let(:client_opts) { { override_runlist: "recipe[override_recipe]" } }
 
           def stub_for_sync_cookbooks
             # --Client#setup_run_context
@@ -192,9 +192,9 @@ describe Chef::Client do
             #
             expect_any_instance_of(Chef::CookbookSynchronizer).to receive(:sync_cookbooks)
             expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], version_class: Chef::CookbookManifestVersions).and_return(http_cookbook_sync)
-            expect(http_cookbook_sync).to receive(:post).
-              with("environments/_default/cookbook_versions", { :run_list => ["override_recipe"] }).
-              and_return({})
+            expect(http_cookbook_sync).to receive(:post)
+              .with("environments/_default/cookbook_versions", { run_list: ["override_recipe"] })
+              .and_return({})
           end
 
           def stub_for_node_save
@@ -218,7 +218,7 @@ describe Chef::Client do
 
       include_examples "a successful client run" do
         let(:new_runlist) { "recipe[new_run_list_recipe]" }
-        let(:client_opts) { { :runlist => new_runlist } }
+        let(:client_opts) { { runlist: new_runlist } }
 
         def stub_for_sync_cookbooks
           # --Client#setup_run_context
@@ -226,9 +226,9 @@ describe Chef::Client do
           #
           expect_any_instance_of(Chef::CookbookSynchronizer).to receive(:sync_cookbooks)
           expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], version_class: Chef::CookbookManifestVersions).and_return(http_cookbook_sync)
-          expect(http_cookbook_sync).to receive(:post).
-            with("environments/_default/cookbook_versions", { :run_list => ["new_run_list_recipe"] }).
-            and_return({})
+          expect(http_cookbook_sync).to receive(:post)
+            .with("environments/_default/cookbook_versions", { run_list: ["new_run_list_recipe"] })
+            .and_return({})
         end
 
         before do
@@ -293,7 +293,7 @@ describe Chef::Client do
 
   describe "when handling run failures" do
     it "should remove the run_lock on failure of #load_node" do
-      @run_lock = double("Chef::RunLock", :acquire => true)
+      @run_lock = double("Chef::RunLock", acquire: true)
       allow(Chef::RunLock).to receive(:new).and_return(@run_lock)
 
       @events = double("Chef::EventDispatch::Dispatcher").as_null_object
@@ -410,8 +410,8 @@ describe Chef::Client do
     let(:run_context) { double("Chef::RunContext") }
     let(:recipe)      { double("Chef::Recipe (required recipe)") }
     let(:required_recipe) do
-      <<EOM
-fake_recipe_variable = "for reals"
+      <<~EOM
+        fake_recipe_variable = "for reals"
 EOM
     end
 
@@ -429,8 +429,8 @@ EOM
 
       context "when the required_recipe has bad contents" do
         let(:required_recipe) do
-          <<EOM
-this is not a recipe
+          <<~EOM
+            this is not a recipe
 EOM
         end
         it "should not raise an error" do
@@ -488,7 +488,7 @@ EOM
 
         context "fatal admin check is configured" do
           it "should not raise an exception" do
-            client.do_windows_admin_check #should not raise
+            client.do_windows_admin_check # should not raise
           end
         end
       end

data/spec/unit/config_fetcher_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "chef/config_fetcher"
 
 describe Chef::ConfigFetcher do
-  let(:valid_json) { Chef::JSONCompat.to_json({ :a => "b" }) }
+  let(:valid_json) { Chef::JSONCompat.to_json({ a: "b" }) }
   let(:invalid_json) { %q[{"syntax-error": "missing quote}] }
   let(:http) { double("Chef::HTTP::Simple") }
 
@@ -16,9 +16,9 @@ describe Chef::ConfigFetcher do
     let(:config_content) { "# The client.rb content" }
 
     it "reads the file from disk" do
-      expect(::File).to receive(:read).
-        with(config_location).
-        and_return(config_content)
+      expect(::File).to receive(:read)
+        .with(config_location)
+        .and_return(config_content)
       expect(fetcher.read_config).to eq(config_content)
     end
 
@@ -42,9 +42,9 @@ describe Chef::ConfigFetcher do
       let(:config_location) { "/etc/chef/first-boot.json" }
 
       it "returns the parsed JSON" do
-        expect(::File).to receive(:read).
-          with(config_location).
-          and_return(valid_json)
+        expect(::File).to receive(:read)
+          .with(config_location)
+          .and_return(valid_json)
 
         expect(fetcher.fetch_json).to eq({ "a" => "b" })
       end
@@ -53,12 +53,12 @@ describe Chef::ConfigFetcher do
 
         it "reports the JSON error" do
 
-          expect(::File).to receive(:read).
-            with(config_location).
-            and_return(invalid_json)
+          expect(::File).to receive(:read)
+            .with(config_location)
+            .and_return(invalid_json)
 
-          expect(Chef::Application).to receive(:fatal!).
-            with(invalid_json_error_regex)
+          expect(Chef::Application).to receive(:fatal!)
+            .with(invalid_json_error_regex)
           fetcher.fetch_json
         end
       end
@@ -78,14 +78,14 @@ describe Chef::ConfigFetcher do
     describe "reading the file" do
 
       before do
-        expect(Chef::HTTP::Simple).to receive(:new).
-          with(config_location).
-          and_return(http)
+        expect(Chef::HTTP::Simple).to receive(:new)
+          .with(config_location)
+          .and_return(http)
       end
 
       it "reads the file over HTTP" do
-        expect(http).to receive(:get).
-          with("").and_return(config_content)
+        expect(http).to receive(:get)
+          .with("").and_return(config_content)
         expect(fetcher.read_config).to eq(config_content)
       end
 
@@ -93,18 +93,18 @@ describe Chef::ConfigFetcher do
         let(:config_location) { "https://example.com/foo.json" }
 
         it "fetches the file and parses it" do
-          expect(http).to receive(:get).
-            with("").and_return(valid_json)
+          expect(http).to receive(:get)
+            .with("").and_return(valid_json)
           expect(fetcher.fetch_json).to eq({ "a" => "b" })
         end
 
         context "and the JSON is invalid" do
           it "reports the JSON error" do
-            expect(http).to receive(:get).
-              with("").and_return(invalid_json)
+            expect(http).to receive(:get)
+              .with("").and_return(invalid_json)
 
-            expect(Chef::Application).to receive(:fatal!).
-              with(invalid_json_error_regex)
+            expect(Chef::Application).to receive(:fatal!)
+              .with(invalid_json_error_regex)
             fetcher.fetch_json
           end
         end