chef 16.2.73-universal-mingw32 → 16.3.38-universal-mingw32

data/spec/unit/log/winevt_spec.rb

@@ -19,32 +19,40 @@
 
 require "spec_helper"
 
-describe Chef::Log::WinEvt do
+describe Chef::Log::WinEvt, :windows_only do
   let(:evtlog) { instance_double("Win32::EventLog") }
   let(:winevt) { Chef::Log::WinEvt.new(evtlog) }
   let(:app) { Chef::Application.new }
 
   before do
     Chef::Log.init(MonoLogger.new(winevt))
-    @old_log_level = Chef::Log.level
     Chef::Log.level = :info
-    @old_loggers = Chef::Log.loggers
-    Chef::Log.use_log_devices([winevt])
-  end
-
-  after do
-    Chef::Log.level = @old_log_level
-    Chef::Log.use_log_devices(@old_loggers)
   end
 
   it "should send message with severity info to Windows Event Log." do
-    expect(winevt).to receive(:add).with(1, "*** Chef 12.4.0.dev.0 ***", nil)
-    Chef::Log.info("*** Chef 12.4.0.dev.0 ***")
+    expect(evtlog).to receive(:report_event).with(
+      event_type: ::Win32::EventLog::INFO_TYPE,
+      source: Chef::Log::WinEvt::SOURCE,
+      event_id: Chef::Log::WinEvt::INFO_EVENT_ID,
+      data: ["*** Chef 12.4.0.dev.0 ***"]
+    )
+
+    expect {
+      Chef::Log.info("*** Chef 12.4.0.dev.0 ***")
+    }.not_to output.to_stderr
   end
 
   it "should send message with severity warning to Windows Event Log." do
-    expect(winevt).to receive(:add).with(2, "No config file found or specified on command line. Using command line options instead.", nil)
-    Chef::Log.warn("No config file found or specified on command line. Using command line options instead.")
+    expect(evtlog).to receive(:report_event).with(
+      event_type: ::Win32::EventLog::WARN_TYPE,
+      source: Chef::Log::WinEvt::SOURCE,
+      event_id: Chef::Log::WinEvt::WARN_EVENT_ID,
+      data: ["No config file found or specified on command line. Using command line options instead."]
+    )
+
+    expect {
+      Chef::Log.warn("No config file found or specified on command line. Using command line options instead.")
+    }.not_to output.to_stderr
   end
 
   it "should fallback into send message with severity info to Windows Event Log when wrong format." do

data/spec/unit/lwrp_spec.rb

@@ -140,7 +140,7 @@ describe "LWRP" do
     before do
       @tmpdir = Dir.mktmpdir("lwrp_test")
       @lwrp_path = File.join(@tmpdir, "foo.rb")
-      content = IO.read(File.expand_path("../../data/lwrp/resources/foo.rb", __FILE__))
+      content = IO.read(File.expand_path("../data/lwrp/resources/foo.rb", __dir__))
       IO.write(@lwrp_path, content)
       Chef::Resource::LWRPBase.build_from_file("lwrp", @lwrp_path, nil)
       @original_resource = Chef::ResourceResolver.resolve(:lwrp_foo)
@@ -152,7 +152,7 @@ describe "LWRP" do
 
     context "And the LWRP is asked to load again, this time with different code" do
       before do
-        content = IO.read(File.expand_path("../../data/lwrp_override/resources/foo.rb", __FILE__))
+        content = IO.read(File.expand_path("../data/lwrp_override/resources/foo.rb", __dir__))
         IO.write(@lwrp_path, content)
         Chef::Resource::LWRPBase.build_from_file("lwrp", @lwrp_path, nil)
       end
@@ -390,11 +390,11 @@ describe "LWRP" do
     end
 
     before(:each) do
-      Dir[File.expand_path(File.expand_path("../../data/lwrp/resources/*", __FILE__))].each do |file|
+      Dir[File.expand_path(File.expand_path("../data/lwrp/resources/*", __dir__))].each do |file|
         Chef::Resource::LWRPBase.build_from_file(lwrp_cookbook_name, file, run_context)
       end
 
-      Dir[File.expand_path(File.expand_path("../../data/lwrp/providers/*", __FILE__))].each do |file|
+      Dir[File.expand_path(File.expand_path("../data/lwrp/providers/*", __dir__))].each do |file|
         Chef::Provider::LWRPBase.build_from_file(lwrp_cookbook_name, file, run_context)
       end
     end

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/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/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",
@@ -1606,6 +1650,49 @@ describe Chef::Node do
           node.normal = {}
           node.override = {}
 
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth1" => {},
+                },
+              },
+            },
+            "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 = {}
+
           selected_data = {
             "default" => {
               "filesystem" => {
@@ -1624,8 +1711,8 @@ describe Chef::Node do
           node.save
         end
 
-        it "should save all attributes if the blacklist is empty" do
-          Chef::Config[:default_attribute_blacklist] = []
+        it "should save all attributes if the blocklist is empty" do
+          Chef::Config[:blocked_default_attributes] = []
 
           node.default = {
               "filesystem" => {