chef 12.5.0.alpha.1 → 12.5.1

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

@@ -0,0 +1,93 @@
+#
+# Copyright:: Copyright (c) 2015 Chef Software, Inc
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Knife::SubcommandLoader::HashedCommandLoader do
+  before do
+    allow(ChefConfig).to receive(:windows?) { false }
+  end
+
+  let(:plugin_manifest) {
+    {
+      "_autogenerated_command_paths" => {
+        "plugins_paths" => {
+          "cool_a" => ["/file/for/plugin/a"],
+          "cooler_b" => ["/file/for/plugin/b"]
+        },
+        "plugins_by_category" => {
+          "cool" => [
+            "cool_a"
+          ],
+          "cooler" => [
+            "cooler_b"
+          ]
+        }
+      }
+    }
+  }
+
+  let(:loader) { Chef::Knife::SubcommandLoader::HashedCommandLoader.new(
+    File.join(CHEF_SPEC_DATA, 'knife-site-subcommands'),
+    plugin_manifest)}
+
+  describe "#list_commands" do
+    it "lists all commands by category when no argument is given" do
+      expect(loader.list_commands).to eq({"cool" => ["cool_a"], "cooler" => ["cooler_b"]})
+    end
+
+    it "lists only commands in the given category when a category is given" do
+      expect(loader.list_commands("cool")).to eq({"cool" => ["cool_a"]})
+    end
+  end
+
+  describe "#subcommand_files" do
+    it "lists all the files" do
+      expect(loader.subcommand_files).to eq(["/file/for/plugin/a", "/file/for/plugin/b"])
+    end
+  end
+
+  describe "#load_commands" do
+    before do
+      allow(Kernel).to receive(:load).and_return(true)
+    end
+
+    it "returns false for non-existant commands" do
+      expect(loader.load_command(["nothere"])).to eq(false)
+    end
+
+    it "loads the correct file and returns true if the command exists" do
+      allow(File).to receive(:exists?).and_return(true)
+      expect(Kernel).to receive(:load).with("/file/for/plugin/a").and_return(true)
+      expect(loader.load_command(["cool_a"])).to eq(true)
+    end
+  end
+
+  describe "#subcommand_for_args" do
+    it "returns the subcommands for an exact match" do
+      expect(loader.subcommand_for_args(["cooler_b"])).to eq("cooler_b")
+    end
+
+    it "finds the right subcommand even when _'s are elided" do
+      expect(loader.subcommand_for_args(["cooler", "b"])).to eq("cooler_b")
+    end
+
+    it "returns nil if the the subcommand isn't in our manifest" do
+      expect(loader.subcommand_for_args(["cooler c"])).to eq(nil)
+    end
+  end
+end

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

@@ -1,6 +1,5 @@
 #
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# Copyright:: Copyright (c) 2015 Chef Software, Inc
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -32,209 +31,34 @@ describe Chef::Knife::SubcommandLoader do
     Chef::Util::PathHelper.class_variable_set(:@@home_dir, nil)
   end
 
