chef 16.2.73-universal-mingw32 → 16.4.41-universal-mingw32

data/spec/unit/mixin/{path_sanity_spec.rb → default_paths_spec.rb}

@@ -18,19 +18,19 @@
 
 require "spec_helper"
 
-class PathSanityTestHarness
-  include Chef::Mixin::PathSanity
+class DefaultPathsTestHarness
+  include Chef::Mixin::DefaultPaths
 end
 
-describe Chef::Mixin::PathSanity do
+describe Chef::Mixin::DefaultPaths do
 
   before do
-    @sanity = PathSanityTestHarness.new
+    @default_paths = DefaultPathsTestHarness.new
   end
 
-  describe "when enforcing path sanity" do
+  describe "when enforcing default paths" do
     before do
-      Chef::Config[:enforce_path_sanity] = true
+      Chef::Config[:enforce_default_paths] = true
       @ruby_bindir = "/some/ruby/bin"
       @gem_bindir = "/some/gem/bin"
       allow(Gem).to receive(:bindir).and_return(@gem_bindir)
@@ -40,41 +40,41 @@ describe Chef::Mixin::PathSanity do
 
     it "adds all useful PATHs even if environment is an empty hash" do
       env = {}
-      @sanity.enforce_path_sanity(env)
+      @default_paths.enforce_default_paths(env)
       expect(env["PATH"]).to eq("#{@gem_bindir}:#{@ruby_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
     end
 
     it "adds all useful PATHs that are not yet in PATH to PATH" do
       env = { "PATH" => "" }
-      @sanity.enforce_path_sanity(env)
+      @default_paths.enforce_default_paths(env)
       expect(env["PATH"]).to eq("#{@gem_bindir}:#{@ruby_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
     end
 
     it "does not re-add paths that already exist in PATH" do
       env = { "PATH" => "/usr/bin:/sbin:/bin" }
-      @sanity.enforce_path_sanity(env)
+      @default_paths.enforce_default_paths(env)
       expect(env["PATH"]).to eq("#{@gem_bindir}:#{@ruby_bindir}:/usr/bin:/sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin")
     end
 
     it "creates path with utf-8 encoding" do
       env = { "PATH" => "/usr/bin:/sbin:/bin:/b#{0x81.chr}t".force_encoding("ISO-8859-1") }
-      @sanity.enforce_path_sanity(env)
+      @default_paths.enforce_default_paths(env)
       expect(env["PATH"].encoding.to_s).to eq("UTF-8")
     end
 
     it "adds the current executing Ruby's bindir and Gem bindir to the PATH" do
       env = { "PATH" => "" }
-      @sanity.enforce_path_sanity(env)
+      @default_paths.enforce_default_paths(env)
       expect(env["PATH"]).to eq("#{@gem_bindir}:#{@ruby_bindir}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
     end
 
-    it "does not create entries for Ruby/Gem bindirs if they exist in SANE_PATH or PATH" do
+    it "does not create entries for Ruby/Gem bindirs if they exist in PATH" do
       ruby_bindir = "/usr/bin"
       gem_bindir = "/yo/gabba/gabba"
       allow(Gem).to receive(:bindir).and_return(gem_bindir)
       allow(RbConfig::CONFIG).to receive(:[]).with("bindir").and_return(ruby_bindir)
       env = { "PATH" => gem_bindir }
-      @sanity.enforce_path_sanity(env)
+      @default_paths.enforce_default_paths(env)
       expect(env["PATH"]).to eq("/usr/bin:/yo/gabba/gabba:/usr/local/sbin:/usr/local/bin:/usr/sbin:/sbin:/bin")
     end
 
@@ -85,7 +85,7 @@ describe Chef::Mixin::PathSanity do
       allow(RbConfig::CONFIG).to receive(:[]).with("bindir").and_return(ruby_bindir)
       allow(ChefUtils).to receive(:windows?).and_return(true)
       env = { "PATH" => 'C:\Windows\system32;C:\mr\softie' }
-      @sanity.enforce_path_sanity(env)
+      @default_paths.enforce_default_paths(env)
       expect(env["PATH"]).to eq("#{gem_bindir};#{ruby_bindir};C:\\Windows\\system32;C:\\mr\\softie")
     end
   end

data/spec/unit/mixin/powershell_exec_spec.rb

@@ -47,7 +47,7 @@ describe Chef::Mixin::PowershellExec, :windows_only do
     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(Chef::PowerShell::CommandFailed)
     end
   end
 end

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.

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/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/which.rb

@@ -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
 
@@ -241,7 +245,7 @@ describe Chef::Node::ImmutableArray do
 
   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

data/spec/unit/node_spec.rb

@@ -1483,9 +1483,9 @@ describe Chef::Node do
         end
       end
 
-      context "with whitelisted attributes configured" do
-        it "should only save whitelisted attributes (and subattributes)" do
-          Chef::Config[:default_attribute_whitelist] = [
+      context "with allowed attributes configured" do
+        it "should only save allowed attributes (and subattributes)" do
+          Chef::Config[:allowed_default_attributes] = [
             ["filesystem", "/dev/disk0s2"],
             "network/interfaces/eth0",
           ]
@@ -1525,8 +1525,8 @@ describe Chef::Node do
           node.save
         end
 
-        it "should save false-y whitelisted attributes" do
-          Chef::Config[:default_attribute_whitelist] = [
+        it "should save false-y allowed attributes" do
+          Chef::Config[:allowed_default_attributes] = [
             "foo/bar/baz",
           ]
 
@@ -1560,8 +1560,8 @@ describe Chef::Node do
           node.save
         end
 
-        it "should not save any attributes if the whitelist is empty" do
-          Chef::Config[:default_attribute_whitelist] = []
+        it "should not save any attributes if the allowed is empty" do
+          Chef::Config[:allowed_default_attributes] = []
 
           node.default = {
               "filesystem" => {
@@ -1583,8 +1583,52 @@ describe Chef::Node do
         end
       end
 
-      context "with blacklisted attributes configured" do
-        it "should only save non-blacklisted attributes (and subattributes)" do
+      context "with deprecated whitelist attributes configured" do
+        it "should only save allowed attributes (and subattributes)" do
+          Chef::Config[:default_attribute_whitelist] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0",
+          ]
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {},
+                },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+
+          node.name("picky-monkey")
+          Chef::Config[:treat_deprecation_warnings_as_errors] = false
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+      end
+
+      context "with deprecated blacklist attributes configured" do
+        it "should only save non-blocklisted attributes (and subattributes)" do
           Chef::Config[:default_attribute_blacklist] = [
             ["filesystem", "/dev/disk0s2"],
             "network/interfaces/eth0",
@@ -1620,12 +1664,55 @@ describe Chef::Node do
             "automatic" => {}, "normal" => {}, "override" => {}
           }
           node.name("picky-monkey")
+          Chef::Config[:treat_deprecation_warnings_as_errors] = false
           expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
           node.save
         end
+      end
+
+      context "with blocklisted attributes configured" do
+        it "should only save non-blocklisted attributes (and subattributes)" do
+          Chef::Config[:blocked_default_attributes] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0",
+          ]
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {},
+                },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
 
-        it "should save all attributes if the blacklist is empty" do
-          Chef::Config[:default_attribute_blacklist] = []
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth1" => {},
+                },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+          node.name("picky-monkey")
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+
+        it "should save all attributes if the blocklist is empty" do
+          Chef::Config[:blocked_default_attributes] = []
 
           node.default = {
               "filesystem" => {
@@ -1686,11 +1773,11 @@ describe Chef::Node do
           end
 
           let(:http_exception) do
-            begin
-              response.error!
-            rescue => e
-              e
-            end
+
+            response.error!
+          rescue => e
+            e
+
           end
 
           let(:trimmed_node) do