chef 14.2.0-universal-mingw32 → 14.3.37-universal-mingw32

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -36,7 +36,7 @@ describe Chef::Knife::CookbookUpload do
     cookbook_loader
   end
 
-  let(:cookbook_uploader) { double(:upload_cookbooks => nil) }
+  let(:cookbook_uploader) { double(upload_cookbooks: nil) }
 
   let(:output) { StringIO.new }
 
@@ -61,16 +61,16 @@ describe Chef::Knife::CookbookUpload do
       test_cookbook = Chef::CookbookVersion.new("test_cookbook", "/tmp/blah")
       allow(cookbook_loader).to receive(:each).and_yield("test_cookbook", test_cookbook)
       allow(cookbook_loader).to receive(:cookbook_names).and_return(["test_cookbook"])
-      expect(Chef::CookbookUploader).to receive(:new).
-        with( kind_of(Array), { :force => nil, :concurrency => 3 }).
-        and_return(double("Chef::CookbookUploader", :upload_cookbooks => true))
+      expect(Chef::CookbookUploader).to receive(:new)
+        .with( kind_of(Array), { force: nil, concurrency: 3 })
+        .and_return(double("Chef::CookbookUploader", upload_cookbooks: true))
       knife.run
     end
   end
 
   describe "run" do
     before(:each) do
-      allow(Chef::CookbookUploader).to receive_messages(:new => cookbook_uploader)
+      allow(Chef::CookbookUploader).to receive_messages(new: cookbook_uploader)
       allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
     end
 
@@ -106,22 +106,22 @@ describe Chef::Knife::CookbookUpload do
 
       before do
         allow(cookbook_loader).to receive(:merged_cookbooks).and_return(["test_cookbook"])
-        allow(cookbook_loader).to receive(:merged_cookbook_paths).
-          and_return({ "test_cookbook" => %w{/path/one/test_cookbook /path/two/test_cookbook} })
+        allow(cookbook_loader).to receive(:merged_cookbook_paths)
+          .and_return({ "test_cookbook" => %w{/path/one/test_cookbook /path/two/test_cookbook} })
       end
 
       it "emits a warning" do
         knife.run
-        expected_message = <<-E
-WARNING: The cookbooks: test_cookbook exist in multiple places in your cookbook_path.
-A composite version of these cookbooks has been compiled for uploading.
-
-IMPORTANT: In a future version of Chef, this behavior will be removed and you will no longer
-be able to have the same version of a cookbook in multiple places in your cookbook_path.
-WARNING: The affected cookbooks are located:
-test_cookbook:
-  /path/one/test_cookbook
-  /path/two/test_cookbook
+        expected_message = <<~E
+          WARNING: The cookbooks: test_cookbook exist in multiple places in your cookbook_path.
+          A composite version of these cookbooks has been compiled for uploading.
+
+          IMPORTANT: In a future version of Chef, this behavior will be removed and you will no longer
+          be able to have the same version of a cookbook in multiple places in your cookbook_path.
+          WARNING: The affected cookbooks are located:
+          test_cookbook:
+            /path/one/test_cookbook
+            /path/two/test_cookbook
 E
         expect(output.string).to include(expected_message)
       end
@@ -310,8 +310,8 @@ E
     describe "when a frozen cookbook exists on the server" do
       it "should fail to replace it" do
         exception = Chef::Exceptions::CookbookFrozen.new
-        expect(cookbook_uploader).to receive(:upload_cookbooks).
-          and_raise(exception)
+        expect(cookbook_uploader).to receive(:upload_cookbooks)
+          .and_raise(exception)
         allow(knife.ui).to receive(:error)
         expect(knife.ui).to receive(:error).with(exception)
         expect { knife.run }.to raise_error(SystemExit)

data/spec/unit/knife/core/bootstrap_context_spec.rb

@@ -26,15 +26,15 @@ describe Chef::Knife::Core::BootstrapContext do
     Chef::Config[:fips] = false
   end
 