-  it "builds a list of the core subcommand file require paths" do
-    expect(loader.subcommand_files).not_to be_empty
-    loader.subcommand_files.each do |require_path|
-      expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
-    end
-  end
-
-  it "finds files installed via rubygems" do
-    expect(loader.find_subcommands_via_rubygems).to include('chef/knife/node_create')
-    loader.find_subcommands_via_rubygems.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])}
-  end
-
-  it "finds files from latest version of installed gems" do
-    gems = [ double('knife-ec2-0.5.12') ]
-    gem_files = [
-      '/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_base.rb',
-      '/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_otherstuff.rb'
-    ]
-    expect($LOAD_PATH).to receive(:map).and_return([])
-    if Gem::Specification.respond_to? :latest_specs
-      expect(Gem::Specification).to receive(:latest_specs).with(true).and_return(gems)
-      expect(gems[0]).to receive(:matches_for_glob).with(/chef\/knife\/\*\.rb\{(.*),\.rb,(.*)\}/).and_return(gem_files)
-    else
-      expect(Gem.source_index).to receive(:latest_specs).with(true).and_return(gems)
-      expect(gems[0]).to receive(:require_paths).twice.and_return(['lib'])
-      expect(gems[0]).to receive(:full_gem_path).and_return('/usr/lib/ruby/gems/knife-ec2-0.5.12')
-      expect(Dir).to receive(:[]).with('/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb').and_return(gem_files)
-    end
-    expect(loader).to receive(:find_subcommands_via_dirglob).and_return({})
-    expect(loader.find_subcommands_via_rubygems.values.select { |file| file =~ /knife-ec2/ }.sort).to eq(gem_files)
-  end
-
-  it "finds files using a dirglob when rubygems is not available" do
-    expect(loader.find_subcommands_via_dirglob).to include('chef/knife/node_create')
-    loader.find_subcommands_via_dirglob.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])}
-  end
-
-  it "finds user-specific subcommands in the user's ~/.chef directory" do
-    expected_command = File.join(home, '.chef', 'plugins', 'knife', 'example_home_subcommand.rb')
-    expect(loader.site_subcommands).to include(expected_command)
-  end
-
-  it "finds repo specific subcommands by searching for a .chef directory" do
-    expected_command = File.join(CHEF_SPEC_DATA, 'knife-site-subcommands', 'plugins', 'knife', 'example_subcommand.rb')
-    expect(loader.site_subcommands).to include(expected_command)
-  end
-
-  # https://github.com/opscode/chef-dk/issues/227
-  #
-  # `knife` in ChefDK isn't from a gem install, it's directly run from a clone
-  # of the source, but there can be one or more versions of chef also installed
-  # as a gem. If the gem install contains a command that doesn't exist in the
-  # source tree of the "primary" chef install, it can be loaded and cause an
-  # error. We also want to ensure that we only load builtin commands from the
-  # "primary" chef install.
-  context "when a different version of chef is also installed as a gem" do
-
-    let(:all_found_commands) do
-      [
-        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/bootstrap.rb",
-        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_bulk_delete.rb",
-        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_create.rb",
-
-        # We use the fake version 1.0.0 because that version doesn't exist,
-        # which ensures it won't ever equal "chef-#{Chef::VERSION}"
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/bootstrap.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/client_bulk_delete.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/client_create.rb",
-
-        # Test that we don't accept a version number that is different only in
-        # trailing characters, e.g. we are running Chef 12.0.0 but there is a
-        # Chef 12.0.0.rc.0 gem also:
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}.rc.0/lib/chef/knife/thing.rb",
-
-        # Test that we ignore the platform suffix when checking for different
-        # gem versions.
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-x86-mingw32/lib/chef/knife/valid.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-i386-mingw64/lib/chef/knife/valid-too.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-mswin32/lib/chef/knife/also-valid.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-universal-mingw32/lib/chef/knife/universal-is-valid.rb",
-        # ...but don't ignore the .rc / .dev parts in the case when we have
-        # platform suffixes
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}.rc.0-x86-mingw32/lib/chef/knife/invalid.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}.dev-mswin32/lib/chef/knife/invalid-too.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}.dev.0-x86-mingw64/lib/chef/knife/still-invalid.rb",
-
-        # This command is "extra" compared to what's in the embedded/apps/chef install:
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/data_bag_secret_options.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-vault-2.2.4/lib/chef/knife/decrypt.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/knife-spork-1.4.1/lib/chef/knife/spork-bump.rb",
-
-        # These are fake commands that have names designed to test that the
-        # regex is strict enough
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-foo-#{Chef::VERSION}/lib/chef/knife/chef-foo.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/foo-chef-#{Chef::VERSION}/lib/chef/knife/foo-chef.rb",
+  let(:config_dir) { File.join(CHEF_SPEC_DATA, 'knife-site-subcommands') }
 
