puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

data/spec/unit/gettext/config_spec.rb

@@ -19,7 +19,7 @@ describe Puppet::GettextConfig do
   end
 
   before(:each) do
-    allow(Puppet::GettextConfig).to receive(:gettext_loaded?).and_return(true)
+    Puppet::GettextConfig.stubs(:gettext_loaded?).returns true
   end
 
   after(:each) do
@@ -29,7 +29,7 @@ describe Puppet::GettextConfig do
 
   describe 'setting and getting the locale' do
     it 'should return "en" when gettext is unavailable' do
-      allow(Puppet::GettextConfig).to receive(:gettext_loaded?).and_return(false)
+      Puppet::GettextConfig.stubs(:gettext_loaded?).returns(false)
 
       expect(Puppet::GettextConfig.current_locale).to eq('en')
     end
@@ -67,7 +67,7 @@ describe Puppet::GettextConfig do
 
     context 'when given a valid locale file location' do
       it 'should return true' do
-        expect(Puppet::GettextConfig).to receive(:add_repository_to_domain).with('puppet', local_path, :po, anything)
+        Puppet::GettextConfig.expects(:add_repository_to_domain).with('puppet', local_path, :po, anything)
 
         expect(Puppet::GettextConfig.load_translations('puppet', local_path, :po)).to be true
       end
@@ -88,7 +88,7 @@ describe Puppet::GettextConfig do
     end
 
     it 'should add puppet translations to the default text domain' do
-      expect(Puppet::GettextConfig).to receive(:load_translations).with('puppet', local_path, :po, Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN).and_return(true)
+      Puppet::GettextConfig.expects(:load_translations).with('puppet', local_path, :po, Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN).returns(true)
 
       Puppet::GettextConfig.create_default_text_domain
       expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN)

data/spec/unit/gettext/module_loading_spec.rb

@@ -16,7 +16,7 @@ describe Puppet::ModuleTranslations do
       :metadata => {
         :author => 'foo'
       },
-      :environment => double("environment"))
+      :environment => mock("environment"))
     }
 
     let(:module_b) { PuppetSpec::Modules.create(
@@ -25,13 +25,13 @@ describe Puppet::ModuleTranslations do
       :metadata => {
         :author => 'foo'
       },
-      :environment => double("environment"))
+      :environment => mock("environment"))
     }
 
     it "should attempt to load translations only for modules that have them" do
-      expect(module_a).to receive(:has_translations?).and_return(false)
-      expect(module_b).to receive(:has_translations?).and_return(true)
-      expect(Puppet::GettextConfig).to receive(:load_translations).with("foo-mod_b", File.join(modpath, "mod_b", "locales"), :po).and_return(true)
+      module_a.expects(:has_translations?).returns(false)
+      module_b.expects(:has_translations?).returns(true)
+      Puppet::GettextConfig.expects(:load_translations).with("foo-mod_b", File.join(modpath, "mod_b", "locales"), :po).returns(true)
 
       Puppet::ModuleTranslations.load_from_modulepath([module_a, module_b])
     end
@@ -44,8 +44,8 @@ describe Puppet::ModuleTranslations do
     }
 
     it "should attempt to load translations for the current locale" do
-      expect(Puppet::GettextConfig).to receive(:current_locale).and_return("ja")
-      expect(Puppet::GettextConfig).to receive(:load_translations).with("foo-mod_a", File.join(vardir, "locales"), :po).and_return(true)
+      Puppet::GettextConfig.expects(:current_locale).returns("ja")
+      Puppet::GettextConfig.expects(:load_translations).with("foo-mod_a", File.join(vardir, "locales"), :po).returns(true)
 
       Puppet::ModuleTranslations.load_from_vardir(vardir)
     end

data/spec/unit/graph/rb_tree_map_spec.rb

@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 
 require 'puppet/graph'

data/spec/unit/graph/relationship_graph_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/graph'
 
@@ -396,6 +397,6 @@ describe Puppet::Graph::RelationshipGraph do
   end
 
   def stub_vertex(name)
-    double("vertex #{name}", :ref => name)
+    stub "vertex #{name}", :ref => name
   end
 end

data/spec/unit/graph/simple_graph_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/graph'
 
@@ -80,6 +81,22 @@ describe Puppet::Graph::SimpleGraph do
     it "should do nothing when a non-vertex is asked to be removed" do
       expect { @graph.remove_vertex!(:one) }.to_not raise_error
     end