-  let(:config) { { :foo => :bar, :color => true } }
+  let(:config) { { foo: :bar, color: true } }
   let(:run_list) { Chef::RunList.new("recipe[tmux]", "role[base]") }
   let(:chef_config) do
     {
-      :config_log_level => "info",
-      :config_log_location => "/tmp/log",
-      :validation_key => File.join(CHEF_SPEC_DATA, "ssl", "private_key.pem"),
-      :chef_server_url => "http://chef.example.com:4444",
-      :validation_client_name => "chef-validator-testing",
+      config_log_level: "info",
+      config_log_location: "/tmp/log",
+      validation_key: File.join(CHEF_SPEC_DATA, "ssl", "private_key.pem"),
+      chef_server_url: "http://chef.example.com:4444",
+      validation_client_name: "chef-validator-testing",
     }
   end
 
@@ -51,14 +51,14 @@ describe Chef::Knife::Core::BootstrapContext do
   end
 
   describe "when in verbosity mode" do
-    let(:config) { { :verbosity => 2, :color => true } }
+    let(:config) { { verbosity: 2, color: true } }
     it "adds '-l debug' when verbosity is >= 2" do
       expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json -l debug"
     end
   end
 
   describe "when no color value has been set in config" do
-    let(:config) { { :color => false } }
+    let(:config) { { color: false } }
     it "adds '--no-color' when color is false" do
       expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json --no-color"
     end
@@ -69,25 +69,25 @@ describe Chef::Knife::Core::BootstrapContext do
   end
 
   it "generates the config file data" do
-    expected = <<-EXPECTED
-chef_server_url  "http://chef.example.com:4444"
-validation_client_name "chef-validator-testing"
-log_level   :info
-log_location   "/tmp/log"
-# Using default node name (fqdn)
+    expected = <<~EXPECTED
+      chef_server_url  "http://chef.example.com:4444"
+      validation_client_name "chef-validator-testing"
+      log_level   :info
+      log_location   "/tmp/log"
+      # Using default node name (fqdn)
 EXPECTED
     expect(bootstrap_context.config_content).to eq expected
   end
 
   describe "alternate chef-client path" do
-    let(:chef_config) { { :chef_client_path => "/usr/local/bin/chef-client" } }
+    let(:chef_config) { { chef_client_path: "/usr/local/bin/chef-client" } }
     it "runs chef-client from another path when specified" do
       expect(bootstrap_context.start_chef).to eq "/usr/local/bin/chef-client -j /etc/chef/first-boot.json"
     end
   end
 
   describe "validation key path that contains a ~" do
-    let(:chef_config) { { :validation_key => "~/my.key" } }
+    let(:chef_config) { { validation_key: "~/my.key" } }
     it "reads the validation key when it contains a ~" do
       expect(File).to receive(:exist?).with(File.expand_path("my.key", ENV["HOME"])).and_return(true)
       expect(IO).to receive(:read).with(File.expand_path("my.key", ENV["HOME"]))
@@ -96,36 +96,36 @@ EXPECTED
   end
 
   describe "when an explicit node name is given" do
-    let(:config) { { :chef_node_name => "foobar.example.com" } }
+    let(:config) { { chef_node_name: "foobar.example.com" } }
     it "sets the node name in the client.rb" do
       expect(bootstrap_context.config_content).to match(/node_name "foobar\.example\.com"/)
     end
   end
 
   describe "when bootstrapping into a specific environment" do
-    let(:config) { { :environment => "prodtastic", :color => true } }
+    let(:config) { { environment: "prodtastic", color: true } }
     it "starts chef in the configured environment" do
       expect(bootstrap_context.start_chef).to eq("chef-client -j /etc/chef/first-boot.json -E prodtastic")
     end
   end
 
   describe "when tags are given" do
-    let(:config) { { :tags => [ "unicorn" ] } }
+    let(:config) { { tags: [ "unicorn" ] } }
     it "adds the attributes to first_boot" do
-      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ :run_list => run_list, :tags => ["unicorn"] }))
+      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ run_list: run_list, tags: ["unicorn"] }))
     end
   end
 
   describe "when JSON attributes are given" do
-    let(:config) { { :first_boot_attributes => { :baz => :quux } } }
+    let(:config) { { first_boot_attributes: { baz: :quux } } }
     it "adds the attributes to first_boot" do
-      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ :baz => :quux, :run_list => run_list }))
+      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ baz: :quux, run_list: run_list }))
     end
   end
 
   describe "when JSON attributes are NOT given" do
     it "sets first_boot equal to run_list" do
-      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ :run_list => run_list }))
+      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({ run_list: run_list }))
     end
   end
 
