chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/spec/unit/policy_builder/dynamic_spec.rb

@@ -0,0 +1,275 @@
+#
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright 2014 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'
+require 'chef/policy_builder'
+
+describe Chef::PolicyBuilder::Dynamic do
+
+  let(:node_name) { "joe_node" }
+  let(:ohai_data) { {"platform" => "ubuntu", "platform_version" => "13.04", "fqdn" => "joenode.example.com"} }
+  let(:json_attribs) { {"custom_attr" => "custom_attr_value"} }
+  let(:override_runlist) { nil }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+
+  let(:err_namespace) { Chef::PolicyBuilder::Policyfile }
+
+  let(:base_node) do
+    node = Chef::Node.new
+    node.name(node_name)
+    node
+  end
+
+  let(:node) { base_node }
+
+  subject(:policy_builder) { Chef::PolicyBuilder::Dynamic.new(node_name, ohai_data, json_attribs, override_runlist, events) }
+
+  describe "loading policy data" do
+
+    describe "delegating PolicyBuilder API to the correct implementation" do
+
+      let(:implementation) { instance_double("Chef::PolicyBuilder::Policyfile") }
+
+      before do
+        allow(policy_builder).to receive(:implementation).and_return(implementation)
+      end
+
+      # Dynamic should load_node, figure out the correct backend, then forward
+      # messages to it after. That behavior is tested below.
+      it "responds to #load_node" do
+        expect(policy_builder).to respond_to(:load_node)
+      end
+
+      it "forwards #original_runlist" do
+        expect(implementation).to receive(:original_runlist)
+        policy_builder.original_runlist
+      end
+
+      it "forwards #run_context" do
+        expect(implementation).to receive(:run_context)
+        policy_builder.run_context
+      end
+
+      it "forwards #run_list_expansion" do
+        expect(implementation).to receive(:run_list_expansion)
+        policy_builder.run_list_expansion
+      end
+
+      it "forwards #build_node to the implementation object" do
+        expect(implementation).to receive(:build_node)
+        policy_builder.build_node
+      end
+
+      it "forwards #setup_run_context to the implementation object" do
+        expect(implementation).to receive(:setup_run_context)
+        policy_builder.setup_run_context
+
+        arg = Object.new
+
+        expect(implementation).to receive(:setup_run_context).with(arg)
+        policy_builder.setup_run_context(arg)
+      end
+
+      it "forwards #expand_run_list to the implementation object" do
+        expect(implementation).to receive(:expand_run_list)
+        policy_builder.expand_run_list
+      end
+
+      it "forwards #sync_cookbooks to the implementation object" do
+        expect(implementation).to receive(:sync_cookbooks)
+        policy_builder.sync_cookbooks
+      end
+
+      it "forwards #temporary_policy? to the implementation object" do
+        expect(implementation).to receive(:temporary_policy?)
+        policy_builder.temporary_policy?
+      end
+
+    end
+
+    describe "selecting a backend implementation" do
+
+      let(:implementation) do
+        policy_builder.select_implementation(node)
+        policy_builder.implementation
+      end
+
+      context "when no policyfile attributes are present on the node" do
+
+        context "and json_attribs are not given" do
+
+          let(:json_attribs) { {} }
+
+          it "uses the ExpandNodeObject implementation" do
+            expect(implementation).to be_a(Chef::PolicyBuilder::ExpandNodeObject)
+          end
+
+        end
+
+        context "and no policyfile attributes are present in json_attribs" do
+
+          let(:json_attribs) { {"foo" => "bar"} }
+
+          it "uses the ExpandNodeObject implementation" do
+            expect(implementation).to be_a(Chef::PolicyBuilder::ExpandNodeObject)
+          end
+
+        end
+
+        context "and :use_policyfile is set in Chef::Config" do
+
+          before do
+            Chef::Config[:use_policyfile] = true
+          end
+
+          it "uses the Policyfile implementation" do
+            expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
+          end
+
+        end
+
+        context "and policy_name and policy_group are set on Chef::Config" do
+
+          before do
+            Chef::Config[:policy_name] = "example-policy"
+            Chef::Config[:policy_group] = "testing"
+          end
+
+          it "uses the Policyfile implementation" do
+            expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
+          end
+
+        end
+
+        context "and deployment_group and policy_document_native_api are set on Chef::Config" do
+
+          before do
+            Chef::Config[:deployment_group] = "example-policy-staging"
+            Chef::Config[:policy_document_native_api] = false
+          end
+
+          it "uses the Policyfile implementation" do
+            expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
+          end
+
+        end
+
+        context "and policyfile attributes are present in json_attribs" do
+
+          let(:json_attribs) { {"policy_name" => "example-policy", "policy_group" => "testing"} }
+
+          it "uses the Policyfile implementation" do
+            expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
+          end
+
+        end
+
+      end
+
+      context "when policyfile attributes are present on the node" do
+
+        let(:node) do
+          base_node.policy_name = "example-policy"
+          base_node.policy_group = "staging"
+          base_node
+        end
+
+        it "uses the Policyfile implementation" do
+          expect(implementation).to be_a(Chef::PolicyBuilder::Policyfile)
+        end
+
+      end
+
+    end
+
+    describe "loading a node" do
+
+      let(:implementation) { instance_double("Chef::PolicyBuilder::Policyfile") }
+
+      before do
+        allow(policy_builder).to receive(:implementation).and_return(implementation)
+      end
+
+      context "when not running chef solo" do
+
+
+        context "when successful" do
+
+          before do
+            expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
+            expect(policy_builder).to receive(:select_implementation).with(node)
+            expect(implementation).to receive(:finish_load_node).with(node)
+          end
+
+          it "selects the backend implementation and continues node loading" do
+            policy_builder.load_node
+          end
+
+        end
+
+        context "when an error occurs finding the node" do
+
+          before do
+            expect(Chef::Node).to receive(:find_or_create).with(node_name).and_raise("oops")
+          end
+
+          it "sends a node_load_failed event and re-raises" do
+            expect(events).to receive(:node_load_failed)
+            expect { policy_builder.load_node }.to raise_error("oops")
+          end
+
+        end
+
+        context "when an error occurs in the implementation's finish_load_node call" do
+
+          before do
+            expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
+            expect(policy_builder).to receive(:select_implementation).with(node)
+            expect(implementation).to receive(:finish_load_node).and_raise("oops")
+          end
+
+
+          it "sends a node_load_failed event and re-raises" do
+            expect(events).to receive(:node_load_failed)
+            expect { policy_builder.load_node }.to raise_error("oops")
+          end
+
+        end
+
+      end
+
+      context "when running chef solo" do
+
+        before do
+          Chef::Config[:solo] = true
+          expect(Chef::Node).to receive(:build).with(node_name).and_return(node)
+          expect(policy_builder).to receive(:select_implementation).with(node)
+          expect(implementation).to receive(:finish_load_node).with(node)
+        end
+
+        it "selects the backend implementation and continues node loading" do
+          policy_builder.load_node
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/policy_builder/expand_node_object_spec.rb