+
+    describe "when managing resources with quotes in their title" do
+      subject do
+        v = Puppet::Type.type(:notify).new(:name => 'GRANT ALL ON DATABASE "puppetdb" TO "puppetdb"')
+        @graph.add_vertex(v)
+        @graph.to_dot
+      end
+
+      it "should escape quotes in node name" do
+        expect(subject).to match(/^[[:space:]]{4}"Notify\[GRANT ALL ON DATABASE \\"puppetdb\\" TO \\"puppetdb\\"\]" \[$/)
+      end
+
+      it "should escape quotes in node label" do
+        expect(subject).to match(/^[[:space:]]{8}label = "Notify\[GRANT ALL ON DATABASE \\"puppetdb\\" TO \\"puppetdb\\"\]"$/)
+      end
+    end
   end
 
   describe "when managing edges" do
@@ -113,6 +130,23 @@ describe Puppet::Graph::SimpleGraph do
       expect(@graph.edge?(:one, :two)).to be_truthy
     end
 
+    describe "when managing edges between nodes with quotes in their title" do
+      let(:vertex) do
+        Hash.new do |hash, key|
+          hash[key] = Puppet::Type.type(:notify).new(:name => key.to_s)
+        end
+      end
+
+      subject do
+        @graph.add_edge(vertex['Postgresql_psql[CREATE DATABASE "ejabberd"]'], vertex['Postgresql_psql[REVOKE CONNECT ON DATABASE "ejabberd" FROM public]'])
+        @graph.to_dot
+      end
+
+      it "should escape quotes in edge" do
+        expect(subject).to match(/^[[:space:]]{4}"Notify\[Postgresql_psql\[CREATE DATABASE \\"ejabberd\\"\]\]" -> "Notify\[Postgresql_psql\[REVOKE CONNECT ON DATABASE \\"ejabberd\\" FROM public\]\]" \[$/)
+      end
+    end
+
     describe "when retrieving edges between two nodes" do
       it "should handle the case of nodes not in the graph" do
         expect(@graph.edges_between(:one, :two)).to eq([])
@@ -301,30 +335,37 @@ describe Puppet::Graph::SimpleGraph do
       end
     end
 
+    it "should report one-vertex loops" do
+      add_edges :a => :a
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[a\]\)/))
+      cycle = @graph.report_cycles_in_graph.first
+      expect_cycle_to_include(cycle, :a)
+    end
+
     it "should report two-vertex loops" do
       add_edges :a => :b, :b => :a
-      expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/)
+      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 report multi-vertex loops" do
       add_edges :a => :b, :b => :c, :c => :a
-      expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[c\] => Notify\[a\]\)/)
+      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 report when a larger tree contains a small cycle" do
       add_edges :a => :b, :b => :a, :c => :a, :d => :c
-      expect(Puppet).to receive(:err).with(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/)
+      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(Puppet).not_to receive(:err)
+      Puppet.expects(:err).never
       expect(@graph.report_cycles_in_graph).to be_nil
     end
 
@@ -428,14 +469,14 @@ describe Puppet::Graph::SimpleGraph do
     end
 
     it "should only write when graphing is enabled" do
-      expect(File).not_to receive(:open).with(@file)
+      File.expects(:open).with(@file).never
       Puppet[:graph] = false
       @graph.write_graph(@name)
     end
 
     it "should write a dot file based on the passed name" do
-      expect(File).to receive(:open).with(@file, "w:UTF-8").and_yield(double("file", :puts => nil))
-      expect(@graph).to receive(:to_dot).with("name" => @name.to_s.capitalize)
+      File.expects(:open).with(@file, "w:UTF-8").yields(stub("file", :puts => nil))
+      @graph.expects(:to_dot).with("name" => @name.to_s.capitalize)
       Puppet[:graph] = true
       @graph.write_graph(@name)
     end
@@ -463,7 +504,7 @@ describe Puppet::Graph::SimpleGraph do
       # because indexing a String with a non-Integer throws an exception (and none of
       # these tests need anything meaningful from []).
       resource = "a"
-      allow(resource).to receive(:[])
+      resource.stubs(:[])
       @event = Puppet::Transaction::Event.new(:name => :yay, :resource => resource)
       @none = Puppet::Transaction::Event.new(:name => :NONE, :resource => resource)
 
@@ -595,7 +636,7 @@ describe Puppet::Graph::SimpleGraph do
           # the serialized objects easily without invoking any
           # yaml_initialize hooks.
           yaml_form.gsub!('!ruby/object:Puppet::', '!hack/object:Puppet::')
-          serialized_object = YAML.load(yaml_form)
+          serialized_object = Puppet::Util::Yaml.safe_load(yaml_form, [Symbol,Puppet::Graph::SimpleGraph])
 
           # Check that the object contains instance variables @edges and
           # @vertices only.  @reversal is also permitted, but we don't
@@ -663,7 +704,7 @@ describe Puppet::Graph::SimpleGraph do
           reference_graph = Puppet::Graph::SimpleGraph.new
           send(graph_to_test, reference_graph)
           yaml_form = graph_to_yaml(reference_graph, which_format)
-          recovered_graph = YAML.load(yaml_form)
+          recovered_graph = Puppet::Util::Yaml.safe_load(yaml_form, [Symbol,Puppet::Graph::SimpleGraph])
 
           # Test that the recovered vertices match the vertices in the
           # reference graph.
@@ -707,7 +748,7 @@ describe Puppet::Graph::SimpleGraph do
       derived.add_edge('a', 'b')
       derived.foo = 1234
       yaml = YAML.dump(derived)
-      recovered_derived = YAML.load(yaml)
+      recovered_derived = Puppet::Util::Yaml.safe_load(yaml, [Puppet::TestDerivedClass])
       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')

data/spec/unit/hiera/scope_spec.rb

@@ -90,11 +90,4 @@ describe Hiera::Scope do
       expect(scope.include?("calling_module")).to eq(true)
     end
   end
-
-  describe "#call_function" do
-    it "should delegate a call to call_function to the real scope" do
-      expect(real).to receive(:call_function).once
-      scope.call_function('some_function', [1,2,3])
-    end
-  end
 end

data/spec/unit/hiera_puppet_spec.rb

@@ -16,8 +16,8 @@ describe 'HieraPuppet' do
 
     context "when the hiera_config_file exists" do
       before do