@@ -159,7 +159,7 @@ EXPECTED
   describe "when a bootstrap_version is specified" do
     let(:chef_config) do
       {
-        :knife => { :bootstrap_version => "11.12.4" },
+        knife: { bootstrap_version: "11.12.4" },
       }
     end
 
@@ -171,7 +171,7 @@ EXPECTED
   describe "when a pre-release bootstrap_version is specified" do
     let(:chef_config) do
       {
-        :knife => { :bootstrap_version => "11.12.4.rc.0" },
+        knife: { bootstrap_version: "11.12.4.rc.0" },
       }
     end
 
@@ -195,7 +195,7 @@ EXPECTED
     describe "when configured in config" do
       let(:chef_config) do
         {
-          :knife => { :ssl_verify_mode => :verify_peer },
+          knife: { ssl_verify_mode: :verify_peer },
         }
       end
 
@@ -204,7 +204,7 @@ EXPECTED
       end
 
       describe "when configured via CLI" do
-        let(:config) { { :node_ssl_verify_mode => "none" } }
+        let(:config) { { node_ssl_verify_mode: "none" } }
 
         it "uses CLI value" do
           expect(bootstrap_context.config_content).to include("ssl_verify_mode :verify_none")
@@ -238,7 +238,7 @@ EXPECTED
     describe "when configured in config" do
       let(:chef_config) do
         {
-          :knife => { :verify_api_cert => :false },
+          knife: { verify_api_cert: :false },
         }
       end
 
@@ -247,7 +247,7 @@ EXPECTED
       end
 
       describe "when configured via CLI" do
-        let(:config) { { :node_verify_api_cert => true } }
+        let(:config) { { node_verify_api_cert: true } }
 
         it "uses CLI value" do
           expect(bootstrap_context.config_content).to include("verify_api_cert true")
@@ -262,7 +262,7 @@ EXPECTED
     end
 
     describe "when configured via cli" do
-      let(:config) { { :prerelease => true } }
+      let(:config) { { prerelease: true } }
 
       it "uses CLI value" do
         expect(bootstrap_context.latest_current_chef_version_string).to eq("-p")
@@ -272,49 +272,49 @@ EXPECTED
 
   describe "#config_log_location" do
     context "when config_log_location is nil" do
-      let(:chef_config) { { :config_log_location => nil } }
+      let(:chef_config) { { config_log_location: nil } }
       it "sets the default config_log_location  in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "STDOUT"
       end
     end
 
     context "when config_log_location is empty" do
-      let(:chef_config) { { :config_log_location => "" } }
+      let(:chef_config) { { config_log_location: "" } }
       it "sets the default config_log_location  in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "STDOUT"
       end
     end
 
     context "when config_log_location is :win_evt" do
-      let(:chef_config) { { :config_log_location => :win_evt } }
+      let(:chef_config) { { config_log_location: :win_evt } }
       it "raise error when config_log_location is :win_evt " do
         expect { bootstrap_context.get_log_location }.to raise_error("The value :win_evt is not supported for config_log_location on Linux Platforms \n")
       end
     end
 
     context "when config_log_location is :syslog" do
-      let(:chef_config) { { :config_log_location => :syslog } }
+      let(:chef_config) { { config_log_location: :syslog } }
       it "sets the config_log_location value as :syslog in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq ":syslog"
       end
     end
 
     context "When config_log_location is STDOUT" do
-      let(:chef_config) { { :config_log_location => STDOUT } }
+      let(:chef_config) { { config_log_location: STDOUT } }
       it "Sets the config_log_location value as STDOUT in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "STDOUT"
       end
     end
 
     context "when config_log_location is STDERR" do
-      let(:chef_config) { { :config_log_location => STDERR } }
+      let(:chef_config) { { config_log_location: STDERR } }
       it "sets the config_log_location value as STDERR  in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "STDERR"
       end
     end
 
     context "when config_log_location is a path" do
-      let(:chef_config) { { :config_log_location => "/tmp/ChefLogFile" } }
+      let(:chef_config) { { config_log_location: "/tmp/ChefLogFile" } }
       it "sets the config_log_location path in the client.rb" do
         expect(bootstrap_context.get_log_location).to eq "\"/tmp/ChefLogFile\""
       end

data/spec/unit/knife/core/cookbook_scm_repo_spec.rb