@@ -34,10 +34,18 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
       expect(policy_builder).to respond_to(:node)
     end
 
-    it "implements a load_node method" do
+    it "implements a load_node method for backwards compatibility until Chef 13" do
       expect(policy_builder).to respond_to(:load_node)
     end
 
+    it "has removed the deprecated #load_node method", :chef_gte_13_only do
+      expect(policy_builder).to_not respond_to(:load_node)
+    end
+
+    it "implements a finish_load_node method" do
+      expect(policy_builder).to respond_to(:finish_load_node)
+    end
+
     it "implements  a build_node method" do
       expect(policy_builder).to respond_to(:build_node)
     end
@@ -63,39 +71,13 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
       expect(policy_builder).to respond_to(:temporary_policy?)
     end
 
-    describe "loading the node" do
-
-      context "on chef-solo" do
-
-        before do
-          Chef::Config[:solo] = true
-        end
-
-        it "creates a new in-memory node object with the given name" do
-          policy_builder.load_node
-          expect(policy_builder.node.name).to eq(node_name)
-        end
-
-      end
-
-      context "on chef-client" do
-
-        let(:node) { Chef::Node.new.tap { |n| n.name(node_name) } }
-
-        it "loads or creates a node on the server" do
-          expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
-          policy_builder.load_node
-          expect(policy_builder.node).to eq(node)
-        end
+    describe "finishing loading the node" do
 
