puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

data/spec/unit/graph/relationship_graph_spec.rb

@@ -295,21 +295,6 @@ describe Puppet::Graph::RelationshipGraph do
           completed_sentinel_of("class[A]"))
     end
 
-    it "admissible and completed sentinels should inherit the same tags" do
-      relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
-        class a {
-	  tag "test_tag"
-        }
-
-        include a
-      MANIFEST
-
-      expect(vertex_called(relationship_graph, admissible_sentinel_of("class[A]")).tagged?("test_tag")).
-      to eq(true)
-      expect(vertex_called(relationship_graph, completed_sentinel_of("class[A]")).tagged?("test_tag")).
-      to eq(true)
-    end
-
     it "should remove all Component objects from the dependency graph" do
       relationship_graph = compile_to_relationship_graph(<<-MANIFEST)
         class a {

data/spec/unit/graph/simple_graph_spec.rb

@@ -296,32 +296,37 @@ describe Puppet::Graph::SimpleGraph do
       end
     end
 
-    it "should fail on two-vertex loops" do
+    def expect_cycle_to_include(cycle, *resource_names)
+      resource_names.each_with_index do |resource, index|
+        expect(cycle[index].ref).to eq("Notify[#{resource}]")
+      end
+    end
+
+    it "should report two-vertex loops" do
       add_edges :a => :b, :b => :a
-      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/))
+      cycle = @graph.report_cycles_in_graph.first
+      expect_cycle_to_include(cycle, :a, :b)
     end
 
-    it "should fail on multi-vertex loops" do
+    it "should report multi-vertex loops" do
       add_edges :a => :b, :b => :c, :c => :a
-      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[c\] => Notify\[a\]\)/))
+      cycle = @graph.report_cycles_in_graph.first
+      expect_cycle_to_include(cycle, :a, :b, :c)
     end
 
-    it "should fail when a larger tree contains a small cycle" do
+    it "should report when a larger tree contains a small cycle" do
       add_edges :a => :b, :b => :a, :c => :a, :d => :c
-      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/))
+      cycle = @graph.report_cycles_in_graph.first
+      expect_cycle_to_include(cycle, :a, :b)
     end
 
     it "should succeed on trees with no cycles" do
       add_edges :a => :b, :b => :e, :c => :a, :d => :c
-      expect { @graph.report_cycles_in_graph }.to_not raise_error
-    end
-
-    it "should produce the correct relationship text" do
-      add_edges :a => :b, :b => :a
-      # cycle detection starts from a or b randomly
-      # so we need to check for either ordering in the error message
-      want = %r{Found 1 dependency cycle:\n\((Notify\[a\] => Notify\[b\] => Notify\[a\]|Notify\[b\] => Notify\[a\] => Notify\[b\])\)\nTry}
-      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error, want)
+      Puppet.expects(:err).never
+      expect(@graph.report_cycles_in_graph).to be_nil
     end
 
     it "cycle discovery should be the minimum cycle for a simple graph" do
@@ -528,31 +533,31 @@ describe Puppet::Graph::SimpleGraph do
     end
 
     def one_vertex_graph(graph)
-      graph.add_vertex(:a)
+      graph.add_vertex('a')
     end
 
     def graph_without_edges(graph)
-      [:a, :b, :c].each { |x| graph.add_vertex(x) }
+      ['a', 'b', 'c'].each { |x| graph.add_vertex(x) }
     end
 
     def one_edge_graph(graph)
-      graph.add_edge(:a, :b)
+      graph.add_edge('a', 'b')
     end
 
     def many_edge_graph(graph)
-      graph.add_edge(:a, :b)
-      graph.add_edge(:a, :c)
-      graph.add_edge(:b, :d)
-      graph.add_edge(:c, :d)
+      graph.add_edge('a', 'b')
+      graph.add_edge('a', 'c')
+      graph.add_edge('b', 'd')
+      graph.add_edge('c', 'd')
     end
 
     def labeled_edge_graph(graph)
-      graph.add_edge(:a, :b, :callback => :foo, :event => :bar)
+      graph.add_edge('a', 'b', :callback => :foo, :event => :bar)
     end
 
     def overlapping_edge_graph(graph)
-      graph.add_edge(:a, :b, :callback => :foo, :event => :bar)
-      graph.add_edge(:a, :b, :callback => :biz, :event => :baz)
+      graph.add_edge('a', 'b', :callback => :foo, :event => :bar)
+      graph.add_edge('a', 'b', :callback => :biz, :event => :baz)
     end
 
     def self.all_test_graphs
@@ -569,7 +574,11 @@ describe Puppet::Graph::SimpleGraph do
     def graph_to_yaml(graph, which_format)
       previous_use_new_yaml_format = Puppet::Graph::SimpleGraph.use_new_yaml_format
       Puppet::Graph::SimpleGraph.use_new_yaml_format = (which_format == :new)