@@ -24,7 +24,7 @@ describe Chef::Knife::CookbookSCMRepo do
     @repo_path = File.join(CHEF_SPEC_DATA, "cookbooks")
     @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
     @ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
-    @cookbook_repo = Chef::Knife::CookbookSCMRepo.new(@repo_path, @ui, :default_branch => "master")
+    @cookbook_repo = Chef::Knife::CookbookSCMRepo.new(@repo_path, @ui, default_branch: "master")
 
     @branch_list = Mixlib::ShellOut.new
     @branch_list.stdout.replace(<<-BRANCHES)
@@ -69,7 +69,7 @@ BRANCHES
 
         it "exits when the default branch doesn't exist" do
           @nobranches = Mixlib::ShellOut.new.tap { |s| s.stdout.replace "\n" }
-          expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@nobranches)
+          expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@nobranches)
           expect { @cookbook_repo.sanity_check }.to raise_error(SystemExit)
         end
 
@@ -77,7 +77,7 @@ BRANCHES
           before do
             @master_branch = Mixlib::ShellOut.new
             @master_branch.stdout.replace "* master\n"
-            expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@master_branch)
+            expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@master_branch)
           end
 
           it "exits when the git repo is dirty" do
@@ -85,14 +85,14 @@ BRANCHES
             @dirty_status.stdout.replace(<<-DIRTY)
  M chef/lib/chef/knife/cookbook_site_install.rb
 DIRTY
-            expect(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain", :cwd => @repo_path).and_return(@dirty_status)
+            expect(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain", cwd: @repo_path).and_return(@dirty_status)
             expect { @cookbook_repo.sanity_check }.to raise_error(SystemExit)
           end
 
           describe "and the repo is clean" do
             before do
               @clean_status = Mixlib::ShellOut.new.tap { |s| s.stdout.replace("\n") }
-              allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain", :cwd => @repo_path).and_return(@clean_status)
+              allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain", cwd: @repo_path).and_return(@clean_status)
             end
 
             it "passes the sanity check" do
@@ -106,35 +106,35 @@ DIRTY
   end
 
   it "resets to default state by checking out the default branch" do
-    expect(@cookbook_repo).to receive(:shell_out!).with("git checkout master", :cwd => @repo_path)
+    expect(@cookbook_repo).to receive(:shell_out!).with("git checkout master", cwd: @repo_path)
     @cookbook_repo.reset_to_default_state
   end
 
   it "determines if a the pristine copy branch exists" do
-    expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@branch_list)
+    expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
     expect(@cookbook_repo.branch_exists?("chef-vendor-apache2")).to be_truthy
-    expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@branch_list)
+    expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
     expect(@cookbook_repo.branch_exists?("chef-vendor-nginx")).to be_falsey
   end
 
   it "determines if a the branch not exists correctly without substring search" do
-    expect(@cookbook_repo).to receive(:shell_out!).twice.with("git branch --no-color", :cwd => @repo_path).and_return(@branch_list)
+    expect(@cookbook_repo).to receive(:shell_out!).twice.with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
     expect(@cookbook_repo).not_to be_branch_exists("chef-vendor-absent")
     expect(@cookbook_repo).to be_branch_exists("chef-vendor-absent-new")
   end
 
   describe "when the pristine copy branch does not exist" do
     it "prepares for import by creating the pristine copy branch" do
-      expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@branch_list)
-      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout -b chef-vendor-nginx", :cwd => @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout -b chef-vendor-nginx", cwd: @repo_path)
       @cookbook_repo.prepare_to_import("nginx")
     end
   end
 
   describe "when the pristine copy branch does exist" do
     it "prepares for import by checking out the pristine copy branch" do
-      expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@branch_list)
-      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout chef-vendor-apache2", :cwd => @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout chef-vendor-apache2", cwd: @repo_path)
       @cookbook_repo.prepare_to_import("apache2")
     end
   end
@@ -143,7 +143,7 @@ DIRTY
     before do
       @updates = Mixlib::ShellOut.new
       @updates.stdout.replace("\n")
-      allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain -- apache2", :cwd => @repo_path).and_return(@updates)
+      allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain -- apache2", cwd: @repo_path).and_return(@updates)
     end
 
     it "shows no changes in the pristine copy" do