-        expect(Hiera::Config).to receive(:load).and_return(hiera_config_data)
-        expect(HieraPuppet).to receive(:hiera_config_file).and_return(true)
+        Hiera::Config.expects(:load).returns(hiera_config_data)
+        HieraPuppet.expects(:hiera_config_file).returns(true)
       end
 
       it "should return a configuration hash" do
@@ -31,8 +31,8 @@ describe 'HieraPuppet' do
 
     context "when the hiera_config_file does not exist" do
       before do
-        expect(Hiera::Config).not_to receive(:load)
-        expect(HieraPuppet).to receive(:hiera_config_file).and_return(nil)
+        Hiera::Config.expects(:load).never
+        HieraPuppet.expects(:hiera_config_file).returns(nil)
       end
 
       it "should return a configuration hash" do
@@ -59,7 +59,7 @@ describe 'HieraPuppet' do
         pending("This example does not apply to Puppet #{Puppet.version} because it does not have this setting")
       end
 
-      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:hiera_config]).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).with(Puppet[:hiera_config]).returns(true)
       expect(HieraPuppet.send(:hiera_config_file)).to eq(Puppet[:hiera_config])
     end
 
@@ -75,29 +75,29 @@ describe 'HieraPuppet' do
       end
 
       it "should use Puppet.settings[:codedir]/hiera.yaml when '$codedir/hiera.yaml' exists and '$confdir/hiera.yaml' does not exist" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(false)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(false)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(code_hiera_config)
       end
 
       it "should use Puppet.settings[:confdir]/hiera.yaml when '$codedir/hiera.yaml' does not exist and '$confdir/hiera.yaml' exists" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(false)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(conf_hiera_config)
       end
 
       it "should use Puppet.settings[:codedir]/hiera.yaml when '$codedir/hiera.yaml' exists and '$confdir/hiera.yaml' exists" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(code_hiera_config)
       end
 
       it "should return nil when neither '$codedir/hiera.yaml' nor '$confdir/hiera.yaml' exists" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(false)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(false)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(false)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(false)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(nil)
       end
@@ -109,9 +109,9 @@ describe 'HieraPuppet' do
           explicit_hiera_config = '/an/explicit/hiera.yaml'
         end
         Puppet.settings[:hiera_config] = explicit_hiera_config
