chef 16.1.16 → 16.18.30

data/spec/unit/mixin/powershell_exec_spec.rb

@@ -24,8 +24,37 @@ describe Chef::Mixin::PowershellExec, :windows_only do
   subject(:object) { powershell_mixin.new }
 
   describe "#powershell_exec" do
-    it "runs a basic command and returns a Chef::PowerShell object" do
-      expect(object.powershell_exec("$PSVersionTable")).to be_kind_of(Chef::PowerShell)
+    context "not specifying an interpreter" do
+      it "runs a basic command and returns a ChefPowerShell::PowerShell object" do
+        expect(object.powershell_exec("$PSVersionTable")).to be_kind_of(ChefPowerShell::PowerShell)
+      end
+
+      it "uses less than version 6" do
+        execution = object.powershell_exec("$PSVersionTable")
+        expect(execution.result["PSVersion"].to_s.to_i).to be < 6
+      end
+    end
+
+    context "using pwsh interpreter" do
+      it "runs a basic command and returns a ChefPowerShell::Pwsh object" do
+        expect(object.powershell_exec("$PSVersionTable", :pwsh)).to be_kind_of(ChefPowerShell::Pwsh)
+      end
+
+      it "uses greater than version 6" do
+        execution = object.powershell_exec("$PSVersionTable", :pwsh)
+        expect(execution.result["PSVersion"]["Major"]).to be > 6
+      end
+    end
+
+    context "using powershell interpreter" do
+      it "runs a basic command and returns a ChefPowerShell::PowerShell object" do
+        expect(object.powershell_exec("$PSVersionTable", :powershell)).to be_kind_of(ChefPowerShell::PowerShell)
+      end
+
+      it "uses less than version 6" do
+        execution = object.powershell_exec("$PSVersionTable", :powershell)
+        expect(execution.result["PSVersion"].to_s.to_i).to be < 6
+      end
     end
 
     it "runs a command that fails with a non-terminating error and can trap the error via .error?" do
@@ -37,17 +66,25 @@ describe Chef::Mixin::PowershellExec, :windows_only do
       execution = object.powershell_exec("this-should-error")
       expect(execution.errors).to be_a_kind_of(Array)
       expect(execution.errors[0]).to be_a_kind_of(String)
-      expect(execution.errors[0]).to include("Runtime exception: this-should-error")
+      expect(execution.errors[0]).to include("The term 'this-should-error' is not recognized")
+    end
+
+    it "raises an error if the interpreter is invalid" do
+      expect { object.powershell_exec("this-should-error", :powerfart) }.to raise_error(ArgumentError)
     end
   end
 
   describe "#powershell_exec!" do
-    it "runs a basic command and returns a Chef::PowerShell object" do
-      expect(object.powershell_exec!("$PSVersionTable")).to be_kind_of(Chef::PowerShell)
+    it "runs a basic command and returns a ChefPowerShell::PowerShell object" do
+      expect(object.powershell_exec!("$PSVersionTable")).to be_kind_of(ChefPowerShell::PowerShell)
     end
 
     it "raises an error if the command fails" do
-      expect(object.powershell_exec!("$PSVersionTable")).to be_kind_of(Chef::PowerShell::CommandFailed)
+      expect { object.powershell_exec!("this-should-error") }.to raise_error(ChefPowerShell::PowerShellExceptions::PowerShellCommandFailed)
+    end
+
+    it "raises an error if the interpreter is invalid" do
+      expect { object.powershell_exec!("this-should-error", :powerfart) }.to raise_error(ArgumentError)
     end
   end
 end

data/spec/unit/mixin/powershell_out_spec.rb

@@ -30,8 +30,7 @@ describe Chef::Mixin::PowershellOut, :windows_only do
     it "runs a command and returns the shell_out object" do
       ret = double("Mixlib::ShellOut")
       expect(object).to receive(:shell_out).with(
-        "powershell.exe #{flags} -Command \"Get-Process\"",
-        {}
+        "powershell.exe #{flags} -Command \"Get-Process\"", {}
       ).and_return(ret)
       expect(object.powershell_out("Get-Process")).to eql(ret)
     end
@@ -45,6 +44,20 @@ describe Chef::Mixin::PowershellOut, :windows_only do
       expect(object.powershell_out("Get-Process", timeout: 600)).to eql(ret)
     end
 