@@ -159,7 +159,7 @@ DIRTY
     before do
       @updates = Mixlib::ShellOut.new
       @updates.stdout.replace(" M cookbooks/apache2/recipes/default.rb\n")
-      allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain -- apache2", :cwd => @repo_path).and_return(@updates)
+      allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain -- apache2", cwd: @repo_path).and_return(@updates)
     end
 
     it "shows changes in the pristine copy" do
@@ -167,20 +167,20 @@ DIRTY
     end
 
     it "commits the changes to the repo and tags the commit" do
-      expect(@cookbook_repo).to receive(:shell_out!).with("git add apache2", :cwd => @repo_path)
-      expect(@cookbook_repo).to receive(:shell_out!).with("git commit -m \"Import apache2 version 1.2.3\" -- apache2", :cwd => @repo_path)
-      expect(@cookbook_repo).to receive(:shell_out!).with("git tag -f cookbook-site-imported-apache2-1.2.3", :cwd => @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git add apache2", cwd: @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git commit -m \"Import apache2 version 1.2.3\" -- apache2", cwd: @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git tag -f cookbook-site-imported-apache2-1.2.3", cwd: @repo_path)
       expect(@cookbook_repo.finalize_updates_to("apache2", "1.2.3")).to be_truthy
     end
   end
 
   describe "when a custom default branch is specified" do
     before do
-      @cookbook_repo = Chef::Knife::CookbookSCMRepo.new(@repo_path, @ui, :default_branch => "develop")
+      @cookbook_repo = Chef::Knife::CookbookSCMRepo.new(@repo_path, @ui, default_branch: "develop")
     end
 
     it "resets to default state by checking out the default branch" do
-      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout develop", :cwd => @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout develop", cwd: @repo_path)
       @cookbook_repo.reset_to_default_state
     end
   end

data/spec/unit/knife/core/object_loader_spec.rb

@@ -57,7 +57,7 @@ describe Chef::Knife::Core::ObjectLoader do
         it_behaves_like "Chef object", chef_class
       end
 
-      #NOTE: This is check for the bug described at CHEF-2352
+      # NOTE: This is check for the bug described at CHEF-2352
       describe "when the file is a JSON" do
         describe "and it has defined 'json_class'" do
           before do

data/spec/unit/knife/core/ui_spec.rb

@@ -25,10 +25,10 @@ describe Chef::Knife::UI do
   before do
     @out, @err, @in = StringIO.new, StringIO.new, StringIO.new
     @config = {
-      :verbosity => 0,
-      :yes => nil,
-      :format => "summary",
-      :field_separator => ".",
+      verbosity: 0,
+      yes: nil,
+      format: "summary",
+      field_separator: ".",
     }
     @ui = Chef::Knife::UI.new(@out, @err, @in, @config)
   end
@@ -171,12 +171,12 @@ describe Chef::Knife::UI do
   describe "format_list_for_display" do
     it "should print the full hash if --with-uri is true" do
       @ui.config[:with_uri] = true
-      expect(@ui.format_list_for_display({ :marcy => :playground })).to eq({ :marcy => :playground })
+      expect(@ui.format_list_for_display({ marcy: :playground })).to eq({ marcy: :playground })
     end
 
     it "should print only the keys if --with-uri is false" do
       @ui.config[:with_uri] = false
-      expect(@ui.format_list_for_display({ :marcy => :playground })).to eq([ :marcy ])
+      expect(@ui.format_list_for_display({ marcy: :playground })).to eq([ :marcy ])
     end
   end
 
@@ -211,9 +211,9 @@ describe Chef::Knife::UI do
 
     it "formats hashes appropriately" do
       @ui.output({ "hi" => "a", "lo" => "b" })
-      expect(@out.string).to eq <<EOM
-hi: a
-lo: b
+      expect(@out.string).to eq <<~EOM
+        hi: a
+        lo: b
 EOM
     end
 
@@ -224,9 +224,9 @@ EOM
 
     it "formats arrays appropriately" do
       @ui.output(%w{a b})
-      expect(@out.string).to eq <<EOM
-a
-b
+      expect(@out.string).to eq <<~EOM
+        a
+        b
 EOM
     end
 
@@ -247,74 +247,74 @@ EOM
 
     it "formats nested arrays appropriately" do
       @ui.output([ %w{a b}, %w{c d}])