-        allow(Puppet::FileSystem).to receive(:exist?).with(explicit_hiera_config).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(code_hiera_config).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(conf_hiera_config).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(explicit_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(code_hiera_config).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(conf_hiera_config).returns(true)
 
         expect(HieraPuppet.send(:hiera_config_file)).to eq(explicit_hiera_config)
       end
@@ -126,18 +126,18 @@ describe 'HieraPuppet' do
     end
 
     it "should return the value from Hiera" do
-      allow_any_instance_of(Hiera).to receive(:lookup).and_return('8080')
+      Hiera.any_instance.stubs(:lookup).returns('8080')
       expect(HieraPuppet.lookup('port', nil, scope, nil, :priority)).to eq('8080')
 
-      allow_any_instance_of(Hiera).to receive(:lookup).and_return(['foo', 'bar'])
+      Hiera.any_instance.stubs(:lookup).returns(['foo', 'bar'])
       expect(HieraPuppet.lookup('ntpservers', nil, scope, nil, :array)).to eq(['foo', 'bar'])
 
-      allow_any_instance_of(Hiera).to receive(:lookup).and_return({'uid' => '1000'})
+      Hiera.any_instance.stubs(:lookup).returns({'uid' => '1000'})
       expect(HieraPuppet.lookup('user', nil, scope, nil, :hash)).to eq({'uid' => '1000'})
     end
 
     it "should raise a useful error when the answer is nil" do
-      allow_any_instance_of(Hiera).to receive(:lookup).and_return(nil)
+      Hiera.any_instance.stubs(:lookup).returns(nil)
       expect do
         HieraPuppet.lookup('port', nil, scope, nil, :priority)
       end.to raise_error(Puppet::ParseError,

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
@@ -9,9 +10,19 @@ describe Puppet::Resource::Catalog::Compiler do
   let(:node_name) { "foo" }
   let(:node) { Puppet::Node.new(node_name)}
 
+  before do
+    Facter.stubs(:to_hash).returns({})
+  end
+
   describe "when initializing" do
     before do
-      allow(Puppet).to receive(:version).and_return(1)
+      Puppet.expects(:version).returns(1)
+      Facter.expects(:value).with('fqdn').returns("my.server.com")
+      Facter.expects(:value).with('ipaddress').returns("my.ip.address")
+    end
+
+    it "should gather data about itself" do
+      Puppet::Resource::Catalog::Compiler.new
     end
 
     it "should cache the server metadata and reuse it" do
@@ -19,7 +30,7 @@ describe Puppet::Resource::Catalog::Compiler do
       Puppet::Node.indirection.save(Puppet::Node.new("node1"))
       Puppet::Node.indirection.save(Puppet::Node.new("node2"))
 
-      allow(compiler).to receive(:compile)
+      compiler.stubs(:compile)
 
       compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node1', nil, :node => 'node1'))
       compiler.find(Puppet::Indirector::Request.new(:catalog, :find, 'node2', nil, :node => 'node2'))
@@ -28,69 +39,71 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when finding catalogs" do
     before do
-      allow(node).to receive(:merge)
-      allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+      Facter.stubs(:value).returns("whatever")
+
+      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
-      expect(Puppet::Node.indirection).not_to receive(:find)
-      expect(compiler).to receive(:compile).with(node, anything)
-      allow(@request).to receive(:options).and_return(:use_node => node)
-      allow(@request).to receive(:remote?).and_return(false)
+      Puppet::Node.indirection.expects(:find).never
+      compiler.expects(:compile).with(node, anything)
+      @request.stubs(:options).returns(:use_node => node)
+      @request.stubs(:remote?).returns(false)
       compiler.find(@request)
     end
 
     it "rejects a provided node if the request is remote" do
-      allow(@request).to receive(:options).and_return(:use_node => node)
-      allow(@request).to receive(:remote?).and_return(true)
+      @request.stubs(:options).returns(:use_node => node)
+      @request.stubs(:remote?).returns(true)
       expect {
         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
-      allow(@request).to receive(:key).and_return(nil)
-      expect(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
-      expect(compiler).to receive(:compile).with(node, anything)
+      @request.stubs(:key).returns(nil)
+      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
-      expect(@request).to receive(:key).and_return("my_node")
+      @request.expects(:key).returns "my_node"
 
-      expect(Puppet::Node.indirection).to receive(:find).with("my_node", anything).and_return(node)
-      expect(compiler).to receive(:compile).with(node, anything)
+      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
-      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(nil)
+      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
-      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_raise("eh")
+      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
-      expect(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
-      expect(Puppet::Parser::Compiler).to receive(:compile).with(node, anything)
+      Puppet::Node.indirection.expects(:find).with(node_name, anything).returns(node)
+      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"
-      allow(Puppet::Node.indirection).to receive(:find).and_return(node_with_percent_character)
-      expect(Puppet::Parser::Compiler).to receive(:compile).with(node_with_percent_character, anything)
+      Puppet::Node.indirection.stubs(:find).returns(node_with_percent_character)
+      Puppet::Parser::Compiler.expects(:compile).with(node_with_percent_character, anything)
       compiler.find(@request)
     end
 
     it "should extract any facts from the request" do
-      expect(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
-      expect(compiler).to receive(:extract_facts_from_request).with(@request)
-      allow(Puppet::Parser::Compiler).to receive(:compile)
+      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)
     end
 
@@ -113,119 +126,119 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     it "should return the results of compiling as the catalog" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       catalog = Puppet::Resource::Catalog.new(node.name)
-      allow(Puppet::Parser::Compiler).to receive(:compile).and_return(catalog)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
       expect(compiler.find(@request)).to equal(catalog)
     end
 
     it "passes the code_id from the request to the compiler" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
       @request.options[:code_id] = code_id
 
-      expect(Puppet::Parser::Compiler).to receive(:compile).with(anything, code_id)
+      Puppet::Parser::Compiler.expects(:compile).with(anything, code_id)
 
       compiler.find(@request)
     end
 
     it "returns a catalog with the code_id from the request" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(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)
-      allow(Puppet::Parser::Compiler).to receive(:compile).and_return(catalog)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
       expect(compiler.find(@request).code_id).to eq(code_id)
     end
 
     it "does not inline metadata when the static_catalog option is false" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = false
       @request.options[:code_id] = 'some_code_id'
-      allow(node.environment).to receive(:static_catalogs?).and_return(true)
+      node.environment.stubs(:static_catalogs?).returns true
 
       catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
-      allow(Puppet::Parser::Compiler).to receive(:compile).and_return(catalog)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      expect(compiler).not_to receive(:inline_metadata)
+      compiler.expects(:inline_metadata).never
       compiler.find(@request)
     end
 
     it "does not inline metadata when static_catalogs are disabled" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(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'
-      allow(node.environment).to receive(:static_catalogs?).and_return(false)
+      node.environment.stubs(:static_catalogs?).returns false
 
       catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
-      allow(Puppet::Parser::Compiler).to receive(:compile).and_return(catalog)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      expect(compiler).not_to receive(:inline_metadata)
+      compiler.expects(:inline_metadata).never
       compiler.find(@request)
     end
 
     it "does not inline metadata when code_id is not specified" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
       @request.options[:checksum_type] = 'md5'
-      allow(node.environment).to receive(:static_catalogs?).and_return(true)
+      node.environment.stubs(:static_catalogs?).returns true
 
       catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
-      allow(Puppet::Parser::Compiler).to receive(:compile).and_return(catalog)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      expect(compiler).not_to receive(:inline_metadata)
+      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
-      allow(Puppet::Node.indirection).to receive(:find).and_return(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'
-      allow(node.environment).to receive(:static_catalogs?).and_return(true)
+      node.environment.stubs(:static_catalogs?).returns true
 
       catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
-      allow(Puppet::Parser::Compiler).to receive(:compile).and_return(catalog)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      expect(compiler).to receive(:inline_metadata).with(catalog, :sha256).and_return(catalog)
+      compiler.expects(:inline_metadata).with(catalog, :sha256).returns catalog
       compiler.find(@request)
     end
 
     it "inlines metadata with the first common checksum type" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(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'
-      allow(node.environment).to receive(:static_catalogs?).and_return(true)
+      node.environment.stubs(:static_catalogs?).returns true
 
       catalog = Puppet::Resource::Catalog.new(node.name, node.environment)
-      allow(Puppet::Parser::Compiler).to receive(:compile).and_return(catalog)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      expect(compiler).to receive(:inline_metadata).with(catalog, :md5).and_return(catalog)
+      compiler.expects(:inline_metadata).with(catalog, :md5).returns catalog
       compiler.find(@request)
     end
 
     it "errors if checksum_type contains no shared checksum types" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(node)
+      Puppet::Node.indirection.stubs(:find).returns(node)
       @request.options[:static_catalog] = true
       @request.options[:checksum_type] = 'atime.md2'
       @request.options[:code_id] = 'some_code_id'
-      allow(node.environment).to receive(:static_catalogs?).and_return(true)
+      node.environment.stubs(:static_catalogs?).returns true
 
       expect { compiler.find(@request) }.to raise_error Puppet::Error,
         "Unable to find a common checksum type between agent 'atime.md2' and master '[:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, :mtime, :ctime, :none]'."
     end
 
     it "errors if checksum_type contains no shared checksum types" do
-      allow(Puppet::Node.indirection).to receive(:find).and_return(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'
-      allow(node.environment).to receive(:static_catalogs?).and_return(true)
+      node.environment.stubs(:static_catalogs?).returns true
 
       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, :sha512, :sha384, :sha224, :mtime, :ctime, :none]'."
@@ -234,10 +247,10 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when handling a request with facts" do
     before do
-      allow(Facter).to receive(:value).and_return("something")
+      Puppet::Node::Facts.indirection.terminus_class = :memory
+      Facter.stubs(:value).returns "something"
 
-      facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
-      Puppet::Node::Facts.indirection.save(facts)
+      @facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
     end
 
     def a_legacy_request_that_contains(facts, format = :pson)
@@ -255,8 +268,6 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     context "when extracting facts from the request" do
-      let(:facts) { Puppet::Node::Facts.new("hostname") }
-
       it "should do nothing if no facts are provided" do
         request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
         request.options[:facts] = nil
@@ -266,21 +277,21 @@ describe Puppet::Resource::Catalog::Compiler do
 
       it "should deserialize the facts without changing the timestamp" do
         time = Time.now
-        facts.timestamp = time
-        request = a_request_that_contains(facts)
+        @facts.timestamp = time
+        request = a_request_that_contains(@facts)
         facts = compiler.extract_facts_from_request(request)
         expect(facts.timestamp).to eq(time)
       end
 
       it "accepts PSON facts from older agents" do
-        request = a_legacy_request_that_contains(facts)
+        request = a_legacy_request_that_contains(@facts)
 
         facts = compiler.extract_facts_from_request(request)
-        expect(facts).to eq(facts)
+        expect(facts).to eq(@facts)
       end
 
       it "rejects YAML facts" do
-        request = a_legacy_request_that_contains(facts, :yaml)
+        request = a_legacy_request_that_contains(@facts, :yaml)
 
         expect {
           compiler.extract_facts_from_request(request)
@@ -288,7 +299,7 @@ describe Puppet::Resource::Catalog::Compiler do
       end
 
       it "rejects unknown fact formats" do
-        request = a_request_that_contains(facts)
+        request = a_request_that_contains(@facts)
         request.options[:facts_format] = 'unknown-format'
 
         expect {
@@ -298,17 +309,15 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     context "when saving facts from the request" do
-      let(:facts) { Puppet::Node::Facts.new("hostname") }
-
       it "should save facts if they were issued by the request" do
-        request = a_request_that_contains(facts)
+        request = a_request_that_contains(@facts)
 
         options = {
           :environment => request.environment,
           :transaction_uuid => request.options[:transaction_uuid],
         }
 
-        expect(Puppet::Node::Facts.indirection).to receive(:save).with(facts, nil, options)
+        Puppet::Node::Facts.indirection.expects(:save).with(equals(@facts), nil, options)
         compiler.find(request)
       end
 
@@ -320,7 +329,7 @@ describe Puppet::Resource::Catalog::Compiler do
           :transaction_uuid => request.options[:transaction_uuid],
         }
 
-        expect(Puppet::Node::Facts.indirection).not_to receive(:save).with(facts, nil, options)
+        Puppet::Node::Facts.indirection.expects(:save).with(equals(@facts), nil, options).never
         compiler.find(request)
       end
     end
@@ -328,52 +337,53 @@ describe Puppet::Resource::Catalog::Compiler do
 
   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")
       request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
-      allow(compiler).to receive(:compile)
+      compiler.stubs(:compile)
 
-      expect(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(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'
-      allow(compiler).to receive(:compile)
+      compiler.stubs(:compile)
       request = Puppet::Indirector::Request.new(:catalog, :find, node_name,
                                                 nil, :transaction_uuid => uuid)
 
-      expect(Puppet::Node.indirection).to receive(:find).with(
+      Puppet::Node.indirection.expects(:find).with(
         node_name,
-        hash_including(:transaction_uuid => uuid)
-      ).and_return(node)
+        has_entries(:transaction_uuid => uuid)
+      ).returns(node)
 
       compiler.find(request)
     end
 
     it "should pass the configured_environment to the node indirection" do
       environment = 'foo'
-      allow(compiler).to receive(:compile)
+      compiler.stubs(:compile)
       request = Puppet::Indirector::Request.new(:catalog, :find, node_name,
                                                 nil, :configured_environment => environment)
 
-      expect(Puppet::Node.indirection).to receive(:find).with(
+      Puppet::Node.indirection.expects(:find).with(
         node_name,
-        hash_including(:configured_environment => environment)
-      ).and_return(node)
+        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")
-      expect(compiler).to receive(:extract_facts_from_request).and_return(facts)
-      expect(compiler).to receive(:save_facts_from_request)
+      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'))
 
-      expect(Puppet::Node.indirection).to receive(:find).with("hostname", hash_including(:facts => facts)).and_return(node)
+      Puppet::Node.indirection.expects(:find).with("hostname", has_entries(:facts => facts)).returns(node)
 
       compiler.find(request)
     end
@@ -381,89 +391,62 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "after finding nodes" do
     before do
-      expect(Puppet).to receive(:version).and_return(1)
-      expect(Facter).to receive(:value).with('fqdn').and_return("my.server.com")
-      expect(Facter).to receive(:value).with('ipaddress').and_return("my.ip.address")
+      Puppet.expects(:version).returns(1)
+      Facter.expects(:value).with('fqdn').returns("my.server.com")
+      Facter.expects(:value).with('ipaddress').returns("my.ip.address")
       @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
-      allow(compiler).to receive(:compile)
-      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
+      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
-      expect(node).to receive(:merge).with(hash_including("serverversion" => "1"))
+      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
-      expect(node).to receive(:merge).with(hash_including("servername" => "my.server.com"))
+      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
-      expect(node).to receive(:merge).with(hash_including("serverip" => "my.ip.address"))
+      node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" }
       compiler.find(@request)
     end
   end
 
-  describe "after finding nodes when checking for a PE version" do
-    include PuppetSpec::Compiler
-
-    let(:pe_version_file) { '/opt/puppetlabs/server/pe_version' }
-    let(:request) { Puppet::Indirector::Request.new(:catalog, :find, node_name, nil) }
-
-    before :each do
-      Puppet[:code] = 'notify { "PE Version: $pe_serverversion": }'
-    end
-
-    it "should not add 'pe_serverversion' when FOSS" do
-      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
-      catalog = compiler.find(request)
-
-      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be_nil
-    end
-
-    it "should add 'pe_serverversion' when PE" do
-      allow(File).to receive(:readable?).with(pe_version_file).and_return(true)
-      allow(File).to receive(:zero?).with(pe_version_file).and_return(false)
-      allow(File).to receive(:read).with(pe_version_file).and_return('2019.2.0')
-
-      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
-      catalog = compiler.find(request)
-
-      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be
-    end
-  end
-
   describe "when filtering resources" do
     before :each do
-      @catalog = double('catalog')
-      allow(@catalog).to receive(:respond_to?).with(:filter).and_return(true)
+      Facter.stubs(:value)
+      @catalog = stub_everything 'catalog'
+      @catalog.stubs(:respond_to?).with(:filter).returns(true)
     end
 
     it "should delegate to the catalog instance filtering" do
-      expect(@catalog).to receive(:filter)
+      @catalog.expects(:filter)
       compiler.filter(@catalog)
     end
 
     it "should filter out virtual resources" do
-      resource = double('resource', :virtual? => true)
-      allow(@catalog).to receive(:filter).and_yield(resource)
+      resource = mock 'resource', :virtual? => true
+      @catalog.stubs(:filter).yields(resource)
 
       compiler.filter(@catalog)
     end
 
     it "should return the same catalog if it doesn't support filtering" do
-      allow(@catalog).to receive(:respond_to?).with(:filter).and_return(false)
+      @catalog.stubs(:respond_to?).with(:filter).returns(false)
 
       expect(compiler.filter(@catalog)).to eq(@catalog)
     end
 
     it "should return the filtered catalog" do
-      catalog = double('filtered catalog')
-      allow(@catalog).to receive(:filter).and_return(catalog)
+      catalog = stub 'filtered catalog'
+      @catalog.stubs(:filter).returns(catalog)
 
       expect(compiler.filter(@catalog)).to eq(catalog)
     end
+
   end
 
   describe "when inlining metadata" do
@@ -478,33 +461,33 @@ describe Puppet::Resource::Catalog::Compiler do
     def stubs_resource_metadata(ftype, relative_path, full_path = nil)
       full_path ||=  File.join(Puppet[:environmentpath], 'production', relative_path)
 
-      metadata = double('metadata')
-      allow(metadata).to receive(:ftype).and_return(ftype)
-      allow(metadata).to receive(:full_path).and_return(full_path)
-      allow(metadata).to receive(:relative_path).and_return(relative_path)
-      allow(metadata).to receive(:source).and_return("puppet:///#{relative_path}")
-      allow(metadata).to receive(:source=)
-      allow(metadata).to receive(:content_uri=)
+      metadata = stub 'metadata'
+      metadata.stubs(:ftype).returns(ftype)
+      metadata.stubs(:full_path).returns(full_path)
+      metadata.stubs(:relative_path).returns(relative_path)
+      metadata.stubs(:source).returns("puppet:///#{relative_path}")
+      metadata.stubs(:source=)
+      metadata.stubs(:content_uri=)
 
       metadata
     end
 
     def stubs_file_metadata(checksum_type, sha, relative_path, full_path = nil)
       metadata = stubs_resource_metadata('file', relative_path, full_path)
-      allow(metadata).to receive(:checksum).and_return("{#{checksum_type}}#{sha}")
-      allow(metadata).to receive(:checksum_type).and_return(checksum_type)
+      metadata.stubs(:checksum).returns("{#{checksum_type}}#{sha}")
+      metadata.stubs(:checksum_type).returns(checksum_type)
       metadata
     end
 
     def stubs_link_metadata(relative_path, destination)
       metadata = stubs_resource_metadata('link', relative_path)
-      allow(metadata).to receive(:destination).and_return(destination)
+      metadata.stubs(:destination).returns(destination)
       metadata
     end
 
     def stubs_directory_metadata(relative_path)
       metadata = stubs_resource_metadata('directory', relative_path)
-      allow(metadata).to receive(:relative_path).and_return('.')
+      metadata.stubs(:relative_path).returns('.')
       metadata
     end
 
@@ -517,8 +500,8 @@ describe Puppet::Resource::Catalog::Compiler do
       MANIFEST
 
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/files/config_file.txt')
-      expect(metadata).to receive(:source=).with(source)
-      expect(metadata).to receive(:content_uri=).with('puppet:///modules/mymodule/files/config_file.txt')
+      metadata.expects(:source=).with(source)
+      metadata.expects(:content_uri=).with('puppet:///modules/mymodule/files/config_file.txt')
 
       options = {
         :environment => catalog.environment_instance,
@@ -526,7 +509,7 @@ describe Puppet::Resource::Catalog::Compiler do
         :checksum_type => checksum_type.to_sym,
         :source_permissions => :ignore
       }
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, options).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, options).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
 
@@ -545,8 +528,8 @@ describe Puppet::Resource::Catalog::Compiler do
       MANIFEST
 
       metadata = stubs_link_metadata('modules/mymodule/files/config_file.txt', '/tmp/some/absolute/path')
-      expect(metadata).to receive(:source=).with(source)
-      expect(metadata).to receive(:content_uri=).with('puppet:///modules/mymodule/files/config_file.txt')
+      metadata.expects(:source=).with(source)
+      metadata.expects(:content_uri=).with('puppet:///modules/mymodule/files/config_file.txt')
 
       options = {
         :environment        => catalog.environment_instance,
@@ -554,7 +537,7 @@ describe Puppet::Resource::Catalog::Compiler do
         :checksum_type      => checksum_type.to_sym,
         :source_permissions => :use
       }
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, options).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, options).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
 
@@ -585,7 +568,7 @@ describe Puppet::Resource::Catalog::Compiler do
         :source_permissions => default_file[:source_permissions]
       }
 
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, options).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, options).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
     end
@@ -600,10 +583,10 @@ describe Puppet::Resource::Catalog::Compiler do
       MANIFEST
 
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/files/config_file.txt')
-      expect(metadata).to receive(:source=).with(source)
-      expect(metadata).to receive(:content_uri=).with('puppet:///modules/mymodule/files/config_file.txt')
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(alt_source, anything).and_return(nil)
+      metadata.expects(:source=).with(source)
+      metadata.expects(:content_uri=).with('puppet:///modules/mymodule/files/config_file.txt')
+      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)
 
@@ -630,7 +613,7 @@ describe Puppet::Resource::Catalog::Compiler do
             :checksum_type      => checksum_type.to_sym,
             :source_permissions => :ignore
           }
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, options).and_return(metadata)
+          Puppet::FileServing::Metadata.indirection.expects(:find).with(source, options).returns(metadata)
 
           compiler.send(:inline_metadata, catalog, checksum_type)
 
@@ -651,11 +634,11 @@ describe Puppet::Resource::Catalog::Compiler do
       MANIFEST
 
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/files/config_file.txt')
-      allow(metadata).to receive(:source).and_return(source)
+      metadata.stubs(:source).returns(source)
 
-      expect(metadata).to receive(:content_uri=).with('puppet://myhost:8888/modules/mymodule/files/config_file.txt')
+      metadata.expects(:content_uri=).with('puppet://myhost:8888/modules/mymodule/files/config_file.txt')
 
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
     end
@@ -722,7 +705,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
       full_path = File.join(Puppet[:codedir], "modules/mymodule/files/config_file.txt")
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/files/config_file.txt', full_path)
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
@@ -740,7 +723,7 @@ describe Puppet::Resource::Catalog::Compiler do
       MANIFEST
 
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'secure/files/data.txt')
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
@@ -756,7 +739,7 @@ describe Puppet::Resource::Catalog::Compiler do
       MANIFEST
 
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/not_in_files/config_file.txt')
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
@@ -773,7 +756,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
       # note empty module name "modules//files"
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules//files/config_file.txt')
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata).to be_empty
@@ -793,9 +776,9 @@ describe Puppet::Resource::Catalog::Compiler do
 
       # See https://github.com/puppetlabs/control-repo/blob/508b9cc/site/profile/files/puppetmaster/update-classes.sh
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'site/profile/files/puppetmaster/update-classes.sh')
-      allow(metadata).to receive(:source).and_return(source)
+      metadata.stubs(:source).returns(source)
 
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata[path]).to eq(metadata)
@@ -815,9 +798,9 @@ describe Puppet::Resource::Catalog::Compiler do
       MANIFEST
 
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/files/myfile')
-      allow(metadata).to receive(:source).and_return(source)
+      metadata.stubs(:source).returns(source)
 
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata[path]).to eq(metadata)
@@ -837,8 +820,8 @@ describe Puppet::Resource::Catalog::Compiler do
             }
           MANIFEST
 