-      YAML.dump(graph)
+      if block_given?
+        yield
+      else
+        YAML.dump(graph)
+      end
     ensure
       Puppet::Graph::SimpleGraph.use_new_yaml_format = previous_use_new_yaml_format
     end
@@ -605,7 +614,7 @@ describe Puppet::Graph::SimpleGraph do
             edge.keys.each { |x| expect(['source', 'target', 'callback', 'event']).to include(x) }
             %w{source target callback event}.collect { |x| edge[x] }
           end
-          expect(Set.new(actual_edge_tuples)).to eq(Set.new(expected_edge_tuples))
+          expect(Set.new(actual_edge_tuples)).to eq(Set.new(expected_edge_tuples.map { |tuple| tuple.map {|e| e.nil? ? nil : e.to_s }}))
           expect(actual_edge_tuples.length).to eq(expected_edge_tuples.length)
 
           # Check vertices one by one.
@@ -615,15 +624,16 @@ describe Puppet::Graph::SimpleGraph do
             expect(Set.new(vertices.keys)).to eq(Set.new(graph.vertices))
             vertices.each do |key, value|
               expect(value.keys.sort).to eq(%w{adjacencies vertex})
-              expect(value['vertex']).to equal(key)
+              expect(value['vertex']).to eq(key)
               adjacencies = value['adjacencies']
               expect(adjacencies).to be_a(Hash)
-              expect(Set.new(adjacencies.keys)).to eq(Set.new([:in, :out]))
+              expect(Set.new(adjacencies.keys)).to eq(Set.new(['in', 'out']))
               [:in, :out].each do |direction|
-                expect(adjacencies[direction]).to be_a(Hash)
+                direction_hash = adjacencies[direction.to_s]
+                expect(direction_hash).to be_a(Hash)
                 expected_adjacent_vertices = Set.new(graph.adjacent(key, :direction => direction, :type => :vertices))
-                expect(Set.new(adjacencies[direction].keys)).to eq(expected_adjacent_vertices)
-                adjacencies[direction].each do |adj_key, adj_value|
+                expect(Set.new(direction_hash.keys)).to eq(expected_adjacent_vertices)
+                direction_hash.each do |adj_key, adj_value|
                   # Since we already checked edges, just check consistency
                   # with edges.
                   desired_source = direction == :in ? adj_key : key
@@ -631,8 +641,8 @@ describe Puppet::Graph::SimpleGraph do
                   expected_edges = edges.select do |edge|
                     edge['source'] == desired_source && edge['target'] == desired_target
                   end
-                  expect(adj_value).to be_a(Set)
-                  if object_ids(adj_value) != object_ids(expected_edges)
+                  expect(adj_value).to be_a(Array)
+                  if adj_value != expected_edges
                     raise "For vertex #{key.inspect}, direction #{direction.inspect}: expected adjacencies #{expected_edges.inspect} but got #{adj_value.inspect}"
                   end
                 end
@@ -679,37 +689,30 @@ describe Puppet::Graph::SimpleGraph do
           # the internal representation of the graph is about to change.
         end
       end
-
-      it "should be able to serialize a graph where the vertices contain backreferences to the graph (#{which_format} format)" do
-        reference_graph = Puppet::Graph::SimpleGraph.new
-        vertex = Object.new
-        vertex.instance_eval { @graph = reference_graph }
-        reference_graph.add_edge(vertex, :other_vertex)
-        yaml_form = graph_to_yaml(reference_graph, which_format)
-        recovered_graph = YAML.load(yaml_form)
-
-        expect(recovered_graph.vertices.length).to eq(2)
-        recovered_vertex = recovered_graph.vertices.reject { |x| x.is_a?(Symbol) }[0]
-        expect(recovered_vertex.instance_eval { @graph }).to equal(recovered_graph)
-        expect(recovered_graph.edges.length).to eq(1)
-        recovered_edge = recovered_graph.edges[0]
-        expect(recovered_edge.source).to equal(recovered_vertex)
-        expect(recovered_edge.target).to eq(:other_vertex)
-      end
     end
 
     it "should serialize properly when used as a base class" do
       class Puppet::TestDerivedClass < Puppet::Graph::SimpleGraph
         attr_accessor :foo
+
+        def initialize_from_hash(hash)
+          super(hash)
+          @foo = hash['foo']
+        end
+
+        def to_data_hash
+          super.merge('foo' => @foo)
+        end
       end
       derived = Puppet::TestDerivedClass.new
-      derived.add_edge(:a, :b)
+      derived.add_edge('a', 'b')
       derived.foo = 1234