-      expect(@out.string).to eq <<EOM
-a
-b
+      expect(@out.string).to eq <<~EOM
+        a
+        b
 
-c
-d
+        c
+        d
 EOM
     end
 
     it "formats nested arrays with single- and empty subarrays appropriately" do
       @ui.output([ %w{a b}, [ "c" ], [], %w{d e}])
-      expect(@out.string).to eq <<EOM
-a
-b
+      expect(@out.string).to eq <<~EOM
+        a
+        b
 
-c
+        c
 
 
-d
-e
+        d
+        e
 EOM
     end
 
     it "formats arrays of hashes with extra lines in between for readability" do
       @ui.output([ { "a" => "b", "c" => "d" }, { "x" => "y" }, { "m" => "n", "o" => "p" }])
-      expect(@out.string).to eq <<EOM
-a: b
-c: d
+      expect(@out.string).to eq <<~EOM
+        a: b
+        c: d
 
-x: y
+        x: y
 
-m: n
-o: p
+        m: n
+        o: p
 EOM
     end
 
     it "formats hashes with empty array members appropriately" do
       @ui.output({ "a" => [], "b" => "c" })
-      expect(@out.string).to eq <<EOM
-a:
-b: c
+      expect(@out.string).to eq <<~EOM
+        a:
+        b: c
 EOM
     end
 
     it "formats hashes with single-member array values appropriately" do
       @ui.output({ "a" => [ "foo" ], "b" => "c" })
-      expect(@out.string).to eq <<EOM
-a: foo
-b: c
+      expect(@out.string).to eq <<~EOM
+        a: foo
+        b: c
 EOM
     end
 
     it "formats hashes with array members appropriately" do
       @ui.output({ "a" => %w{foo bar}, "b" => "c" })
-      expect(@out.string).to eq <<EOM
-a:
-  foo
-  bar
-b: c
+      expect(@out.string).to eq <<~EOM
+        a:
+          foo
+          bar
+        b: c
 EOM
     end
 
     it "formats hashes with single-member nested array values appropriately" do
       @ui.output({ "a" => [ [ "foo" ] ], "b" => "c" })
-      expect(@out.string).to eq <<EOM
-a:
-  foo
-b: c
+      expect(@out.string).to eq <<~EOM
+        a:
+          foo
+        b: c
 EOM
     end
 
@@ -327,19 +327,19 @@ EOM
 
     it "formats hashes with hash values appropriately" do
       @ui.output({ "a" => { "aa" => "bb", "cc" => "dd" }, "b" => "c" })
-      expect(@out.string).to eq <<EOM
-a:
-  aa: bb
-  cc: dd
-b: c
+      expect(@out.string).to eq <<~EOM
+        a:
+          aa: bb
+          cc: dd
+        b: c
 EOM
     end
 
     it "formats hashes with empty hash values appropriately" do
       @ui.output({ "a" => {}, "b" => "c" })
-      expect(@out.string).to eq <<EOM
-a:
-b: c
+      expect(@out.string).to eq <<~EOM
+        a:
+        b: c
 EOM
     end
   end
@@ -358,7 +358,7 @@ EOM
 
   describe "format_for_display" do
     it "should return the raw data" do
-      input = { :gi => :go }
+      input = { gi: :go }
       expect(@ui.format_for_display(input)).to eq(input)
     end
 
@@ -480,7 +480,7 @@ EOM
 
     context "when running on Windows" do
       before(:each) do
-        stdout = double("StringIO", :tty? => true)
+        stdout = double("StringIO", tty?: true)
         allow(@ui).to receive(:stdout).and_return(stdout)
         allow(ChefConfig).to receive(:windows?) { true }
         Chef::Config.reset
@@ -631,7 +631,7 @@ EOM
       out = StringIO.new
       allow(@ui).to receive(:stdout).and_return(out)
       allow(@ui).to receive(:stdin).and_return(StringIO.new(" \n"))
-      expect(@ui.ask_question("your chef server URL? ", :default => "http://localhost:4000")).to eq("http://localhost:4000")
+      expect(@ui.ask_question("your chef server URL? ", default: "http://localhost:4000")).to eq("http://localhost:4000")
       expect(out.string).to eq("your chef server URL? [http://localhost:4000] ")
     end
   end