-          expect(metadata).to receive(:content_uri=).with('puppet:///modules/mymodule/files/directory')
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source_dir, anything).and_return(metadata)
+          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)
 
@@ -859,8 +842,8 @@ describe Puppet::Resource::Catalog::Compiler do
             }
           MANIFEST
 
-          expect(metadata).to receive(:content_uri=).with('puppet:///modules/mymodule/files/directory')
-          expect(child_metadata).to receive(:content_uri=).with('puppet:///modules/mymodule/files/directory/myfile.txt')
+          metadata.expects(:content_uri=).with('puppet:///modules/mymodule/files/directory')
+          child_metadata.expects(:content_uri=).with('puppet:///modules/mymodule/files/directory/myfile.txt')
 
           options = {
             :environment        => catalog.environment_instance,
@@ -871,7 +854,7 @@ describe Puppet::Resource::Catalog::Compiler do
             :recurselimit       => nil,
             :ignore             => nil,
           }
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source_dir, options).and_return([metadata, child_metadata])
+          Puppet::FileServing::Metadata.indirection.expects(:search).with(source_dir, options).returns([metadata, child_metadata])
 
           compiler.send(:inline_metadata, catalog, checksum_type)
 
@@ -902,7 +885,7 @@ describe Puppet::Resource::Catalog::Compiler do
             :recurselimit       => 2,
             :ignore             => 'foo.+',
           }
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source_dir, options).and_return([metadata, child_metadata])
+          Puppet::FileServing::Metadata.indirection.expects(:search).with(source_dir, options).returns([metadata, child_metadata])
 
           compiler.send(:inline_metadata, catalog, checksum_type)
 