-        # In a real scenario, we'd use rubygems APIs to only select the most
-        # recent gem, but for this test we want to check that we're doing the
-        # right thing both when the plugin version matches and does not match
-        # the current chef version. Looking at
-        # `SubcommandLoader::MATCHES_THIS_CHEF_GEM` and
-        # `SubcommandLoader::MATCHES_CHEF_GEM` should make it clear why we want
-        # to test these two cases.
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-bar-1.0.0/lib/chef/knife/chef-bar.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/bar-chef-1.0.0/lib/chef/knife/bar-chef.rb"
-      ]
-    end
-
-    let(:expected_valid_commands) do
-      [
-        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/bootstrap.rb",
-        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_bulk_delete.rb",
-        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_create.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-x86-mingw32/lib/chef/knife/valid.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-i386-mingw64/lib/chef/knife/valid-too.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-mswin32/lib/chef/knife/also-valid.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-universal-mingw32/lib/chef/knife/universal-is-valid.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-vault-2.2.4/lib/chef/knife/decrypt.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/knife-spork-1.4.1/lib/chef/knife/spork-bump.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-foo-#{Chef::VERSION}/lib/chef/knife/chef-foo.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/foo-chef-#{Chef::VERSION}/lib/chef/knife/foo-chef.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-bar-1.0.0/lib/chef/knife/chef-bar.rb",
-        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/bar-chef-1.0.0/lib/chef/knife/bar-chef.rb"
-      ]
-    end
-
-    before do
-      expect(loader).to receive(:find_files_latest_gems).with("chef/knife/*.rb").and_return(all_found_commands)
-      expect(loader).to receive(:find_subcommands_via_dirglob).and_return({})
-    end
-
-    it "ignores commands from the non-matching gem install" do
-      expect(loader.find_subcommands_via_rubygems.values).to eq(expected_valid_commands)
-    end
-
-  end
-
-  describe "finding 3rd party plugins" do
-    let(:home) { "/home/alice" }
-    let(:manifest_path) { home + "/.chef/plugin_manifest.json" }
-
-    context "when there is not a ~/.chef/plugin_manifest.json file" do
+  describe "#for_config" do
+    context "when ~/.chef/plugin_manifest.json exists" do
       before do
-        allow(File).to receive(:exist?).with(manifest_path).and_return(false)
+        allow(File).to receive(:exist?).with(File.join(home, '.chef', 'plugin_manifest.json')).and_return(true)
       end
 
-      it "searches rubygems for plugins" do
-        if Gem::Specification.respond_to?(:latest_specs)
-          expect(Gem::Specification).to receive(:latest_specs).and_call_original
-        else
-          expect(Gem.source_index).to receive(:latest_specs).and_call_original
-        end
-        loader.subcommand_files.each do |require_path|
-          expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
-        end
+      it "creates a HashedCommandLoader with the manifest has _autogenerated_command_paths" do
+        allow(File).to receive(:read).with(File.join(home, '.chef', 'plugin_manifest.json')).and_return("{ \"_autogenerated_command_paths\": {}}")
+        expect(Chef::Knife::SubcommandLoader.for_config(config_dir)).to be_a Chef::Knife::SubcommandLoader::HashedCommandLoader
       end
 
-      context "and HOME environment variable is not set" do
-        before do
-          allow(Chef::Util::PathHelper).to receive(:home).and_return(nil)
-        end
-
-        it "searches rubygems for plugins" do
-          if Gem::Specification.respond_to?(:latest_specs)
-            expect(Gem::Specification).to receive(:latest_specs).and_call_original
-          else
-            expect(Gem.source_index).to receive(:latest_specs).and_call_original
-          end
-          loader.subcommand_files.each do |require_path|
-            expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
-          end
-        end
+      it "creates a CustomManifestLoader with then manifest has a key other than _autogenerated_command_paths" do
+        Chef::Config[:treat_deprecation_warnings_as_errors] = false
+        allow(File).to receive(:read).with(File.join(home, '.chef', 'plugin_manifest.json')).and_return("{ \"plugins\": {}}")
+        expect(Chef::Knife::SubcommandLoader.for_config(config_dir)).to be_a Chef::Knife::SubcommandLoader::CustomManifestLoader
       end
-
     end
 
-    context "when there is a ~/.chef/plugin_manifest.json file" do
-      let(:ec2_server_create_plugin) { "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_server_create.rb" }
-
-      let(:manifest_content) do
-        { "plugins" => {
-            "knife-ec2" => {
-              "paths" => [
-                ec2_server_create_plugin
-              ]
-            }
-          }
-        }
-      end
-
-      let(:manifest_json) { Chef::JSONCompat.to_json(manifest_content) }
-
+    context "when ~/.chef/plugin_manifest.json does not exist" do
       before do
-        allow(File).to receive(:exist?).with(manifest_path).and_return(true)
-        allow(File).to receive(:read).with(manifest_path).and_return(manifest_json)
+        allow(File).to receive(:exist?).with(File.join(home, '.chef', 'plugin_manifest.json')).and_return(false)
       end
 
-      it "uses paths from the manifest instead of searching gems" do
-        expect(Gem::Specification).not_to receive(:latest_specs).and_call_original
-        expect(loader.subcommand_files).to include(ec2_server_create_plugin)
+      it "creates a GemGlobLoader" do
+        expect(Chef::Knife::SubcommandLoader.for_config(config_dir)).to be_a Chef::Knife::SubcommandLoader::GemGlobLoader
       end