-      recovered_derived = YAML.load(YAML.dump(derived))
+      yaml = YAML.dump(derived)
+      recovered_derived = YAML.load(yaml)
       expect(recovered_derived.class).to equal(Puppet::TestDerivedClass)
       expect(recovered_derived.edges.length).to eq(1)
-      expect(recovered_derived.edges[0].source).to eq(:a)
-      expect(recovered_derived.edges[0].target).to eq(:b)
+      expect(recovered_derived.edges[0].source).to eq('a')
+      expect(recovered_derived.edges[0].target).to eq('b')
       expect(recovered_derived.vertices.length).to eq(2)
       expect(recovered_derived.foo).to eq(1234)
     end

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -6,6 +6,10 @@ require 'matchers/resource'
 require 'puppet/indirector/catalog/compiler'
 
 describe Puppet::Resource::Catalog::Compiler do
+  let(:compiler) { described_class.new }
+  let(:node_name) { "foo" }
+  let(:node) { Puppet::Node.new(node_name)}
+
   before do
     Facter.stubs(:to_hash).returns({})
   end
@@ -26,7 +30,6 @@ describe Puppet::Resource::Catalog::Compiler do
       Puppet::Node.indirection.save(Puppet::Node.new("node1"))
       Puppet::Node.indirection.save(Puppet::Node.new("node2"))
 
-      compiler = Puppet::Resource::Catalog::Compiler.new
       compiler.stubs(:compile)
 
       compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node1', nil, :node => 'node1'))
@@ -38,81 +41,78 @@ describe Puppet::Resource::Catalog::Compiler do
     before do
       Facter.stubs(:value).returns("whatever")
 
-      @compiler = Puppet::Resource::Catalog::Compiler.new
-      @name = "me"
-      @node = Puppet::Node.new @name
-      @node.stubs(:merge)
-      Puppet::Node.indirection.stubs(:find).returns @node
-      @request = Puppet::Indirector::Request.new(:catalog, :find, @name, nil, :node => @name)
+      node.stubs(:merge)
+      Puppet::Node.indirection.stubs(:find).returns(node)
+      @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil, :node => node_name)
     end
 
     it "should directly use provided nodes for a local request" do
       Puppet::Node.indirection.expects(:find).never
-      @compiler.expects(:compile).with(@node, anything)
-      @request.stubs(:options).returns(:use_node => @node)
+      compiler.expects(:compile).with(node, anything)
+      @request.stubs(:options).returns(:use_node => node)
       @request.stubs(:remote?).returns(false)
-      @compiler.find(@request)
+      compiler.find(@request)
     end
 
     it "rejects a provided node if the request is remote" do
-      @request.stubs(:options).returns(:use_node => @node)
+      @request.stubs(:options).returns(:use_node => node)
       @request.stubs(:remote?).returns(true)
       expect {
-        @compiler.find(@request)
+        compiler.find(@request)
       }.to raise_error Puppet::Error, /invalid option use_node/i
     end
 
     it "should use the authenticated node name if no request key is provided" do
       @request.stubs(:key).returns(nil)
-      Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
-      @compiler.expects(:compile).with(@node, anything)
-      @compiler.find(@request)
+      Puppet::Node.indirection.expects(:find).with(node_name, anything).returns(node)
+      compiler.expects(:compile).with(node, anything)
+      compiler.find(@request)
     end
 
     it "should use the provided node name by default" do
       @request.expects(:key).returns "my_node"
 
-      Puppet::Node.indirection.expects(:find).with("my_node", anything).returns @node
-      @compiler.expects(:compile).with(@node, anything)
-      @compiler.find(@request)
+      Puppet::Node.indirection.expects(:find).with("my_node", anything).returns node
+      compiler.expects(:compile).with(node, anything)
+      compiler.find(@request)
     end
 
     it "should fail if no node is passed and none can be found" do
-      Puppet::Node.indirection.stubs(:find).with(@name, anything).returns(nil)
-      expect { @compiler.find(@request) }.to raise_error(ArgumentError)
+      Puppet::Node.indirection.stubs(:find).with(node_name, anything).returns(nil)
+      expect { compiler.find(@request) }.to raise_error(ArgumentError)
     end
 
     it "should fail intelligently when searching for a node raises an exception" do
-      Puppet::Node.indirection.stubs(:find).with(@name, anything).raises "eh"
-      expect { @compiler.find(@request) }.to raise_error(Puppet::Error)
+      Puppet::Node.indirection.stubs(:find).with(node_name, anything).raises "eh"
+      expect { compiler.find(@request) }.to raise_error(Puppet::Error)
     end
 
     it "should pass the found node to the compiler for compiling" do
-      Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
+      Puppet::Node.indirection.expects(:find).with(node_name, anything).returns(node)
       config = mock 'config'
