chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/mixin/shell_out_spec.rb

@@ -38,16 +38,16 @@ describe Chef::Mixin::ShellOut do
       let(:command_args) { [ cmd ] }
 
       it 'should not edit command args' do
-        should eql(command_args)
+        is_expected.to eql(command_args)
       end
     end
 
     context 'without deprecated options' do
       let(:options) { { :environment => environment } }
-      let(:environment) { { 'LC_ALL' => 'C' } }
+      let(:environment) { { 'LC_ALL' => 'C', 'LANG' => 'C', 'LANGUAGE' => 'C' } }
 
       it 'should not edit command args' do
-        should eql(command_args)
+        is_expected.to eql(command_args)
       end
     end
 
@@ -66,7 +66,7 @@ describe Chef::Mixin::ShellOut do
       let(:command_log_level) { :warn }
 
       it 'should convert :command_log_level to :log_level' do
-        should eql [ cmd, { :log_level => command_log_level } ]
+        is_expected.to eql [ cmd, { :log_level => command_log_level } ]
       end
 
       should_emit_deprecation_warning_about :command_log_level, :log_level
@@ -77,7 +77,7 @@ describe Chef::Mixin::ShellOut do
       let(:command_log_prepend) { 'PROVIDER:' }
 
       it 'should convert :command_log_prepend to :log_tag' do
-        should eql [ cmd, { :log_tag => command_log_prepend } ]
+        is_expected.to eql [ cmd, { :log_tag => command_log_prepend } ]
       end
 
       should_emit_deprecation_warning_about :command_log_prepend, :log_tag
@@ -88,7 +88,7 @@ describe Chef::Mixin::ShellOut do
       let(:command_log_level) { :warn }
 
       it "should convert 'command_log_level' to :log_level" do
-        should eql [ cmd, { :log_level => command_log_level } ]
+        is_expected.to eql [ cmd, { :log_level => command_log_level } ]
       end
 
       should_emit_deprecation_warning_about :command_log_level, :log_level
@@ -99,7 +99,7 @@ describe Chef::Mixin::ShellOut do
       let(:command_log_prepend) { 'PROVIDER:' }
 
       it "should convert 'command_log_prepend' to :log_tag" do
-        should eql [ cmd, { :log_tag => command_log_prepend } ]
+        is_expected.to eql [ cmd, { :log_tag => command_log_prepend } ]
       end
 
       should_emit_deprecation_warning_about :command_log_prepend, :log_tag
@@ -123,30 +123,40 @@ describe Chef::Mixin::ShellOut do
 
       describe "when the last argument is a Hash" 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 } }
+          it "should not change environment language settings when they are set to nil" do
+            options = { :environment => { 'LC_ALL' => nil, 'LANGUAGE' => nil, 'LANG' => nil } }
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, options)
           end
 
-          it "should not change environment['LC_ALL'] when set to non-nil" do
-            options = { :environment => { 'LC_ALL' => 'en_US.UTF-8' } }
+          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' } }
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, options)
           end
 
-          it "should set environment['LC_ALL'] to 'en_US.UTF-8' when 'LC_ALL' not present" do
+          it "should set environment language settings to the configured internal locale when they are not present" do
             options = { :environment => { 'HOME' => '/Users/morty' } }
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, {
-              :environment => { 'HOME' => '/Users/morty', 'LC_ALL' => Chef::Config[:internal_locale] },
+              :environment => {
+                'HOME'     => '/Users/morty',
+                'LC_ALL'   => Chef::Config[:internal_locale],
+                'LANG'     => Chef::Config[:internal_locale],
+                'LANGUAGE' => Chef::Config[:internal_locale],
+              },
             }).and_return(true)
             shell_out_obj.shell_out(cmd, options)
           end
 
-          it "should not mutate the options hash when it adds LC_ALL" do
+          it "should not mutate the options hash when it adds language settings" do
             options = { :environment => { 'HOME' => '/Users/morty' } }
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, {
-              :environment => { 'HOME' => '/Users/morty', 'LC_ALL' => Chef::Config[:internal_locale] },
+              :environment => {
+                'HOME'     => '/Users/morty',
+                'LC_ALL'   => Chef::Config[:internal_locale],
+                'LANG'     => Chef::Config[:internal_locale],
+                'LANGUAGE' => Chef::Config[:internal_locale],
+              },
             }).and_return(true)
             shell_out_obj.shell_out(cmd, options)
             expect(options[:environment].has_key?('LC_ALL')).to be false