-      end
-    end
-
-    describe "building the node" do
+      let(:node) { Chef::Node.new.tap { |n| n.name(node_name) } }
 
-      # XXX: Chef::Client just needs to be able to call this, it doesn't depend on the return value.
-      it "builds the node and returns the updated node object" do
-        skip
+      it "stores the node" do
+        policy_builder.finish_load_node(node)
+        expect(policy_builder.node).to eq(node)
       end
 
     end
@@ -124,7 +106,8 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
 
   end
 
-  context "once the node has been loaded" do
+  context "deprecated #load_node method" do
+
     let(:node) do
       node = Chef::Node.new
       node.name(node_name)
@@ -133,10 +116,29 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
     end
 
     before do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
       policy_builder.load_node
     end
 
+    it "loads the node" do
+      expect(policy_builder.node).to eq(node)
+    end
+
+  end
+
+  context "once the node has been loaded" do
+    let(:node) do
+      node = Chef::Node.new
+      node.name(node_name)
+      node.run_list(["recipe[a::default]", "recipe[b::server]"])
+      node
+    end
+
+    before do
+      policy_builder.finish_load_node(node)
+    end
+
     it "expands the run_list" do
       expect(policy_builder.expand_run_list).to be_a(Chef::RunList::RunListExpansion)
       expect(policy_builder.run_list_expansion).to be_a(Chef::RunList::RunListExpansion)
@@ -167,8 +169,7 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
 
     before do
       Chef::Config[:environment] = configured_environment
-      expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
-      policy_builder.load_node
+      policy_builder.finish_load_node(node)
       policy_builder.build_node
     end
 
@@ -302,11 +303,9 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
     let(:cookbook_synchronizer) { double("CookbookSynchronizer") }
 
     before do
-      expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
-
       allow(policy_builder).to receive(:api_service).and_return(chef_http)
 
-      policy_builder.load_node
+      policy_builder.finish_load_node(node)
       policy_builder.build_node
 
       run_list_expansion = policy_builder.run_list_expansion

data/spec/unit/policy_builder/policyfile_spec.rb

@@ -76,8 +76,11 @@ describe Chef::PolicyBuilder::Policyfile do
 
   let(:policyfile_run_list) { ["recipe[example1::default]", "recipe[example2::server]"] }
 