+    it "uses pwsh.exe when given :pwsh interpreter" do
+      ret = double("Mixlib::ShellOut")
+      expect(object).to receive(:shell_out).with(
+        "pwsh.exe #{flags} -Command \"Get-Process\"",
+        timeout: 600
+      ).and_return(ret)
+      expect(object.powershell_out("Get-Process", :pwsh, timeout: 600)).to eql(ret)
+    end
+
+    it "raises error if interpreter is invalid" do
+      ret = double("Mixlib::ShellOut")
+      expect { object.powershell_out("Get-Process", :blah, timeout: 600) }.to raise_error(ArgumentError)
+    end
+
     context "when double quote is passed in the powershell command" do
       it "passes if double quote is appended with single escape" do
         result = object.powershell_out("Write-Verbose \"Some String\" -Verbose")
@@ -62,8 +75,7 @@ describe Chef::Mixin::PowershellOut, :windows_only do
     it "runs a command and returns the shell_out object" do
       mixlib_shellout = double("Mixlib::ShellOut")
       expect(object).to receive(:shell_out).with(
-        "powershell.exe #{flags} -Command \"Get-Process\"",
-        {}
+        "powershell.exe #{flags} -Command \"Get-Process\"", {}
       ).and_return(mixlib_shellout)
       expect(mixlib_shellout).to receive(:error!)
       expect(object.powershell_out!("Get-Process")).to eql(mixlib_shellout)

data/spec/unit/mixin/powershell_type_coercions_spec.rb

@@ -25,7 +25,7 @@ class Chef::PSTypeTester
 end
 
 describe Chef::Mixin::PowershellTypeCoercions do
-  let (:test_class) { Chef::PSTypeTester.new }
+  let(:test_class) { Chef::PSTypeTester.new }
 
   describe "#translate_type" do
     it "single quotes a string" do

data/spec/unit/mixin/securable_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 #
 # Author:: Mark Mzyk (<mmzyk@chef.io>)
 # Copyright:: Copyright (c) Chef Software Inc.
@@ -46,7 +45,7 @@ describe Chef::Mixin::Securable do
   describe "unix-specific behavior" do
     before(:each) do
       platform_mock :unix do
-        load File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "chef", "mixin", "securable.rb")
+        load File.join(__dir__, "..", "..", "..", "lib", "chef", "mixin", "securable.rb")
         @securable = Object.new
         @securable.send(:extend, Chef::Mixin::Securable)
         @securable.send(:extend, Chef::Mixin::ParamsValidate)
@@ -177,7 +176,7 @@ describe Chef::Mixin::Securable do
   describe "windows-specific behavior" do
     before(:each) do
       platform_mock :windows do
-        load File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "chef", "mixin", "securable.rb")
+        load File.join(__dir__, "..", "..", "..", "lib", "chef", "mixin", "securable.rb")
         securable_class = Class.new do
           include Chef::Mixin::Securable
           include Chef::Mixin::ParamsValidate

data/spec/unit/mixin/shell_out_spec.rb

@@ -21,10 +21,9 @@
 #
 
 require "spec_helper"
-require "chef/mixin/path_sanity"
+require "chef/mixin/default_paths"
 
 describe Chef::Mixin::ShellOut do
-  include ChefUtils::DSL::PathSanity
   let(:shell_out_class) { Class.new { include Chef::Mixin::ShellOut } }
   subject(:shell_out_obj) { shell_out_class.new }
 
@@ -57,38 +56,38 @@ describe Chef::Mixin::ShellOut do
           describe "and environment is an option" do
             it "should not change environment language settings when they are set to nil" do
               options = { environment: { "LC_ALL" => nil, "LANGUAGE" => nil, "LANG" => nil, env_path => nil } }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, **options).and_return(retobj)
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, **options).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
             end
 
             it "should not change environment language settings when they are set to non-nil" do
               options = { environment: { "LC_ALL" => "en_US.UTF-8", "LANGUAGE" => "en_US.UTF-8", "LANG" => "en_US.UTF-8", env_path => "foo:bar:baz" } }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, **options).and_return(retobj)
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, **options).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
             end
 
             it "should set environment language settings to the configured internal locale when they are not present" do
               options = { environment: { "HOME" => "/Users/morty" } }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd,
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd,
                 environment: {
                   "HOME" => "/Users/morty",
                   "LC_ALL" => Chef::Config[:internal_locale],
                   "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path => sanitized_path,
+                  env_path => shell_out_obj.default_paths,
                 }).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
             end
 
             it "should not mutate the options hash when it adds language settings" do
               options = { environment: { "HOME" => "/Users/morty" } }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd,
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd,
                 environment: {
                   "HOME" => "/Users/morty",
                   "LC_ALL" => Chef::Config[:internal_locale],
                   "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path => sanitized_path,
+                  env_path => shell_out_obj.default_paths,
                 }).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
               expect(options[:environment].key?("LC_ALL")).to be false