@@ -154,30 +164,40 @@ describe Chef::Mixin::ShellOut do
         end
 
         describe "and env is an option" do
-          it "should not change env when set to nil" do
-            options = { :env => { 'LC_ALL' => nil } }
+          it "should not change env when langauge options are set to nil" do
+            options = { :env => { 'LC_ALL' => nil, 'LANG' => nil, 'LANGUAGE' => nil } }
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, options)
           end
 
-          it "should not change env when set to non-nil" do
-            options = { :env => { 'LC_ALL' => 'de_DE.UTF-8'}}
+          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' }}
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
             shell_out_obj.shell_out(cmd, options)
           end
 
-          it "should set env['LC_ALL'] to 'en_US.UTF-8' when 'LC_ALL' not present" do
+          it "should set environment language settings to the configured internal locale when they are not present" do
             options = { :env => { 'HOME' => '/Users/morty' } }
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, {
-              :env => { 'HOME' => '/Users/morty', 'LC_ALL' => Chef::Config[:internal_locale] },
+              :env => {
+                'HOME'     => '/Users/morty',
+                'LC_ALL'   => Chef::Config[:internal_locale],
+                'LANG'     => Chef::Config[:internal_locale],
+                'LANGUAGE' => Chef::Config[:internal_locale],
+              }
             }).and_return(true)
             shell_out_obj.shell_out(cmd, options)
           end
 
-          it "should not mutate the options hash when it adds LC_ALL" do
+          it "should not mutate the options hash when it adds language settings" do
             options = { :env => { 'HOME' => '/Users/morty' } }
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, {
-              :env => { 'HOME' => '/Users/morty', 'LC_ALL' => Chef::Config[:internal_locale] },
+              :env => {
+                'HOME'     => '/Users/morty',
+                'LC_ALL'   => Chef::Config[:internal_locale],
+                'LANG'     => Chef::Config[:internal_locale],
+                'LANGUAGE' => Chef::Config[:internal_locale],
+              }
             }).and_return(true)
             shell_out_obj.shell_out(cmd, options)
             expect(options[:env].has_key?('LC_ALL')).to be false
@@ -185,10 +205,15 @@ describe Chef::Mixin::ShellOut do
         end
 
         describe "and no env/environment option is present" do
-          it "should add environment option and set environment['LC_ALL'] to 'en_US.UTF_8'" do
+          it "should set environment language settings to the configured internal locale" do
             options = { :user => 'morty' }
             expect(shell_out_obj).to receive(:shell_out_command).with(cmd, {
-              :user => 'morty', :environment => { 'LC_ALL' => Chef::Config[:internal_locale] },
+              :user => 'morty',
+              :environment => {
+                'LC_ALL'   => Chef::Config[:internal_locale],
+                'LANG'     => Chef::Config[:internal_locale],
+                'LANGUAGE' => Chef::Config[:internal_locale],
+              },
             }).and_return(true)
             shell_out_obj.shell_out(cmd, options)
           end
@@ -196,9 +221,13 @@ describe Chef::Mixin::ShellOut do
       end
 
       describe "when the last argument is not a Hash" do
-        it "should add environment options and set environment['LC_ALL'] to 'en_US.UTF-8'" do
+        it "should set environment language settings to the configured internal locale" do
           expect(shell_out_obj).to receive(:shell_out_command).with(cmd, {
-            :environment => { 'LC_ALL' => Chef::Config[:internal_locale] },
+            :environment => {
+              'LC_ALL'   => Chef::Config[:internal_locale],
+              'LANG'     => Chef::Config[:internal_locale],
+              'LANGUAGE' => Chef::Config[:internal_locale],
+            },
           }).and_return(true)
           shell_out_obj.shell_out(cmd)
         end

data/spec/unit/mixin/template_spec.rb

@@ -30,7 +30,7 @@ describe Chef::Mixin::Template, "render_template" do
   it "should render the template evaluated in the given context" do
     @context[:foo] = "bar"
     output = @context.render_template_from_string("<%= @foo %>")