-
     end
   end
-
 end

data/spec/unit/knife/node_run_list_remove_spec.rb

@@ -84,6 +84,23 @@ describe Chef::Knife::NodeRunListRemove do
         expect(@node.run_list).not_to include('role[monkey]')
         expect(@node.run_list).not_to include('recipe[duck::type]')
       end
+
+      it "should warn when the thing to remove is not in the runlist" do
+        @node.run_list << 'role[blah]'
+        @node.run_list << 'recipe[duck::type]'
+        @knife.name_args = [ 'adam', 'role[blork]' ]
+        expect(@knife.ui).to receive(:warn).with("role[blork] is not in the run list")
+        @knife.run
+      end
+
+      it "should warn even more when the thing to remove is not in the runlist and unqualified" do
+        @node.run_list << 'role[blah]'
+        @node.run_list << 'recipe[duck::type]'
+        @knife.name_args = [ 'adam', 'blork' ]
+        expect(@knife.ui).to receive(:warn).with("blork is not in the run list")
+        expect(@knife.ui).to receive(:warn).with(/did you forget recipe\[\] or role\[\]/)
+        @knife.run
+      end
     end
   end
 end

data/spec/unit/mixin/enforce_ownership_and_permissions_spec.rb

@@ -49,12 +49,12 @@ describe Chef::Mixin::EnforceOwnershipAndPermissions do
       allow_any_instance_of(Chef::FileAccessControl).to receive(:uid_from_resource).and_return(0)
       allow_any_instance_of(Chef::FileAccessControl).to receive(:requires_changes?).and_return(false)
       allow_any_instance_of(Chef::FileAccessControl).to receive(:define_resource_requirements)
+      allow_any_instance_of(Chef::FileAccessControl).to receive(:describe_changes)
+
+      passwd_struct = OpenStruct.new(:name => "root", :passwd => "x",
+                                     :uid => 0, :gid => 0, :dir => '/root',
+                                     :shell => '/bin/bash')
 
-      passwd_struct = if windows?
-                        Struct::Passwd.new("root", "x", 0, 0, "/root", "/bin/bash")
-                      else
-                        Struct::Passwd.new("root", "x", 0, 0, "root", "/root", "/bin/bash")
-                      end
       group_struct = OpenStruct.new(:name => "root", :passwd => "x", :gid => 0)
       allow(Etc).to receive(:getpwuid).and_return(passwd_struct)
       allow(Etc).to receive(:getgrgid).and_return(group_struct)
@@ -73,12 +73,12 @@ describe Chef::Mixin::EnforceOwnershipAndPermissions do
     before do
       allow_any_instance_of(Chef::FileAccessControl).to receive(:requires_changes?).and_return(true)
       allow_any_instance_of(Chef::FileAccessControl).to receive(:uid_from_resource).and_return(0)
+      allow_any_instance_of(Chef::FileAccessControl).to receive(:describe_changes)
+
+      passwd_struct = OpenStruct.new(:name => "root", :passwd => "x",
+                                     :uid => 0, :gid => 0, :dir => '/root',
+                                     :shell => '/bin/bash')
 
-      passwd_struct = if windows?
-                        Struct::Passwd.new("root", "x", 0, 0, "/root", "/bin/bash")
-                      else
-                        Struct::Passwd.new("root", "x", 0, 0, "root", "/root", "/bin/bash")
-                      end
       group_struct = OpenStruct.new(:name => "root", :passwd => "x", :gid => 0)
       allow(Etc).to receive(:getpwuid).and_return(passwd_struct)
       allow(Etc).to receive(:getgrgid).and_return(group_struct)

data/spec/unit/mixin/template_spec.rb

@@ -150,6 +150,11 @@ describe Chef::Mixin::Template, "render_template" do
       output == "before {super secret is candy} after"
     end
 
+    it "should pass the template finder to the partials" do
+      output = @template_context.render_template_from_string("before {<%= render 'nested_openldap_partials.erb', :variables => {:hello => 'Hello World!' } %>} after")
+      output == "before {Hello World!} after"
+    end
+
     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")
       expect(output).to eq("before {super secret is whatever} after")
@@ -266,4 +271,3 @@ describe Chef::Mixin::Template, "render_template" do
     end
   end
 end
-

data/spec/unit/mixin/windows_architecture_helper_spec.rb

@@ -60,23 +60,28 @@ describe Chef::Mixin::WindowsArchitectureHelper do
     end
   end
 