-      Puppet::Parser::Compiler.expects(:compile).with(@node, anything)
-      @compiler.find(@request)
+      Puppet::Parser::Compiler.expects(:compile).with(node, anything)
+      compiler.find(@request)
     end
 
     it "should pass node containing percent character to the compiler" do
       node_with_percent_character = Puppet::Node.new "%6de"
       Puppet::Node.indirection.stubs(:find).returns(node_with_percent_character)
       Puppet::Parser::Compiler.expects(:compile).with(node_with_percent_character, anything)
-      @compiler.find(@request)
+      compiler.find(@request)
     end
 
-    it "should extract and save any facts from the request" do
-      Puppet::Node.indirection.expects(:find).with(@name, anything).returns @node
-      @compiler.expects(:extract_facts_from_request).with(@request)
+    it "should extract any facts from the request" do
+      Puppet::Node.indirection.expects(:find).with(node_name, anything).returns node
+      compiler.expects(:extract_facts_from_request).with(@request)
       Puppet::Parser::Compiler.stubs(:compile)
-      @compiler.find(@request)
+      compiler.find(@request)
     end
 
     it "requires `facts_format` option if facts are passed in" do
       facts = Puppet::Node::Facts.new("mynode", :afact => "avalue")
       request = Puppet::Indirector::Request.new(:catalog, :find, "mynode", nil, :facts => facts)
       expect {
-        @compiler.find(request)
+        compiler.find(request)
       }.to raise_error ArgumentError, /no fact format provided for mynode/
     end
 
@@ -122,226 +122,253 @@ describe Puppet::Resource::Catalog::Compiler do
         :catalog, :find, "mynode", nil, :facts => facts, :facts_format => "unused"
       )
       expect {
-        @compiler.find(request)
+        compiler.find(request)
       }.to raise_error Puppet::Error, /fact definition for the wrong node/i
     end
 
     it "should return the results of compiling as the catalog" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
-      catalog = Puppet::Resource::Catalog.new(@node.name)
+      Puppet::Node.indirection.stubs(:find).returns(node)
+      catalog = Puppet::Resource::Catalog.new(node.name)
       Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      expect(@compiler.find(@request)).to equal(catalog)
+      expect(compiler.find(@request)).to equal(catalog)
     end
 
     it "passes the code_id from the request to the compiler" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
       @request.options[:code_id] = code_id
 
       Puppet::Parser::Compiler.expects(:compile).with(anything, code_id)
 
-      @compiler.find(@request)
+      compiler.find(@request)
     end
 
     it "returns a catalog with the code_id from the request" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
       @request.options[:code_id] = code_id
 
-      catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment, code_id)
+      catalog = Puppet::Resource::Catalog.new(node.name, node.environment, code_id)
       Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      expect(@compiler.find(@request).code_id).to eq(code_id)
+      expect(compiler.find(@request).code_id).to eq(code_id)
     end
 
     it "does not inline metadata when the static_catalog option is false" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = false
       @request.options[:code_id] = 'some_code_id'
-      @node.environment.stubs(:static_catalogs?).returns true
+      node.environment.stubs(:static_catalogs?).returns true
 
-      catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment)
+      catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
       Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      @compiler.expects(:inline_metadata).never
-      @compiler.find(@request)
+      compiler.expects(:inline_metadata).never
+      compiler.find(@request)
     end
 
     it "does not inline metadata when static_catalogs are disabled" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
       @request.options[:checksum_type] = 'md5'
       @request.options[:code_id] = 'some_code_id'
-      @node.environment.stubs(:static_catalogs?).returns false
+      node.environment.stubs(:static_catalogs?).returns false
 
-      catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment)
+      catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
       Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      @compiler.expects(:inline_metadata).never
-      @compiler.find(@request)
+      compiler.expects(:inline_metadata).never
+      compiler.find(@request)
     end
 
     it "does not inline metadata when code_id is not specified" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
       @request.options[:checksum_type] = 'md5'
-      @node.environment.stubs(:static_catalogs?).returns true
+      node.environment.stubs(:static_catalogs?).returns true
 
-      catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment)
+      catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
       Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      @compiler.expects(:inline_metadata).never
-      expect(@compiler.find(@request)).to eq(catalog)
+      compiler.expects(:inline_metadata).never
+      expect(compiler.find(@request)).to eq(catalog)
     end
 
     it "inlines metadata when the static_catalog option is true, static_catalogs are enabled, and a code_id is provided" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
       @request.options[:checksum_type] = 'sha256'
       @request.options[:code_id] = 'some_code_id'
-      @node.environment.stubs(:static_catalogs?).returns true
+      node.environment.stubs(:static_catalogs?).returns true
 
-      catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment)
+      catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
       Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      @compiler.expects(:inline_metadata).with(catalog, :sha256).returns catalog