-    output.should == "bar"
+    expect(output).to eq("bar")
   end
 
   template_contents = [ "Fancy\r\nTemplate\r\n\r\n",
@@ -39,14 +39,14 @@ describe Chef::Mixin::Template, "render_template" do
 
   describe "when running on windows" do
     before do
-      Chef::Platform.stub(:windows?).and_return(true)
+      allow(Chef::Platform).to receive(:windows?).and_return(true)
     end
 
     it "should render the templates with windows line endings" do
       template_contents.each do |template_content|
         output = @context.render_template_from_string(template_content)
         output.each_line do |line|
-          line.should end_with("\r\n")
+          expect(line).to end_with("\r\n")
         end
       end
     end
@@ -54,14 +54,14 @@ describe Chef::Mixin::Template, "render_template" do
 
   describe "when running on unix" do
     before do
-      Chef::Platform.stub(:windows?).and_return(false)
+      allow(Chef::Platform).to receive(:windows?).and_return(false)
     end
 
     it "should render the templates with unix line endings" do
       template_contents.each do |template_content|
         output = @context.render_template_from_string(template_content)
         output.each_line do |line|
-          line.should end_with("\n")
+          expect(line).to end_with("\n")
         end
       end
     end
@@ -70,7 +70,7 @@ describe Chef::Mixin::Template, "render_template" do
   it "should provide a node method to access @node" do
     @context[:node] = "tehShizzle"
     output = @context.render_template_from_string("<%= @node %>")
-    output.should == "tehShizzle"
+    expect(output).to eq("tehShizzle")
   end
 
   describe "with a template resource" do
@@ -100,7 +100,7 @@ describe Chef::Mixin::Template, "render_template" do
 
     it "should provide a render method" do
       output = @template_context.render_template_from_string("before {<%= render('test.erb').strip -%>} after")
-      output.should == "before {We could be diving for pearls!} after"
+      expect(output).to eq("before {We could be diving for pearls!} after")
     end
 
     it "should render local files" do
@@ -110,7 +110,7 @@ describe Chef::Mixin::Template, "render_template" do
         tf.rewind
 
         output = @template_context.render_template_from_string("before {<%= render '#{tf.path}', :local => true %>} after")
-        output.should == "before {test} after"
+        expect(output).to eq("before {test} after")
       ensure
         tf.close
       end
@@ -120,7 +120,7 @@ describe Chef::Mixin::Template, "render_template" do
       @template_context[:template_finder] = Chef::Provider::TemplateFinder.new(@run_context, 'apache2', @node)
 
       output = @template_context.render_template_from_string("before {<%= render('test.erb', :cookbook => 'openldap').strip %>} after")
-      output.should == "before {We could be diving for pearls!} after"
+      expect(output).to eq("before {We could be diving for pearls!} after")
     end
 
     it "should render using the source argument if provided" do
@@ -130,7 +130,7 @@ describe Chef::Mixin::Template, "render_template" do
         tf.rewind
 
         output = @template_context.render_template_from_string("before {<%= render 'something', :local => true, :source => '#{tf.path}' %>} after")
-        output.should == "before {test} after"
+        expect(output).to eq("before {test} after")
       ensure
         tf.close
       end
@@ -140,7 +140,7 @@ describe Chef::Mixin::Template, "render_template" do
       @node.normal[:slappiness] = "happiness"
 
       output = @template_context.render_template_from_string("before {<%= render 'openldap_stuff.conf.erb' %>} after")
-      output.should == "before {slappiness is happiness} after"
+      expect(output).to eq("before {slappiness is happiness} after")
     end
 
     it "should pass the original variables to partials" do
@@ -152,29 +152,29 @@ describe Chef::Mixin::Template, "render_template" do
 
     it "should pass variables to partials" do
       output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {:secret => 'whatever' } %>} after")
-      output.should == "before {super secret is whatever} after"
+      expect(output).to eq("before {super secret is whatever} after")
     end
 
     it "should pass variables to partials even if they are named the same" do
       @template_context[:secret] = 'one'
 
       output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {:secret => 'two' } %>} after <%= @secret %>")