-  it "returns true for each supported desired architecture for all nodes with each valid architecture passed to node_supports_windows_architecture" do
-    enumerate_architecture_node_combinations(true)
+  it "returns true only for supported desired architecture passed to node_supports_windows_architecture" do
+    with_node_architecture_combinations do | node, desired_arch |
+        expect(node_supports_windows_architecture?(node, desired_arch)).to be true if (node_windows_architecture(node) == :x86_64 || desired_arch == :i386 )
+        expect(node_supports_windows_architecture?(node, desired_arch)).to be false if (node_windows_architecture(node)  == :i386 && desired_arch == :x86_64 )
+    end
   end
 
-  it "returns false for each unsupported desired architecture for all nodes with each valid architecture passed to node_supports_windows_architecture?" do
-    enumerate_architecture_node_combinations(true)
+  it "returns true only when forced_32bit_override_required? has 64-bit node architecture and 32-bit desired architecture" do
+    with_node_architecture_combinations do | node, desired_arch |
+      expect(forced_32bit_override_required?(node, desired_arch)).to be true if ((node_windows_architecture(node) == :x86_64) && (desired_arch == :i386) && !is_i386_process_on_x86_64_windows?)
+      expect(forced_32bit_override_required?(node, desired_arch)).to be false if ! ((node_windows_architecture(node) == :x86_64) && (desired_arch == :i386))
+    end
   end
 
-  def enumerate_architecture_node_combinations(only_valid_combinations)
+  def with_node_architecture_combinations
     @valid_architectures.each do | node_architecture |
       new_node = Chef::Node.new
       new_node.default["kernel"] = Hash.new
       new_node.default["kernel"][:machine] = node_architecture.to_s
 
-      @valid_architectures.each do | supported_architecture |
-        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 )
+      @valid_architectures.each do | architecture |
+        yield new_node, architecture if block_given?
       end
     end
   end

data/spec/unit/node_spec.rb

@@ -127,6 +127,78 @@ describe Chef::Node do
     end
   end
 