@@ -921,8 +904,8 @@ describe Puppet::Resource::Catalog::Compiler do
             }
           MANIFEST
 
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source_dir, anything).and_return([metadata, child_metadata])
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(alt_source_dir, anything).and_return([metadata, child_metadata])
+          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)
 
@@ -941,8 +924,8 @@ describe Puppet::Resource::Catalog::Compiler do
             }
           MANIFEST
 
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source_dir, anything).and_return(nil)
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(alt_source_dir, anything).and_return([metadata, child_metadata])
+          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)
 
@@ -963,9 +946,9 @@ describe Puppet::Resource::Catalog::Compiler do
           MANIFEST
 
           metadata = stubs_directory_metadata('secure/files/data')
-          allow(metadata).to receive(:source).and_return(source)
+          metadata.stubs(:source).returns(source)
 
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source, anything).and_return([metadata])
+          Puppet::FileServing::Metadata.indirection.expects(:search).with(source, anything).returns([metadata])
 
           compiler.send(:inline_metadata, catalog, checksum_type)
           expect(catalog.metadata).to be_empty
@@ -984,7 +967,7 @@ describe Puppet::Resource::Catalog::Compiler do
           MANIFEST
 
           metadata = stubs_directory_metadata('modules/mymodule/not_in_files/directory')
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source, anything).and_return([metadata])
+          Puppet::FileServing::Metadata.indirection.expects(:search).with(source, anything).returns([metadata])
 
           compiler.send(:inline_metadata, catalog, checksum_type)
           expect(catalog.metadata).to be_empty