@@ -98,38 +97,38 @@ describe Chef::Mixin::ShellOut do
           describe "and env is an option" do
             it "should not change env when langauge options are set to nil" do
               options = { env: { "LC_ALL" => nil, "LANG" => nil, "LANGUAGE" => nil, env_path => nil } }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, **options).and_return(retobj)
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, **options).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
             end
 
             it "should not change env when language options are set to non-nil" do
               options = { env: { "LC_ALL" => "de_DE.UTF-8", "LANG" => "de_DE.UTF-8", "LANGUAGE" => "de_DE.UTF-8", env_path => "foo:bar:baz" } }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, **options).and_return(retobj)
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, **options).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
             end
 
             it "should set environment language settings to the configured internal locale when they are not present" do
               options = { env: { "HOME" => "/Users/morty" } }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd,
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd,
                 env: {
                   "HOME" => "/Users/morty",
                   "LC_ALL" => Chef::Config[:internal_locale],
                   "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path => sanitized_path,
+                  env_path => shell_out_obj.default_paths,
                 }).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
             end
 
             it "should not mutate the options hash when it adds language settings" do
               options = { env: { "HOME" => "/Users/morty" } }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd,
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd,
                 env: {
                   "HOME" => "/Users/morty",
                   "LC_ALL" => Chef::Config[:internal_locale],
                   "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path => sanitized_path,
+                  env_path => shell_out_obj.default_paths,
                 }).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
               expect(options[:env].key?("LC_ALL")).to be false
@@ -139,13 +138,13 @@ describe Chef::Mixin::ShellOut do
           describe "and no env/environment option is present" do
             it "should set environment language settings to the configured internal locale" do
               options = { user: "morty" }
-              expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd,
+              expect(shell_out_obj).to receive(:__shell_out_command).with(cmd,
                 user: "morty",
                 environment: {
                   "LC_ALL" => Chef::Config[:internal_locale],
                   "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path => sanitized_path,
+                  env_path => shell_out_obj.default_paths,
                 }).and_return(retobj)
               shell_out_obj.send(method, cmd, **options)
             end
@@ -154,12 +153,12 @@ describe Chef::Mixin::ShellOut do
 
         describe "when the last argument is not a Hash" do
           it "should set environment language settings to the configured internal locale" do
-            expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd,
+            expect(shell_out_obj).to receive(:__shell_out_command).with(cmd,
               environment: {
                 "LC_ALL" => Chef::Config[:internal_locale],
                 "LANG" => Chef::Config[:internal_locale],
                 "LANGUAGE" => Chef::Config[:internal_locale],
-                env_path => sanitized_path,
+                env_path => shell_out_obj.default_paths,
               }).and_return(retobj)
             shell_out_obj.send(method, cmd)
           end
@@ -173,19 +172,19 @@ describe Chef::Mixin::ShellOut do
         describe "and environment is an option" do
           it "should not change environment['LC_ALL'] when set to nil" do
             options = { environment: { "LC_ALL" => nil } }
-            expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, **options, default_env: false)
           end
 
           it "should not change environment['LC_ALL'] when set to non-nil" do
             options = { environment: { "LC_ALL" => "en_US.UTF-8" } }
-            expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, **options, default_env: false)
           end
 
           it "should no longer set environment['LC_ALL'] to nil when 'LC_ALL' not present" do
             options = { environment: { "HOME" => "/Users/morty" } }
-            expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, **options, default_env: false)
           end
         end
@@ -193,19 +192,19 @@ describe Chef::Mixin::ShellOut do
         describe "and env is an option" do
           it "should not change env when set to nil" do
             options = { env: { "LC_ALL" => nil } }
-            expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, **options, default_env: false)
           end
 
           it "should not change env when set to non-nil" do
             options = { env: { "LC_ALL" => "en_US.UTF-8" } }
-            expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, **options, default_env: false)
           end
 
           it "should no longer set env['LC_ALL'] to nil when 'LC_ALL' not present" do
             options = { env: { "HOME" => "/Users/morty" } }
-            expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, **options, default_env: false)
           end
         end