-      @compiler.find(@request)
+      compiler.expects(:inline_metadata).with(catalog, :sha256).returns catalog
+      compiler.find(@request)
     end
 
     it "inlines metadata with the first common checksum type" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
       @request.options[:checksum_type] = 'atime.md5.sha256.mtime'
       @request.options[:code_id] = 'some_code_id'
-      @node.environment.stubs(:static_catalogs?).returns true
+      node.environment.stubs(:static_catalogs?).returns true
 
-      catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment)
+      catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
       Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      @compiler.expects(:inline_metadata).with(catalog, :md5).returns catalog
-      @compiler.find(@request)
+      compiler.expects(:inline_metadata).with(catalog, :md5).returns catalog
+      compiler.find(@request)
     end
 
     it "errors if checksum_type contains no shared checksum types" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
       @request.options[:checksum_type] = 'atime.sha512'
       @request.options[:code_id] = 'some_code_id'
-      @node.environment.stubs(:static_catalogs?).returns true
+      node.environment.stubs(:static_catalogs?).returns true
 
-      expect { @compiler.find(@request) }.to raise_error Puppet::Error,
+      expect { compiler.find(@request) }.to raise_error Puppet::Error,
         "Unable to find a common checksum type between agent 'atime.sha512' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :mtime, :ctime, :none]'."
     end
 
     it "errors if checksum_type contains no shared checksum types" do