@@ -1005,12 +988,12 @@ describe Puppet::Resource::Catalog::Compiler do
 
           # See https://github.com/puppetlabs/control-repo/blob/508b9cc/site/profile/files/puppetmaster/update-classes.sh
           dir_metadata = stubs_directory_metadata('site/profile/files/puppetmaster')
-          allow(dir_metadata).to receive(:source).and_return(source)
+          dir_metadata.stubs(:source).returns(source)
 
           child_metadata = stubs_file_metadata(checksum_type, checksum_value, './update-classes.sh')
-          allow(child_metadata).to receive(:source).and_return("#{source}/update-classes.sh")
+          child_metadata.stubs(:source).returns("#{source}/update-classes.sh")
 
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source, anything).and_return([dir_metadata, child_metadata])
+          Puppet::FileServing::Metadata.indirection.expects(:search).with(source, anything).returns([dir_metadata, child_metadata])
 
           compiler.send(:inline_metadata, catalog, checksum_type)
           expect(catalog.metadata).to be_empty
@@ -1029,12 +1012,12 @@ describe Puppet::Resource::Catalog::Compiler do
           MANIFEST
 
           dir_metadata = stubs_directory_metadata('modules/mymodule/files/directory')
-          allow(dir_metadata).to receive(:source).and_return(source)
+          dir_metadata.stubs(:source).returns(source)
 
           child_metadata = stubs_file_metadata(checksum_type, checksum_value, './file')
-          allow(child_metadata).to receive(:source).and_return("#{source}/file")
+          child_metadata.stubs(:source).returns("#{source}/file")
 
-          expect(Puppet::FileServing::Metadata.indirection).to receive(:search).with(source, anything).and_return([dir_metadata, child_metadata])
+          Puppet::FileServing::Metadata.indirection.expects(:search).with(source, anything).returns([dir_metadata, child_metadata])
 
           compiler.send(:inline_metadata, catalog, checksum_type)
 
@@ -1063,7 +1046,7 @@ describe Puppet::Resource::Catalog::Compiler do
       MANIFEST
 
       metadata = stubs_file_metadata(checksum_type, checksum_value, 'modules/mymodule/files/config_file.txt')
-      expect(Puppet::FileServing::Metadata.indirection).to receive(:find).with(source, anything).and_return(metadata)
+      Puppet::FileServing::Metadata.indirection.expects(:find).with(source, anything).returns(metadata)
 
       compiler.send(:inline_metadata, catalog, checksum_type)
       expect(catalog.metadata['c:/foo']).to eq(metadata)