-      output.should == "before {super secret is two} after one"
+      expect(output).to eq("before {super secret is two} after one")
     end
 
     it "should pass nil for missing variables in partials" do
       output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb', :variables => {} %>} after")
-      output.should == "before {super secret is } after"
+      expect(output).to eq("before {super secret is } after")
 
       output = @template_context.render_template_from_string("before {<%= render 'openldap_variable_stuff.conf.erb' %>} after")
-    output.should == "before {super secret is } after"
+    expect(output).to eq("before {super secret is } after")
     end
 
     it "should render nested partials" do
       path = File.expand_path(File.join(CHEF_SPEC_DATA, "partial_one.erb"))
 
       output = @template_context.render_template_from_string("before {<%= render('#{path}', :local => true).strip %>} after")
-      output.should == "before {partial one We could be diving for pearls! calling home} after"
+      expect(output).to eq("before {partial one We could be diving for pearls! calling home} after")
     end
 
     describe "when customizing the template context" do
@@ -187,7 +187,7 @@ describe Chef::Mixin::Template, "render_template" do
         end
         @template_context._extend_modules([mod])
         output = @template_context.render_template_from_string("<%=hello%>")
-        output.should == "ohai"
+        expect(output).to eq("ohai")
       end
 
       it "emits a warning when overriding 'core' methods" do
@@ -202,7 +202,7 @@ describe Chef::Mixin::Template, "render_template" do
           end
         end
         ['node', 'render', 'render_template', 'render_template_from_string'].each do |method_name|