+  describe "policy_name" do
+
+    it "defaults to nil" do
+      expect(node.policy_name).to be_nil
+    end
+
+    it "sets policy_name with a regular setter" do
+      node.policy_name = "example-policy"
+      expect(node.policy_name).to eq("example-policy")
+    end
+
+    it "allows policy_name with every valid character" do
+      expect { node.policy_name = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqurstuvwxyz0123456789-_:.' }.to_not raise_error
+    end
+
+    it "sets policy_name when given an argument" do
+      node.policy_name("example-policy")
+      expect(node.policy_name).to eq("example-policy")
+    end
+
+    it "sets policy_name to nil when given nil" do
+      node.policy_name = "example-policy"
+      node.policy_name = nil
+      expect(node.policy_name).to be_nil
+    end
+
+    it "disallows non-strings" do
+      expect { node.policy_name(Hash.new) }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { node.policy_name(42) }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "cannot be blank" do
+      expect { node.policy_name("")}.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+  end
+
+  describe "policy_group" do
+
+    it "defaults to nil" do
+      expect(node.policy_group).to be_nil
+    end
+
+    it "sets policy_group with a regular setter" do
+      node.policy_group = "staging"
+      expect(node.policy_group).to eq("staging")
+    end
+
+    it "allows policy_group with every valid character" do
+      expect { node.policy_group = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqurstuvwxyz0123456789-_:.' }.to_not raise_error
+    end
+
+    it "sets an environment with chef_environment(something)" do
+      node.policy_group("staging")
+      expect(node.policy_group).to eq("staging")
+    end
+
+    it "sets policy_group to nil when given nil" do
+      node.policy_group = "staging"
+      node.policy_group = nil
+      expect(node.policy_group).to be_nil
+    end
+
+    it "disallows non-strings" do
+      expect { node.policy_group(Hash.new) }.to raise_error(Chef::Exceptions::ValidationFailed)
+      expect { node.policy_group(42) }.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+
+    it "cannot be blank" do
+      expect { node.policy_group("")}.to raise_error(Chef::Exceptions::ValidationFailed)
+    end
+  end
+
   describe "attributes" do
     it "should have attributes" do
       expect(node.attribute).to be_a_kind_of(Hash)
@@ -1113,6 +1185,43 @@ describe Chef::Node do
       expect(serialized_node.run_list).to eq(node.run_list)
     end
 
+    context "when policyfile attributes are not present" do
+
+      it "does not have a policy_name key in the json" do
+        expect(node.for_json.keys).to_not include("policy_name")
+      end
+
+      it "does not have a policy_group key in the json" do
+        expect(node.for_json.keys).to_not include("policy_name")
+      end
+    end
+
+    context "when policyfile attributes are present" do
+
+      before do
+        node.policy_name = "my-application"
+        node.policy_group = "staging"
+      end
+
+      it "includes policy_name key in the json" do
+        expect(node.for_json).to have_key("policy_name")
+        expect(node.for_json["policy_name"]).to eq("my-application")
+      end
+
+      it "includes a policy_group key in the json" do
+        expect(node.for_json).to have_key("policy_group")
+        expect(node.for_json["policy_group"]).to eq("staging")
+      end
+
+      it "parses policyfile attributes from JSON" do
+        round_tripped_node = Chef::Node.json_create(node.for_json)
+
+        expect(round_tripped_node.policy_name).to eq("my-application")
+        expect(round_tripped_node.policy_group).to eq("staging")
+      end
+
+    end
+
     include_examples "to_json equivalent to Chef::JSONCompat.to_json" do
       let(:jsonable) {
         node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA))
@@ -1308,6 +1417,110 @@ describe Chef::Node do
           node.save
         end
       end
+
+      context "when policyfile attributes are present" do
+
+        before do
+          node.name("example-node")
+          node.policy_name = "my-application"
+          node.policy_group = "staging"
+        end
+
+        context "and the server supports policyfile attributes in node JSON" do
+
+          it "creates the object normally" do
+            expect(@rest).to receive(:post_rest).with("nodes", node.for_json)
+            node.create
+          end
+
+          it "saves the node object normally" do
+            expect(@rest).to receive(:put_rest).with("nodes/example-node", node.for_json)
+            node.save
+          end
+        end
+
+        # Chef Server before 12.3
+        context "and the Chef Server does not support policyfile attributes in node JSON" do
+
+          let(:response_body) { %q[{"error":["Invalid key policy_name in request body"]}] }
+
+          let(:response) do
+            Net::HTTPResponse.send(:response_class, "400").new("1.0", "400", "Bad Request").tap do |r|
+              allow(r).to receive(:body).and_return(response_body)
+            end
+          end
+
+          let(:http_exception) do
+            begin
+              response.error!
+            rescue => e
+              e
+            end
+          end
+
+          let(:trimmed_node) do
+            node.for_json.tap do |j|
+              j.delete("policy_name")
+              j.delete("policy_group")
+            end
+
+          end
+
+          context "on Chef Client 13 and later" do
+
+            # Though we normally attempt to provide compatibility with chef
+            # server one major version back, policyfiles were beta when we
+            # added the policyfile attributes to the node JSON, therefore
+            # policyfile users need to be on 12.3 minimum when upgrading Chef
+            # Client to 13+
+            it "lets the 400 pass through", :chef_gte_13_only do
+              expect { node.save }.to raise_error(http_exception)
+            end
+
+          end
+
+          context "when the node exists" do
+
+            it "falls back to saving without policyfile attributes" do
+              expect(@rest).to receive(:put_rest).with("nodes/example-node", node.for_json).and_raise(http_exception)
+              expect(@rest).to receive(:put_rest).with("nodes/example-node", trimmed_node).and_return(@node)
+              expect { node.save }.to_not raise_error
+            end
+
+          end
+
+          context "when the node doesn't exist" do
+
+            let(:response_404) do
+              Net::HTTPResponse.send(:response_class, "404").new("1.0", "404", "Not Found")
+            end
+
+            let(:http_exception_404) do
+              begin
+                response_404.error!
+              rescue => e
+                e
+              end
+            end
+
+            it "falls back to saving without policyfile attributes" do
+              expect(@rest).to receive(:put_rest).with("nodes/example-node", node.for_json).and_raise(http_exception)
+              expect(@rest).to receive(:put_rest).with("nodes/example-node", trimmed_node).and_raise(http_exception_404)
+              expect(@rest).to receive(:post_rest).with("nodes", trimmed_node).and_return(@node)
+              node.save
+            end
+
+            it "creates the node without policyfile attributes" do
+              expect(@rest).to receive(:post_rest).with("nodes", node.for_json).and_raise(http_exception)
+              expect(@rest).to receive(:post_rest).with("nodes", trimmed_node).and_return(@node)
+              node.create
+            end
+          end
+
+        end
+
+      end
+
     end
   end