-      Puppet::Node.indirection.stubs(:find).returns(@node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
       @request.options[:checksum_type] = nil
       @request.options[:code_id] = 'some_code_id'
-      @node.environment.stubs(:static_catalogs?).returns true
+      node.environment.stubs(:static_catalogs?).returns true
 
-      expect { @compiler.find(@request) }.to raise_error Puppet::Error,
+      expect { compiler.find(@request) }.to raise_error Puppet::Error,
         "Unable to find a common checksum type between agent '' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :mtime, :ctime, :none]'."
     end
   end
 
-  describe "when extracting facts from the request" do
+  describe "when handling a request with facts" do
     before do
       Puppet::Node::Facts.indirection.terminus_class = :memory
       Facter.stubs(:value).returns "something"
-      @compiler = Puppet::Resource::Catalog::Compiler.new
 
       @facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
     end
 
-    def a_request_that_contains(facts, format = :pson)
+    def a_legacy_request_that_contains(facts, format = :pson)
       request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
       request.options[:facts_format] = format.to_s
-      request.options[:facts] = Puppet::Util.uri_encode(facts.render(format))
+      request.options[:facts] = Puppet::Util.uri_query_encode(facts.render(format))
       request
     end
 
-    it "should do nothing if no facts are provided" do
+    def a_request_that_contains(facts)
       request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
-      request.options[:facts] = nil
-
-      expect(@compiler.extract_facts_from_request(request)).to be_nil
+      request.options[:facts_format] = "application/json"
+      request.options[:facts] = Puppet::Util.uri_query_encode(facts.render('json'))
+      request
     end
 
-    it "should deserialize the facts without changing the timestamp" do
-      time = Time.now
-      @facts.timestamp = time
-      request = a_request_that_contains(@facts)
-      facts = @compiler.extract_facts_from_request(request)
-      expect(facts.timestamp).to eq(time)
-    end
+    context "when extracting facts from the request" do
+      it "should do nothing if no facts are provided" do
+        request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
+        request.options[:facts] = nil
 
-    it "accepts PSON facts" do
-      request = a_request_that_contains(@facts)
+        expect(compiler.extract_facts_from_request(request)).to be_nil
+      end
 
-      options = {
-        :environment => request.environment,
-        :transaction_uuid => request.options[:transaction_uuid],
-      }
+      it "should deserialize the facts without changing the timestamp" do
+        time = Time.now
+        @facts.timestamp = time
+        request = a_request_that_contains(@facts)
+        facts = compiler.extract_facts_from_request(request)
+        expect(facts.timestamp).to eq(time)
+      end
 
-      Puppet::Node::Facts.indirection.expects(:save).with(equals(@facts), nil, options)
+      it "accepts PSON facts from older agents" do
+        request = a_legacy_request_that_contains(@facts)
 
-      @compiler.extract_facts_from_request(request)
-    end
+        options = {
+          :environment => request.environment,
+          :transaction_uuid => request.options[:transaction_uuid],
+        }
+        facts = compiler.extract_facts_from_request(request)
+        expect(facts).to eq(@facts)
+      end
 
-    it "rejects YAML facts" do
-      request = a_request_that_contains(@facts, :yaml)
+      it "rejects YAML facts" do
+        request = a_legacy_request_that_contains(@facts, :yaml)
 
-      options = {
-        :environment => request.environment,
-        :transaction_uuid => request.options[:transaction_uuid],
-      }
+        options = {
+          :environment => request.environment,
+          :transaction_uuid => request.options[:transaction_uuid],
+        }
 
-      expect {
-        @compiler.extract_facts_from_request(request)
-      }.to raise_error(ArgumentError, /Unsupported facts format/)
-    end
+        expect {
+          compiler.extract_facts_from_request(request)
+        }.to raise_error(ArgumentError, /Unsupported facts format/)
+      end
 
-    it "rejects unknown fact formats" do
-      request = a_request_that_contains(@facts)
-      request.options[:facts_format] = 'unknown-format'
+      it "rejects unknown fact formats" do
+        request = a_request_that_contains(@facts)
+        request.options[:facts_format] = 'unknown-format'
 
-      options = {
-        :environment => request.environment,
-        :transaction_uuid => request.options[:transaction_uuid],
-      }
+        options = {
+          :environment => request.environment,
+          :transaction_uuid => request.options[:transaction_uuid],
+        }
 
-      expect {
-        @compiler.extract_facts_from_request(request)
-      }.to raise_error(ArgumentError, /Unsupported facts format/)
+        expect {
+          compiler.extract_facts_from_request(request)
+        }.to raise_error(ArgumentError, /Unsupported facts format/)
+      end
     end
 
+    context "when saving facts from the request" do
+      it "should save facts if they were issued by the request" do
+        request = a_request_that_contains(@facts)
+
+        options = {
+          :environment => request.environment,
+          :transaction_uuid => request.options[:transaction_uuid],
+        }
+
+        Puppet::Node::Facts.indirection.expects(:save).with(equals(@facts), nil, options)
+        compiler.find(request)
+      end
+
+      it "should skip saving facts if none were supplied" do
+        request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
+
+        options = {
+          :environment => request.environment,
+          :transaction_uuid => request.options[:transaction_uuid],
+        }
+
+        Puppet::Node::Facts.indirection.expects(:save).with(equals(@facts), nil, options).never
+        compiler.find(request)
+      end
+    end
   end
 
   describe "when finding nodes" do
     it "should look node information up via the Node class with the provided key" do
       Facter.stubs(:value).returns("whatever")
-      node = Puppet::Node.new('node')
-      compiler = Puppet::Resource::Catalog::Compiler.new
-      request = Puppet::Indirector::Request.new(:catalog, :find, "me", nil)
+      request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
       compiler.stubs(:compile)
 
-      Puppet::Node.indirection.expects(:find).with("me", anything).returns(node)
+      Puppet::Node.indirection.expects(:find).with(node_name, anything).returns(node)
 
       compiler.find(request)
     end
 
     it "should pass the transaction_uuid to the node indirection" do
       uuid = '793ff10d-89f8-4527-a645-3302cbc749f3'
-      node = Puppet::Node.new("thing")
-      compiler = Puppet::Resource::Catalog::Compiler.new
       compiler.stubs(:compile)
-      request = Puppet::Indirector::Request.new(:catalog, :find, "thing",
+      request = Puppet::Indirector::Request.new(:catalog, :find, node_name,
                                                 nil, :transaction_uuid => uuid)
 
       Puppet::Node.indirection.expects(:find).with(
-        "thing",
+        node_name,
         has_entries(:transaction_uuid => uuid)
       ).returns(node)
 
@@ -350,19 +377,31 @@ describe Puppet::Resource::Catalog::Compiler do
 
     it "should pass the configured_environment to the node indirection" do
       environment = 'foo'
-      node = Puppet::Node.new("thing")
-      compiler = Puppet::Resource::Catalog::Compiler.new
       compiler.stubs(:compile)
-      request = Puppet::Indirector::Request.new(:catalog, :find, "thing",
+      request = Puppet::Indirector::Request.new(:catalog, :find, node_name,
                                                 nil, :configured_environment => environment)
 
       Puppet::Node.indirection.expects(:find).with(
-        "thing",
+        node_name,
         has_entries(:configured_environment => environment)
       ).returns(node)
 
       compiler.find(request)
     end
+
+    it "should pass a facts object from the original request facts to the node indirection" do
+      facts = Puppet::Node::Facts.new("hostname", :afact => "avalue")
+      compiler.expects(:extract_facts_from_request).returns(facts)
+      compiler.expects(:save_facts_from_request)
+
+      request = Puppet::Indirector::Request.new(:catalog, :find, "hostname",
+                                                nil, :facts_format => "application/json",
+                                                :facts => facts.render('json'))
+
+      Puppet::Node.indirection.expects(:find).with("hostname", has_entries(:facts => facts)).returns(node)
+
+      compiler.find(request)
+    end
   end
 
   describe "after finding nodes" do
@@ -370,60 +409,57 @@ describe Puppet::Resource::Catalog::Compiler do
       Puppet.expects(:version).returns(1)
       Facter.expects(:value).with('fqdn').returns("my.server.com")
       Facter.expects(:value).with('ipaddress').returns("my.ip.address")
-      @compiler = Puppet::Resource::Catalog::Compiler.new
-      @node = Puppet::Node.new("me")
-      @request = Puppet::Indirector::Request.new(:catalog, :find, "me", nil)
-      @compiler.stubs(:compile)
-      Puppet::Node.indirection.stubs(:find).with("me", anything).returns(@node)
+      @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
+      compiler.stubs(:compile)
+      Puppet::Node.indirection.stubs(:find).with(node_name, anything).returns(node)
     end
 
     it "should add the server's Puppet version to the node's parameters as 'serverversion'" do
-      @node.expects(:merge).with { |args| args["serverversion"] == "1" }
-      @compiler.find(@request)
+      node.expects(:merge).with { |args| args["serverversion"] == "1" }
+      compiler.find(@request)
     end
 
     it "should add the server's fqdn to the node's parameters as 'servername'" do
-      @node.expects(:merge).with { |args| args["servername"] == "my.server.com" }
-      @compiler.find(@request)
+      node.expects(:merge).with { |args| args["servername"] == "my.server.com" }
+      compiler.find(@request)
     end
 
     it "should add the server's IP address to the node's parameters as 'serverip'" do
-      @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" }
-      @compiler.find(@request)
+      node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" }
+      compiler.find(@request)
     end
   end
 
   describe "when filtering resources" do
     before :each do
       Facter.stubs(:value)
-      @compiler = Puppet::Resource::Catalog::Compiler.new
       @catalog = stub_everything 'catalog'
       @catalog.stubs(:respond_to?).with(:filter).returns(true)
     end
 
     it "should delegate to the catalog instance filtering" do
       @catalog.expects(:filter)
-      @compiler.filter(@catalog)
+      compiler.filter(@catalog)
     end
 
     it "should filter out virtual resources" do
       resource = mock 'resource', :virtual? => true
       @catalog.stubs(:filter).yields(resource)
 
-      @compiler.filter(@catalog)
+      compiler.filter(@catalog)
     end
 
     it "should return the same catalog if it doesn't support filtering" do
       @catalog.stubs(:respond_to?).with(:filter).returns(false)
 
-      expect(@compiler.filter(@catalog)).to eq(@catalog)
+      expect(compiler.filter(@catalog)).to eq(@catalog)
     end
 
     it "should return the filtered catalog" do
       catalog = stub 'filtered catalog'
       @catalog.stubs(:filter).returns(catalog)
 
-      expect(@compiler.filter(@catalog)).to eq(catalog)
+      expect(compiler.filter(@catalog)).to eq(catalog)
     end
 
   end
@@ -437,10 +473,6 @@ describe Puppet::Resource::Catalog::Compiler do
     let(:path) { File.expand_path('/foo') }
     let(:source) { 'puppet:///modules/mymodule/config_file.txt' }
 
-    before :each do
-      @compiler = Puppet::Resource::Catalog::Compiler.new
-    end
-
     def stubs_resource_metadata(ftype, relative_path, full_path = nil)
       full_path ||=  File.join(Puppet[:environmentpath], 'production', relative_path)
 
@@ -494,7 +526,7 @@ describe Puppet::Resource::Catalog::Compiler do
       }
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, options).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
 
       expect(catalog.metadata[path]).to eq(metadata)
       expect(catalog.recursive_metadata).to be_empty
@@ -522,7 +554,7 @@ describe Puppet::Resource::Catalog::Compiler do
       }
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, options).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
 
       expect(catalog.metadata[path]).to eq(metadata)
       expect(catalog.recursive_metadata).to be_empty