-          Chef::Log.should_receive(:warn).with(/^Core template method `#{method_name}' overridden by extension module/)
+          expect(Chef::Log).to receive(:warn).with(/^Core template method `#{method_name}' overridden by extension module/)
         end
         @template_context._extend_modules([mod])
       end
@@ -216,11 +216,11 @@ describe Chef::Mixin::Template, "render_template" do
     end
 
     it "should catch and re-raise the exception as a TemplateError" do
-      lambda { do_raise }.should raise_error(Chef::Mixin::Template::TemplateError)
+      expect { do_raise }.to raise_error(Chef::Mixin::Template::TemplateError)
     end
 
     it "should raise an error if an attempt is made to access node but it is nil" do
-      lambda {@context.render_template_from_string("<%= node %>") {|r| r}}.should raise_error(Chef::Mixin::Template::TemplateError)
+      expect {@context.render_template_from_string("<%= node %>") {|r| r}}.to raise_error(Chef::Mixin::Template::TemplateError)
     end
 
     describe "the raised TemplateError" do
@@ -233,35 +233,35 @@ describe Chef::Mixin::Template, "render_template" do
       end
 
       it "should have the original exception" do
-        @exception.original_exception.should be
-        @exception.original_exception.message.should =~ /undefined local variable or method `this_is_not_defined'/
+        expect(@exception.original_exception).to be
+        expect(@exception.original_exception.message).to match(/undefined local variable or method `this_is_not_defined'/)
       end
 
       it "should determine the line number of the exception" do
-        @exception.line_number.should == 4
+        expect(@exception.line_number).to eq(4)
       end
 
       it "should provide a source listing of the template around the exception" do
-        @exception.source_listing.should == "  2: bar\n  3: baz\n  4: <%= this_is_not_defined %>\n  5: quin\n  6: qunx"
+        expect(@exception.source_listing).to eq("  2: bar\n  3: baz\n  4: <%= this_is_not_defined %>\n  5: quin\n  6: qunx")
       end
 
       it "should provide the evaluation context of the template" do
-        @exception.context.should == @context
+        expect(@exception.context).to eq(@context)
       end
 
       it "should defer the message to the original exception" do
-        @exception.message.should =~ /undefined local variable or method `this_is_not_defined'/
+        expect(@exception.message).to match(/undefined local variable or method `this_is_not_defined'/)
       end
 
       it "should provide a nice source location" do
-        @exception.source_location.should == "on line #4"
+        expect(@exception.source_location).to eq("on line #4")
       end
 
       it "should create a pretty output for the terminal" do
-        @exception.to_s.should =~ /Chef::Mixin::Template::TemplateError/
-        @exception.to_s.should =~ /undefined local variable or method `this_is_not_defined'/
-        @exception.to_s.should include("  2: bar\n  3: baz\n  4: <%= this_is_not_defined %>\n  5: quin\n  6: qunx")
-        @exception.to_s.should include(@exception.original_exception.backtrace.first)
+        expect(@exception.to_s).to match(/Chef::Mixin::Template::TemplateError/)
+        expect(@exception.to_s).to match(/undefined local variable or method `this_is_not_defined'/)
+        expect(@exception.to_s).to include("  2: bar\n  3: baz\n  4: <%= this_is_not_defined %>\n  5: quin\n  6: qunx")
+        expect(@exception.to_s).to include(@exception.original_exception.backtrace.first)
       end
     end
   end

data/spec/unit/mixin/windows_architecture_helper_spec.rb

@@ -35,13 +35,13 @@ describe Chef::Mixin::WindowsArchitectureHelper do
 
   it "returns true when valid architectures are passed to valid_windows_architecture?" do
     @valid_architectures.each do | architecture |
-      valid_windows_architecture?(architecture).should == true
+      expect(valid_windows_architecture?(architecture)).to eq(true)
     end
   end
 
   it "returns false when invalid architectures are passed to valid_windows_architecture?" do
     @invalid_architectures.each do | architecture |
-      valid_windows_architecture?(architecture).should == false
+      expect(valid_windows_architecture?(architecture)).to eq(false)
     end
   end
 
@@ -54,7 +54,7 @@ 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
-        assert_valid_windows_architecture!(architecture).should raise_error Chef::Exceptions::Win32ArchitectureIncorrect
+        expect(assert_valid_windows_architecture!(architecture)).to raise_error Chef::Exceptions::Win32ArchitectureIncorrect
       rescue Chef::Exceptions::Win32ArchitectureIncorrect
       end
     end
@@ -75,8 +75,8 @@ describe Chef::Mixin::WindowsArchitectureHelper do
       new_node.default["kernel"][:machine] = node_architecture.to_s
 
       @valid_architectures.each do | supported_architecture |
-        node_supports_windows_architecture?(new_node, supported_architecture).should == true if only_valid_combinations && (supported_architecture != :x86_64 && node_architecture != :i386 )
-        node_supports_windows_architecture?(new_node, supported_architecture).should == false if ! only_valid_combinations && (supported_architecture == :x86_64 && node_architecture == :i386 )
+        expect(node_supports_windows_architecture?(new_node, supported_architecture)).to eq(true) if only_valid_combinations && (supported_architecture != :x86_64 && node_architecture != :i386 )
+        expect(node_supports_windows_architecture?(new_node, supported_architecture)).to eq(false) if ! only_valid_combinations && (supported_architecture == :x86_64 && node_architecture == :i386 )
       end
     end
   end

data/spec/unit/mixin/xml_escape_spec.rb

@@ -28,27 +28,27 @@ describe Chef::Mixin::XMLEscape do
   end
 
   it "escapes ampersands to '&'" do
-    @escaper.xml_escape("&").should == "&"
+    expect(@escaper.xml_escape("&")).to eq("&")
   end
 
   it "escapes angle brackets to < or >" do
-    @escaper.xml_escape("<").should == "&lt;"
-    @escaper.xml_escape(">").should == "&gt;"
+    expect(@escaper.xml_escape("<")).to eq("&lt;")
+    expect(@escaper.xml_escape(">")).to eq("&gt;")
   end
 
   it "does not modify ASCII strings" do
-    @escaper.xml_escape('foobarbaz!@#$%^*()').should == 'foobarbaz!@#$%^*()'
+    expect(@escaper.xml_escape('foobarbaz!@#$%^*()')).to eq('foobarbaz!@#$%^*()')
   end
 
   it "converts invalid bytes to asterisks" do
-    @escaper.xml_escape("\x00").should == "*"
+    expect(@escaper.xml_escape("\x00")).to eq("*")
   end
 
   it "converts UTF-8 correctly" do
-    @escaper.xml_escape("\xC2\xA9").should == '&#169;'
+    expect(@escaper.xml_escape("\xC2\xA9")).to eq('&#169;')
   end
 
   it "converts win 1252 characters correctly" do
-    @escaper.xml_escape("\x80").should == '&#8364;'
+    expect(@escaper.xml_escape("\x80")).to eq('&#8364;')
   end
 end