@@ -213,7 +212,7 @@ describe Chef::Mixin::ShellOut do
         describe "and no env/environment option is present" do
           it "should no longer add environment option and set environment['LC_ALL'] to nil" do
             options = { user: "morty" }
-            expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            expect(shell_out_obj).to receive(:__shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, **options, default_env: false)
           end
         end
@@ -221,7 +220,7 @@ describe Chef::Mixin::ShellOut do
 
       describe "when the last argument is not a Hash" do
         it "should no longer add environment options and set environment['LC_ALL'] to nil" do
-          expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd).and_return(true)
+          expect(shell_out_obj).to receive(:__shell_out_command).with(cmd).and_return(true)
           shell_out_obj.shell_out(cmd, default_env: false)
         end
       end

data/spec/unit/mixin/subclass_directive_spec.rb

@@ -31,9 +31,9 @@ class ChildWithoutDirective < SubclassDirectiveParent
 end
 
 describe Chef::Mixin::Uris do
-  let (:child) { SubclassDirectiveChild.new }
+  let(:child) { SubclassDirectiveChild.new }
 
-  let (:other_child) { ChildWithoutDirective.new }
+  let(:other_child) { ChildWithoutDirective.new }
 
   it "the child instance has the directive set" do
     expect(child.behave_differently?).to be true

data/spec/unit/mixin/template_spec.rb

@@ -104,16 +104,16 @@ describe Chef::Mixin::Template, "render_template" do
     end
 
     it "should render local files" do
-      begin
-        tf = Tempfile.new("partial")
-        tf.write "test"
-        tf.rewind
-
-        output = @template_context.render_template_from_string("before {<%= render '#{tf.path}', :local => true %>} after")
-        expect(output).to eq("before {test} after")
-      ensure
-        tf.close
-      end
+
+      tf = Tempfile.new("partial")
+      tf.write "test"
+      tf.rewind
+
+      output = @template_context.render_template_from_string("before {<%= render '#{tf.path}', :local => true %>} after")
+      expect(output).to eq("before {test} after")
+    ensure
+      tf.close
+
     end
 
     it "should render partials from a different cookbook" do
@@ -124,16 +124,16 @@ describe Chef::Mixin::Template, "render_template" do
     end
 
     it "should render using the source argument if provided" do
-      begin
-        tf = Tempfile.new("partial")
-        tf.write "test"
-        tf.rewind
-
-        output = @template_context.render_template_from_string("before {<%= render 'something', :local => true, :source => '#{tf.path}' %>} after")
-        expect(output).to eq("before {test} after")
-      ensure
-        tf.close
-      end
+
+      tf = Tempfile.new("partial")
+      tf.write "test"
+      tf.rewind
+
+      output = @template_context.render_template_from_string("before {<%= render 'something', :local => true, :source => '#{tf.path}' %>} after")
+      expect(output).to eq("before {test} after")
+    ensure
+      tf.close
+
     end
 
     it "should pass the node to partials" do
@@ -195,11 +195,11 @@ describe Chef::Mixin::Template, "render_template" do
 
       describe "the raised TemplateError" do
         subject(:exception) do
-          begin
-            do_raise
-          rescue Chef::Mixin::Template::TemplateError => e
-            e
-          end
+
+          do_raise
+        rescue Chef::Mixin::Template::TemplateError => e
+          e
+
         end
 
         it "should contain template file and line numbers" do
@@ -274,11 +274,11 @@ describe Chef::Mixin::Template, "render_template" do
 
     describe "the raised TemplateError" do
       before :each do
-        begin
-          do_raise
-        rescue Chef::Mixin::Template::TemplateError => e
-          @exception = e
-        end
+
+        do_raise
+      rescue Chef::Mixin::Template::TemplateError => e
+        @exception = e
+
       end
 
       it "should have the original exception" do

data/spec/unit/mixin/unformatter_spec.rb

@@ -27,8 +27,8 @@ class Chef::UnformatterTest
 end
 
 describe Chef::Mixin::Unformatter do
-  let (:unformatter) { Chef::UnformatterTest.new }
-  let (:message) { "Test Message" }
+  let(:unformatter) { Chef::UnformatterTest.new }
+  let(:message) { "Test Message" }
 
   describe "#write" do
     context "with a timestamp" do

data/spec/unit/mixin/uris_spec.rb

@@ -24,7 +24,7 @@ class Chef::UrisTest
 end
 
 describe Chef::Mixin::Uris do