@@ -553,7 +585,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, options).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
     end
 
     it "inlines metadata for the first source found" do
@@ -571,7 +603,7 @@ describe Puppet::Resource::Catalog::Compiler do
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
       Puppet::FileServing::Metadata.indirection.expects(:find).with(alt_source, anything).returns(nil)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
 
       expect(catalog.metadata[path]).to eq(metadata)
       expect(catalog.recursive_metadata).to be_empty
@@ -598,7 +630,7 @@ describe Puppet::Resource::Catalog::Compiler do
           }
           Puppet::FileServing::Metadata.indirection.expects(:find).with(source, options).returns(metadata)
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
 
           expect(catalog.metadata[path]).to eq(metadata)
           expect(catalog.recursive_metadata).to be_empty
@@ -623,7 +655,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
     end
 
     it "skips absent resources" do
@@ -633,7 +665,7 @@ describe Puppet::Resource::Catalog::Compiler do
         }
       MANIFEST
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -645,7 +677,7 @@ describe Puppet::Resource::Catalog::Compiler do
         }
       MANIFEST
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -660,7 +692,7 @@ describe Puppet::Resource::Catalog::Compiler do
         }
       MANIFEST
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -673,7 +705,7 @@ describe Puppet::Resource::Catalog::Compiler do
         }
       MANIFEST
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -690,7 +722,7 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/files/config_file.txt', full_path)
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -708,7 +740,7 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'secure/files/data.txt')
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -724,7 +756,7 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/not_in_files/config_file.txt')
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -741,7 +773,7 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules//files/config_file.txt')
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -763,7 +795,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata[path]).to eq(metadata)
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -785,7 +817,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata[path]).to eq(metadata)
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -806,7 +838,7 @@ describe Puppet::Resource::Catalog::Compiler do
           metadata.expects(:content_uri=).with('puppet:///modules/mymodule/files/directory')
           Puppet::FileServing::Metadata.indirection.expects(:find).with(source_dir, anything).returns(metadata)
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
 
           expect(catalog.metadata[path]).to eq(metadata)
           expect(catalog.recursive_metadata).to be_empty