-  let(:parsed_policyfile_json) do
+  let(:basic_valid_policy_data) do
     {
+      "name" => "example-policy",
+      "revision_id" => "123abc",
+
       "run_list" => policyfile_run_list,
 
       "cookbook_locks" => {
@@ -90,6 +93,8 @@ describe Chef::PolicyBuilder::Policyfile do
     }
   end
 
+  let(:parsed_policyfile_json) { basic_valid_policy_data }
+
   let(:err_namespace) { Chef::PolicyBuilder::Policyfile }
 
   it "configures a Chef HTTP API client" do
@@ -181,19 +186,13 @@ describe Chef::PolicyBuilder::Policyfile do
         let(:error404) { Net::HTTPServerException.new("404 message", :body) }
 
         before do
-          expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
           expect(http_api).to receive(:get).
             with("data/policyfiles/example-policy-stage").
             and_raise(error404)
         end
 
         it "raises an error" do
-          expect { policy_builder.load_node }.to raise_error(err_namespace::ConfigurationError)
-        end
-
-        it "sends error message to the event system" do
-          expect(events).to receive(:node_load_failed).with(node_name, an_instance_of(err_namespace::ConfigurationError), Chef::Config)
-          expect { policy_builder.load_node }.to raise_error(err_namespace::ConfigurationError)
+          expect { policy_builder.finish_load_node(node) }.to raise_error(err_namespace::ConfigurationError)
         end
 
       end
@@ -201,20 +200,12 @@ describe Chef::PolicyBuilder::Policyfile do
       context "when the deployment_group is not configured" do
         before do
           Chef::Config[:deployment_group] = nil
-          expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
         end
 
         it "errors while loading the node" do
-          expect { policy_builder.load_node }.to raise_error(err_namespace::ConfigurationError)
+          expect { policy_builder.finish_load_node(node) }.to raise_error(err_namespace::ConfigurationError)
         end
 
-
-        it "passes error information to the event system" do
-          # TODO: also make sure something acceptable happens with the error formatters
-          err_class = err_namespace::ConfigurationError
-          expect(events).to receive(:node_load_failed).with(node_name, an_instance_of(err_class), Chef::Config)
-          expect { policy_builder.load_node }.to raise_error(err_class)
-        end
       end
 
       context "when deployment_group is correctly configured" do
@@ -307,8 +298,7 @@ describe Chef::PolicyBuilder::Policyfile do
       end
 
       it "implements #expand_run_list in a manner compatible with ExpandNodeObject" do
-        expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
-        policy_builder.load_node
+        policy_builder.finish_load_node(node)
         expect(policy_builder.expand_run_list).to respond_to(:recipes)
         expect(policy_builder.expand_run_list.recipes).to eq(["example1::default", "example2::server"])
         expect(policy_builder.expand_run_list.roles).to eq([])
@@ -345,46 +335,261 @@ describe Chef::PolicyBuilder::Policyfile do
 
       describe "building the node object" do
 
+        let(:extra_chef_config) { {} }
+
         before do
-          expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
+          # must be set before #build_node is called to have the proper effect
+          extra_chef_config.each do |key, value|
+            Chef::Config[key] = value
+          end
 
-          policy_builder.load_node
+          policy_builder.finish_load_node(node)
           policy_builder.build_node
         end
 
+        # it sets policy_name and policy_group in the following priority order:
+        # -j JSON > config file > node object
+
+        describe "selecting policy_name and policy_group from the various sources" do
+
+          context "when only set in node JSON" do
+
+            let(:json_attribs) do
+              {
+                "policy_name" => "policy_name_from_node_json",
+                "policy_group" => "policy_group_from_node_json"
+              }
+            end
+
+            it "sets policy_name and policy_group on Chef::Config" do
+              expect(Chef::Config[:policy_name]).to eq("policy_name_from_node_json")
+              expect(Chef::Config[:policy_group]).to eq("policy_group_from_node_json")
+            end
+
+            it "sets policy_name and policy_group on the node object" do
+              expect(node.policy_name).to eq("policy_name_from_node_json")
+              expect(node.policy_group).to eq("policy_group_from_node_json")
+            end
+
+          end
+
+          context "when only set in Chef::Config" do
+
+            let(:extra_chef_config) do
+              {
+                policy_name: "policy_name_from_config",
+                policy_group: "policy_group_from_config"
+              }
+            end
+
+            it "sets policy_name and policy_group on the node object" do
+              expect(node.policy_name).to eq("policy_name_from_config")
+              expect(node.policy_group).to eq("policy_group_from_config")
+            end
+
+          end
+
+          context "when only set on the node" do
+
+            let(:node) do
+              node = Chef::Node.new
+              node.name(node_name)
+              node.policy_name = "policy_name_from_node"
+              node.policy_group = "policy_group_from_node"
+              node
+            end
+
+            it "sets policy_name and policy_group on Chef::Config" do
+              expect(Chef::Config[:policy_name]).to eq("policy_name_from_node")
+              expect(Chef::Config[:policy_group]).to eq("policy_group_from_node")
+            end
+
+          end
+
+          context "when set in Chef::Config and the fetched node" do
+
+            let(:node) do
+              node = Chef::Node.new
+              node.name(node_name)
+              node.policy_name = "policy_name_from_node"
+              node.policy_group = "policy_group_from_node"
+              node
+            end
+
+            let(:extra_chef_config) do
+              {
+                policy_name: "policy_name_from_config",
+                policy_group: "policy_group_from_config"
+              }
+            end
+
+            it "prefers the policy_name and policy_group from Chef::Config" do
+              expect(node.policy_name).to eq("policy_name_from_config")
+              expect(node.policy_group).to eq("policy_group_from_config")
+            end
+
+          end
+
+          context "when set in node json and the fetched node" do
+
+            let(:json_attribs) do
+              {
+                "policy_name" => "policy_name_from_node_json",
+                "policy_group" => "policy_group_from_node_json"
+              }
+            end
+
+            let(:node) do
+              node = Chef::Node.new
+              node.name(node_name)
+              node.policy_name = "policy_name_from_node"
+              node.policy_group = "policy_group_from_node"
+              node
+            end
+
+
+            it "prefers the policy_name and policy_group from the node json" do
+              expect(policy_builder.policy_name).to eq("policy_name_from_node_json")
+              expect(policy_builder.policy_group).to eq("policy_group_from_node_json")
+
+              expect(Chef::Config[:policy_name]).to eq("policy_name_from_node_json")
+              expect(Chef::Config[:policy_group]).to eq("policy_group_from_node_json")
+              expect(node.policy_name).to eq("policy_name_from_node_json")
+              expect(node.policy_group).to eq("policy_group_from_node_json")
+            end
+
+          end
+
+          context "when set in all sources" do
+
+            let(:json_attribs) do
+              {
+                "policy_name" => "policy_name_from_node_json",
+                "policy_group" => "policy_group_from_node_json"
+              }
+            end
+
+            let(:node) do
+              node = Chef::Node.new
+              node.name(node_name)
+              node.policy_name = "policy_name_from_node"
+              node.policy_group = "policy_group_from_node"
+              node
+            end
+
+            let(:extra_chef_config) do
+              {
+                policy_name: "policy_name_from_config",
+                policy_group: "policy_group_from_config"
+              }
+            end
+
+            it "prefers the policy_name and group from node json" do
+              expect(policy_builder.policy_name).to eq("policy_name_from_node_json")
+              expect(policy_builder.policy_group).to eq("policy_group_from_node_json")
+
+              expect(Chef::Config[:policy_name]).to eq("policy_name_from_node_json")
+              expect(Chef::Config[:policy_group]).to eq("policy_group_from_node_json")
+              expect(node.policy_name).to eq("policy_name_from_node_json")
+              expect(node.policy_group).to eq("policy_group_from_node_json")
+            end
+
+          end
+
+        end
+
         it "resets default and override data" do
           expect(node["default_key"]).to be_nil
           expect(node["override_key"]).to be_nil
         end
 
-        it "applies ohai data" do
-          expect(ohai_data).to_not be_empty # ensure test is testing something
-          ohai_data.each do |key, value|
-            expect(node.automatic_attrs[key]).to eq(value)
+        describe "setting attribute values" do
+
+          before do
+            policy_builder.build_node
           end
-        end
 
-        it "applies attributes from json file" do
-          expect(node["custom_attr"]).to eq("custom_attr_value")
-        end
+          it "resets default and override data" do
+            expect(node["default_key"]).to be_nil
+            expect(node["override_key"]).to be_nil
+          end
 
-        it "applies attributes from the policyfile" do
-          expect(node["policyfile_default_attr"]).to eq("policyfile_default_value")
-          expect(node["policyfile_override_attr"]).to eq("policyfile_override_value")
-        end
+          it "applies ohai data" do
+            expect(ohai_data).to_not be_empty # ensure test is testing something
+            ohai_data.each do |key, value|
+              expect(node.automatic_attrs[key]).to eq(value)
+            end
+          end
 
-        it "sets the policyfile's run_list on the node object" do
-          expect(node.run_list).to eq(policyfile_run_list)
-        end
+          it "applies attributes from json file" do
+            expect(node["custom_attr"]).to eq("custom_attr_value")
+          end
 
-        it "creates node.automatic_attrs[:roles]" do
-          expect(node.automatic_attrs[:roles]).to eq([])
-        end
+          it "applies attributes from the policyfile" do
+            expect(node["policyfile_default_attr"]).to eq("policyfile_default_value")
+            expect(node["policyfile_override_attr"]).to eq("policyfile_override_value")
+          end
+
+          it "sets the policyfile's run_list on the node object" do
+            expect(node.run_list).to eq(policyfile_run_list)
+          end
+
+          it "creates node.automatic_attrs[:roles]" do
+            expect(node.automatic_attrs[:roles]).to eq([])
+          end
 
-        it "create node.automatic_attrs[:recipes]" do
-          expect(node.automatic_attrs[:recipes]).to eq(["example1::default", "example2::server"])
+          it "create node.automatic_attrs[:recipes]" do
+            expect(node.automatic_attrs[:recipes]).to eq(["example1::default", "example2::server"])
+          end
         end
 
+        context "when a named run_list is given" do
+
+          before do
+            Chef::Config[:named_run_list] = "deploy-app"
+          end
+
+          context "and the named run_list is not present in the policy" do
+
+            it "raises a ConfigurationError" do
+              err_class = Chef::PolicyBuilder::Policyfile::ConfigurationError
+              err_text = "Policy 'example-policy' revision '123abc' does not have named_run_list 'deploy-app'(available named_run_lists: [])"
+              expect { policy_builder.build_node }.to raise_error(err_class, err_text)
+            end
+
+          end
+
+          context "and the named run_list is present in the policy" do
+
+            let(:parsed_policyfile_json) do
+              basic_valid_policy_data.dup.tap do |p|
+                p["named_run_lists"] = {
+                  "deploy-app" => [ "recipe[example1::default]" ]
+                }
+              end
+            end
+
+            before do
+              policy_builder.build_node
+            end
+
+            it "sets the run list to the desired named run list" do
+              expect(policy_builder.run_list).to eq([ "recipe[example1::default]" ])
+              expected_expansion = Chef::PolicyBuilder::Policyfile::RunListExpansionIsh.new([ "example1::default" ], [])
+              expect(policy_builder.run_list_expansion).to eq(expected_expansion)
+              expect(policy_builder.run_list_with_versions_for_display).to eq(["example1::default@2.3.5 (168d210)"])
+              expect(node.run_list).to eq([ Chef::RunList::RunListItem.new("recipe[example1::default]") ])
+              expect(node[:roles]).to eq( [] )
+              expect(node[:recipes]).to eq( ["example1::default"] )
+            end
+
+            it "disables the cookbook cache cleaner" do
+              expect(Chef::CookbookCacheCleaner.instance.skip_removal).to be(true)
+            end
+
+          end
+
+        end
       end
 
 
@@ -414,9 +619,7 @@ describe Chef::PolicyBuilder::Policyfile do
             let(:error404) { Net::HTTPServerException.new("404 message", :body) }
 
             before do
-              expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
-
-              policy_builder.load_node
+              policy_builder.finish_load_node(node)
               policy_builder.build_node
 
               expect(http_api).to receive(:get).with(cookbook1_url).
@@ -433,9 +636,9 @@ describe Chef::PolicyBuilder::Policyfile do
         shared_examples_for "fetching cookbooks when they exist" do
           context "and the cookbooks can be fetched" do
             before do
-              expect(Chef::Node).to receive(:find_or_create).with(node_name).and_return(node)
+              Chef.reset!
 
-              policy_builder.load_node
+              policy_builder.finish_load_node(node)
               policy_builder.build_node
 
               allow(Chef::CookbookSynchronizer).to receive(:new).
@@ -443,6 +646,10 @@ describe Chef::PolicyBuilder::Policyfile do
                 and_return(cookbook_synchronizer)
             end
 
+            after do
+              Chef.reset!
+            end
+
             it "builds a Hash of the form 'cookbook_name' => Chef::CookbookVersion" do
               expect(policy_builder.cookbooks_to_sync).to eq(expected_cookbook_hash)
             end
@@ -460,6 +667,13 @@ describe Chef::PolicyBuilder::Policyfile do
               expect(run_context.cookbook_collection.keys).to match_array(["example1", "example2"])
             end
 
+            it "makes the run context available via static method on Chef" do
+              expect(cookbook_synchronizer).to receive(:sync_cookbooks)
+              expect_any_instance_of(Chef::RunContext).to receive(:load).with(policy_builder.run_list_expansion_ish)
+              run_context = policy_builder.setup_run_context
+              expect(Chef.run_context).to eq(run_context)
+            end
+
           end
         end # shared_examples_for "fetching cookbooks"