-  let (:uris) { Chef::UrisTest.new }
+  let(:uris) { Chef::UrisTest.new }
 
   describe "#uri_scheme?" do
     it "matches 'scheme://foo.com'" do

data/spec/unit/mixin/user_context_spec.rb

@@ -77,17 +77,9 @@ describe "a class that mixes in user_context" do
       end
 
       context "when the block raises an exception" do
-        class UserContextTestException < RuntimeError
-        end
-        let(:block_parameter) { Proc.new { raise UserContextTextException } }
-
-        it "raises the exception raised by the block" do
-          expect { instance_with_user_context.with_context("kamilah", nil, "chef4life", &block_parameter) }.not_to raise_error(UserContextTestException)
-        end
-
         it "closes the logon session so resources are not leaked" do
           expect(logon_session).to receive(:close)
-          expect { instance_with_user_context.with_context("kamilah", nil, "chef4life", &block_parameter) }.not_to raise_error(UserContextTestException)
+          expect { instance_with_user_context.with_context("kamilah", nil, "chef4life") { 1 / 0 } }.to raise_error(ZeroDivisionError)
         end
       end
     end

data/spec/unit/mixin/which.rb

@@ -93,7 +93,7 @@ describe Chef::Mixin::Which do
       end
 
       test_which("arrays with blocks", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ]) do |f|
-        raise "bad arg to block" unless f == "/dir2/foo1" || f == "/dir1/foo2"
+        raise "bad arg to block" unless ["/dir2/foo1", "/dir1/foo2"].include?(f)
 
         true
       end
@@ -159,4 +159,12 @@ describe Chef::Mixin::Which do
       end
     end
   end
+
+  describe "useful non-stubbed tests" do
+    it "works even when the PATH is nuked via adding default_paths", unix_only: true do
+      old_path = ENV["PATH"]
+      expect(test.which("ls")).to be_truthy
+      ENV["PATH"] = old_path
+    end
+  end
 end

data/spec/unit/mixin/windows_architecture_helper_spec.rb

@@ -50,10 +50,10 @@ describe Chef::Mixin::WindowsArchitectureHelper do
 
   it "raises an error if an invalid architecture is passed to assert_valid_windows_architecture!" do
     @invalid_architectures.each do |architecture|
-      begin
-        expect(assert_valid_windows_architecture!(architecture)).to raise_error Chef::Exceptions::Win32ArchitectureIncorrect
-      rescue Chef::Exceptions::Win32ArchitectureIncorrect
-      end
+
+      expect(assert_valid_windows_architecture!(architecture)).to raise_error Chef::Exceptions::Win32ArchitectureIncorrect
+    rescue Chef::Exceptions::Win32ArchitectureIncorrect
+
     end
   end
 

data/spec/unit/node/immutable_collections_spec.rb

@@ -73,7 +73,11 @@ shared_examples_for "Immutable#to_yaml" do
   end
 
   it "should create a YAML string with content" do
-    expect(copy).to eq(parsed_yaml)
+    # Roundtrip the test string through YAML to compensate for some changes in libyaml-0.2.5
+    # See: https://github.com/yaml/libyaml/pull/186
+    expected = YAML.dump(YAML.load(parsed_yaml))
+
+    expect(copy).to eq(expected)
   end
 end
 
@@ -126,7 +130,7 @@ describe Chef::Node::ImmutableMash do
   end
 
   %w{to_h to_hash dup}.each do |immutable_meth|
-    describe "#{immutable_meth}" do
+    describe immutable_meth do
       include_examples "ImmutableMash module", description
     end
   end
@@ -234,14 +238,14 @@ describe Chef::Node::ImmutableArray do
   end
 
   %w{to_a to_array dup}.each do |immutable_meth|
-    describe "#{immutable_meth}" do
+    describe immutable_meth do
       include_examples "ImmutableArray module", description
     end
   end
 
   describe "to_yaml" do
     let(:copy) { @immutable_nested_array.to_yaml }
-    let(:parsed_yaml) { "---\n- level1\n- - foo\n  - bar\n  - baz\n  - 1\n  - 2\n  - 3\n  - \n  - true\n  - false\n  - - el\n    - 0\n    - \n- m: m\n" }
+    let(:parsed_yaml) { "---\n- level1\n- - foo\n  - bar\n  - baz\n  - 1\n  - 2\n  - 3\n  -\n  - true\n  - false\n  - - el\n    - 0\n    -\n- m: m\n" }
 
     include_examples "Immutable#to_yaml"
   end