@@ -839,7 +871,7 @@ describe Puppet::Resource::Catalog::Compiler do
           }
           Puppet::FileServing::Metadata.indirection.expects(:search).with(source_dir, options).returns([metadata, child_metadata])
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
 
           expect(catalog.metadata[path]).to be_nil
           expect(catalog.recursive_metadata[path][source_dir]).to eq([metadata, child_metadata])
@@ -870,7 +902,7 @@ describe Puppet::Resource::Catalog::Compiler do
           }
           Puppet::FileServing::Metadata.indirection.expects(:search).with(source_dir, options).returns([metadata, child_metadata])
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
 
           expect(catalog.metadata[path]).to be_nil
           expect(catalog.recursive_metadata[path][source_dir]).to eq([metadata, child_metadata])
@@ -890,7 +922,7 @@ describe Puppet::Resource::Catalog::Compiler do
           Puppet::FileServing::Metadata.indirection.expects(:search).with(source_dir, anything).returns([metadata, child_metadata])
           Puppet::FileServing::Metadata.indirection.expects(:search).with(alt_source_dir, anything).returns([metadata, child_metadata])
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
 
           expect(catalog.metadata[path]).to be_nil
           expect(catalog.recursive_metadata[path][source_dir]).to eq([metadata, child_metadata])
@@ -910,7 +942,7 @@ describe Puppet::Resource::Catalog::Compiler do
           Puppet::FileServing::Metadata.indirection.expects(:search).with(source_dir, anything).returns(nil)
           Puppet::FileServing::Metadata.indirection.expects(:search).with(alt_source_dir, anything).returns([metadata, child_metadata])
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
 
           expect(catalog.metadata[path]).to be_nil
           expect(catalog.recursive_metadata[path][source_dir]).to be_nil
@@ -933,7 +965,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
           Puppet::FileServing::Metadata.indirection.expects(:search).with(source, anything).returns([metadata])
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
           expect(catalog.metadata).to be_empty
           expect(catalog.recursive_metadata).to be_empty
         end
@@ -952,7 +984,7 @@ describe Puppet::Resource::Catalog::Compiler do
           metadata = stubs_directory_metadata('modules/mymodule/not_in_files/directory')
           Puppet::FileServing::Metadata.indirection.expects(:search).with(source, anything).returns([metadata])
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
           expect(catalog.metadata).to be_empty
           expect(catalog.recursive_metadata).to be_empty
         end
@@ -978,7 +1010,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
           Puppet::FileServing::Metadata.indirection.expects(:search).with(source, anything).returns([dir_metadata, child_metadata])
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
           expect(catalog.metadata).to be_empty
           expect(catalog.recursive_metadata[path][source]).to eq([dir_metadata, child_metadata])
         end
@@ -1002,7 +1034,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
           Puppet::FileServing::Metadata.indirection.expects(:search).with(source, anything).returns([dir_metadata, child_metadata])
 
-          @compiler.send(:inline_metadata, catalog, checksum_type)
+          compiler.send(:inline_metadata, catalog, checksum_type)
 
           expect(catalog.metadata).to be_empty
           expect(catalog.recursive_metadata[path][source]).to eq([dir_metadata, child_metadata])
@@ -1015,7 +1047,7 @@ describe Puppet::Resource::Catalog::Compiler do
         notify { 'hi': }
       MANIFEST
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
       expect(catalog.recursive_metadata).to be_empty
     end
@@ -1031,7 +1063,7 @@ describe Puppet::Resource::Catalog::Compiler do
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/files/config_file.txt')
       Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
-      @compiler.send(:inline_metadata, catalog, checksum_type)
+      compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata['c:/foo']).to eq(metadata)
       expect(catalog.recursive_metadata).to be_empty
     end