puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

data/spec/unit/puppet_pal_spec.rb

@@ -1,10 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
-
-require_relative('puppet_pal_2pec') unless RUBY_VERSION == '1.9.3'
-
-#describe 'Puppet Pal' do
-#  pending("Puppet::Pal is not available on Ruby 1.9.3") if RUBY_VERSION == '1.9.3'
-##  before { skip("Puppet::Pal is not available on Ruby 1.9.3") if RUBY_VERSION == '1.9.3' }
-#  require_relative 'puppet_pal_2pec'
-#end
+require_relative 'puppet_pal_2pec'

data/spec/unit/puppet_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
 require 'puppet_spec/files'
@@ -23,23 +24,9 @@ describe Puppet do
     expect(ENV["PATH"]).to eq(newpath)
   end
 
-  it "should change $LOAD_PATH when :libdir changes" do
-    one = tmpdir('load-path-one')
-    two = tmpdir('load-path-two')
-    expect(one).not_to eq(two)
-
-    Puppet[:libdir] = one
-    expect($LOAD_PATH).to include one
-    expect($LOAD_PATH).not_to include two
-
-    Puppet[:libdir] = two
-    expect($LOAD_PATH).not_to include one
-    expect($LOAD_PATH).to include two
-  end
-
   it 'should propagate --modulepath to base environment' do
-    expect(Puppet::Node::Environment).to receive(:create).with(
-      be_a(Symbol), ['/my/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    Puppet::Node::Environment.expects(:create).with(
+      is_a(Symbol), ['/my/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',
@@ -49,8 +36,8 @@ describe Puppet do
   end
 
   it 'empty modulepath does not override basemodulepath' do
-    expect(Puppet::Node::Environment).to receive(:create).with(
-      be_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    Puppet::Node::Environment.expects(:create).with(
+      is_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',
@@ -60,8 +47,8 @@ describe Puppet do
   end
 
   it 'nil modulepath does not override basemodulepath' do
-    expect(Puppet::Node::Environment).to receive(:create).with(
-      be_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    Puppet::Node::Environment.expects(:create).with(
+      is_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',
@@ -83,11 +70,4 @@ describe Puppet do
       expect(SemanticPuppet::Version).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
     end
   end
-
-  context "newtype" do
-    it "should issue a deprecation warning" do
-      expect(subject).to receive(:deprecation_warning).with("Creating sometype via Puppet.newtype is deprecated and will be removed in a future release. Use Puppet::Type.newtype instead.")
-      subject.newtype("sometype")
-    end
-  end
 end

data/spec/unit/relationship_spec.rb

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

data/spec/unit/reports/http_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/reports'
 
@@ -7,19 +8,19 @@ describe processor do
   subject { Puppet::Transaction::Report.new.extend(processor) }
 
   describe "when setting up the connection" do
-    let(:http) { double("http") }
+    let(:http) { stub_everything "http" }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     before :each do
-      expect(http).to receive(:post).and_return(httpok)
+      http.expects(:post).returns(httpok)
     end
 
     it "configures the connection for ssl when using https" do
       Puppet[:reporturl] = 'https://testing:8080/the/path'
 
-      expect(Puppet::Network::HttpPool).to receive(:http_instance).with(
+      Puppet::Network::HttpPool.expects(:http_instance).with(
         'testing', 8080, true
-      ).and_return(http)
+      ).returns http
 
       subject.process
     end
@@ -27,26 +28,26 @@ describe processor do
     it "does not configure the connectino for ssl when using http" do
       Puppet[:reporturl] = "http://testing:8080/the/path"
 
-      expect(Puppet::Network::HttpPool).to receive(:http_instance).with(
+      Puppet::Network::HttpPool.expects(:http_instance).with(
         'testing', 8080, false
-      ).and_return(http)
+      ).returns http
 
       subject.process
     end
   end
 
   describe "when making a request" do
-    let(:connection) { double("connection") }
+    let(:connection) { stub_everything "connection" }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
     let(:options) { {:metric_id => [:puppet, :report, :http]} }
 
     before :each do
-      expect(Puppet::Network::HttpPool).to receive(:http_instance).and_return(connection)
+      Puppet::Network::HttpPool.expects(:http_instance).returns(connection)
     end
 
     it "should use the path specified by the 'reporturl' setting" do
       report_path = URI.parse(Puppet[:reporturl]).path
-      expect(connection).to receive(:post).with(report_path, anything, anything, options).and_return(httpok)
+      connection.expects(:post).with(report_path, anything, anything, options).returns(httpok)
 
       subject.process
     end
@@ -54,24 +55,24 @@ describe processor do
     it "should use the username and password specified by the 'reporturl' setting" do
       Puppet[:reporturl] = "https://user:pass@myhost.mydomain:1234/report/upload"
 
-      expect(connection).to receive(:post).with(anything, anything, anything,
-                                                {:metric_id => [:puppet, :report, :http],
-                                                 :basic_auth => {
-                                                   :user => 'user',
-                                                   :password => 'pass'
-                                                 }}).and_return(httpok)
+      connection.expects(:post).with(anything, anything, anything,
+                                     {:metric_id => [:puppet, :report, :http],
+                                      :basic_auth => {
+                                        :user => 'user',
+                                        :password => 'pass'
+                                      }}).returns(httpok)
 
       subject.process
     end
 
     it "should give the body as the report as YAML" do
-      expect(connection).to receive(:post).with(anything, subject.to_yaml, anything, options).and_return(httpok)
+      connection.expects(:post).with(anything, subject.to_yaml, anything, options).returns(httpok)
 
       subject.process
     end
 
     it "should set content-type to 'application/x-yaml'" do
-      expect(connection).to receive(:post).with(anything, anything, hash_including("Content-Type" => "application/x-yaml"), options).and_return(httpok)
+      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml"), options).returns(httpok)
 
       subject.process
     end
@@ -80,9 +81,9 @@ describe processor do
       if code.to_i >= 200 and code.to_i < 300
         it "should succeed on http code #{code}" do
           response = klass.new('1.1', code, '')
-          expect(connection).to receive(:post).and_return(response)
+          connection.expects(:post).returns(response)
 
-          expect(Puppet).not_to receive(:err)
+          Puppet.expects(:err).never
           subject.process
         end
       end
@@ -90,12 +91,13 @@ describe processor do
       if code.to_i >= 300 && ![301, 302, 307].include?(code.to_i)
         it "should log error on http code #{code}" do
           response = klass.new('1.1', code, '')
-          expect(connection).to receive(:post).and_return(response)
+          connection.expects(:post).returns(response)
 
-          expect(Puppet).to receive(:err)
+          Puppet.expects(:err)
           subject.process
         end
       end
     end
+
   end
 end

data/spec/unit/reports/store_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/reports'
@@ -23,7 +24,7 @@ describe processor do
     end
 
     it "should write the report to the file in YAML" do
-      allow(Time).to receive(:now).and_return(Time.utc(2011,01,06,12,00,00))
+      Time.stubs(:now).returns(Time.utc(2011,01,06,12,00,00))
       @report.process
 
       expect(File.read(File.join(Puppet[:reportdir], @report.host, "201101061200.yaml"))).to eq(@report.to_yaml)
@@ -31,14 +32,14 @@ describe processor do
 
     it "rejects invalid hostnames" do
       @report.host = ".."
-      expect(Puppet::FileSystem).not_to receive(:exist?)
+      Puppet::FileSystem.expects(:exist?).never
       expect { @report.process }.to raise_error(ArgumentError, /Invalid node/)
     end
   end
 
   describe "::destroy" do
     it "rejects invalid hostnames" do
-      expect(Puppet::FileSystem).not_to receive(:unlink)
+      Puppet::FileSystem.expects(:unlink).never
       expect { processor.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
     end
   end

data/spec/unit/reports_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/reports'
@@ -16,11 +17,11 @@ describe Puppet::Reports do
   end
 
   it "should provide a method for returning documentation for all reports" do
-    expect(Puppet::Reports).to receive(:loaded_instances).with(:report).and_return([:one, :two])
-    one = double('one', :doc => "onedoc")
-    two = double('two', :doc => "twodoc")
-    expect(Puppet::Reports).to receive(:report).with(:one).and_return(one)
-    expect(Puppet::Reports).to receive(:report).with(:two).and_return(two)
+    Puppet::Reports.expects(:loaded_instances).with(:report).returns([:one, :two])
+    one = mock 'one', :doc => "onedoc"
+    two = mock 'two', :doc => "twodoc"
+    Puppet::Reports.expects(:report).with(:one).returns(one)
+    Puppet::Reports.expects(:report).with(:two).returns(two)
 
     doc = Puppet::Reports.reportdocs
     expect(doc.include?("onedoc")).to be_truthy
@@ -28,16 +29,17 @@ describe Puppet::Reports do
   end
 end
 
+
 describe Puppet::Reports, " when loading report types" do
   it "should use the instance loader to retrieve report types" do
-    expect(Puppet::Reports).to receive(:loaded_instance).with(:report, :myreporttype)
+    Puppet::Reports.expects(:loaded_instance).with(:report, :myreporttype)
     Puppet::Reports.report(:myreporttype)
   end
 end
 
 describe Puppet::Reports, " when registering report types" do
   it "should evaluate the supplied block as code for a module" do
-    expect(Puppet::Reports).to receive(:genmodule).and_return(Module.new)
+    Puppet::Reports.expects(:genmodule).returns(Module.new)
     Puppet::Reports.register_report(:testing) { }
   end
 
@@ -52,17 +54,17 @@ describe Puppet::Reports, " when registering report types" do
   end
 
   it "should extend the report type with the Puppet::Util::Docs module" do
-    mod = double('module', :define_method => true)
+    mod = stub 'module', :define_method => true
 
-    expect(Puppet::Reports).to receive(:genmodule).with(anything, hash_including(extend: Puppet::Util::Docs)).and_return(mod)
+    Puppet::Reports.expects(:genmodule).with { |name, options, block| options[:extend] == Puppet::Util::Docs }.returns(mod)
     Puppet::Reports.register_report(:testing) { }
   end
 
   it "should define a :report_name method in the module that returns the name of the report" do
-    mod = double('module')
-    expect(mod).to receive(:define_method).with(:report_name)
+    mod = mock 'module'
+    mod.expects(:define_method).with(:report_name)
 
-    expect(Puppet::Reports).to receive(:genmodule).and_return(mod)
+    Puppet::Reports.expects(:genmodule).returns(mod)
     Puppet::Reports.register_report(:testing) { }
   end
 end

data/spec/unit/resource/capability_finder_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require_relative '../pops/parser/parser_rspec_helper'
 require 'puppet/resource/capability_finder'
@@ -5,40 +6,36 @@ require 'puppet/resource/capability_finder'
 describe Puppet::Resource::CapabilityFinder do
   context 'when PuppetDB is not configured' do
     it 'should error' do
-      expect(Puppet::Util).to receive(:const_defined?).with('Puppetdb').and_return(false)
+      Puppet::Util.expects(:const_defined?).with('Puppetdb').returns false
       expect { Puppet::Resource::CapabilityFinder.find('production', nil, nil) }.to raise_error(/PuppetDB is not available/)
     end
   end
 
   context 'when PuppetDB is configured' do
-    before(:each) do
-      allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
-    end
 
-    around(:each) do |example|
-      mock_pdb = !Puppet::Util.const_defined?('Puppetdb')
+    before(:each) do
+      Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+      Puppet.push_context({:loaders => loaders, :current_environment => env})
       if mock_pdb
         module Puppet::Util::Puppetdb
           class Http; end
         end
       end
-      begin
-        Puppet.override(:loaders => loaders, :current_environment => env) do
-          make_cap_type
-          example.run
-        end
-      ensure
-        Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
-        Puppet::Type.rmtype(:cap)
-        Puppet::Pops::Loaders.clear
-      end
+      make_cap_type
+    end
+
+    after(:each) do
+      Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
+      Puppet::Type.rmtype(:cap)
+      Puppet.pop_context()
     end
 
+    let(:mock_pdb) { !Puppet::Util.const_defined?('Puppetdb') }
     let(:env) { Puppet::Node::Environment.create(:testing, []) }
     let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
     let(:response_body) { [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}] }
-    let(:response) { double('response', :body => response_body.to_json) }
+    let(:response) { stub('response', :body => response_body.to_json) }
 
     def make_cap_type
       Puppet::Type.newtype :cap, :is_capability => true do
@@ -49,8 +46,8 @@ describe Puppet::Resource::CapabilityFinder do
 
     describe "when query_puppetdb method is available" do
       it 'should call use the query_puppetdb method if available' do
-        expect(Puppet::Util::Puppetdb).to receive(:query_puppetdb).and_return(response_body)
-        expect(Puppet::Util::Puppetdb::Http).not_to receive(:action)
+        Puppet::Util::Puppetdb.expects(:query_puppetdb).returns(response_body)
+        Puppet::Util::Puppetdb::Http.expects(:action).never
 
         result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
         expect(result['host']).to eq('ahost')
@@ -59,11 +56,11 @@ describe Puppet::Resource::CapabilityFinder do
 
     describe "when query_puppetdb method is unavailable" do
       before :each do
-        allow(Puppet::Util::Puppetdb).to receive(:respond_to?).with(:query_puppetdb).and_return(false)
+        Puppet::Util::Puppetdb.stubs(:respond_to?).with(:query_puppetdb).returns false
       end
 
       it 'should call Puppet::Util::PuppetDB::Http.action' do
-        expect(Puppet::Util::Puppetdb::Http).to receive(:action).and_return(response)
+        Puppet::Util::Puppetdb::Http.expects(:action).returns(response)
         result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
         expect(result['host']).to eq('ahost')
       end
@@ -75,14 +72,14 @@ describe Puppet::Resource::CapabilityFinder do
 
       it 'should search for the resource without including code_id or environment' do
         resources = [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}]
-        allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
+        Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
 
         result = Puppet::Resource::CapabilityFinder.find('production', code_id, Puppet::Resource.new('Cap', 'cap'))
         expect(result['host']).to eq('ahost')
       end
 
       it 'should return nil if no resource is found' do
-        allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return([])
+        Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns []
 
         result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
         expect(result).to be_nil
@@ -95,7 +92,7 @@ describe Puppet::Resource::CapabilityFinder do
         end
 
         before :each do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
+          Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
         end
 
         it 'should return the resource matching environment' do
@@ -116,30 +113,30 @@ describe Puppet::Resource::CapabilityFinder do
         end
 
         before :each do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
+          Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
         end
 
         it 'should return the resource matching code_id' do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return([{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"chost"}}])
+          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"chost"}}]
 
           result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
           expect(result['host']).to eq('chost')
         end
 
         it 'should fail if no resource matches code_id' do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return([])
+          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns []
 
           expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::Error, /expected exactly one resource but got 2/)
         end
 
         it 'should fail if multiple resources match code_id' do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return(resources)
+          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns resources
 
           expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
         end
 
         it 'should fail if no code_id was specified' do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', nil, capability).and_return(resources)
+          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', nil, capability).returns resources
           expect { Puppet::Resource::CapabilityFinder.find('production', nil, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
         end
       end

data/spec/unit/resource/catalog_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
@@ -10,7 +11,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
   before do
     @basepath = make_absolute("/somepath")
     # stub this to not try to create state.yaml
-    allow(Puppet::Util::Storage).to receive(:store)
+    Puppet::Util::Storage.stubs(:store)
   end
 
   it "should support json, pson, dot, yaml" do
@@ -47,8 +48,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
     catalog.add_resource(res, res2, res3, res4, comp_res)
     catalog.write_resource_file
     expect(File.readlines(resourcefile).map(&:chomp)).to match_array([
-      "file[#{res.title.downcase}]",
-      "exec[#{res2.title.downcase}]"
+      "file[#{File.expand_path('/tmp/sam')}]",
+      "exec[#{File.expand_path('/bin/rm')} -rf /]"
     ])
   end
 
@@ -70,11 +71,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     Puppet[:classfile] = File.expand_path("/class/file")
 
-    fh = double('filehandle')
+    fh = mock 'filehandle'
     classfile = Puppet.settings.setting(:classfile)
-    expect(Puppet::FileSystem).to receive(:open).with(classfile.value, classfile.mode.to_i(8), "w:UTF-8").and_yield(fh)
+    Puppet::FileSystem.expects(:open).with(classfile.value, classfile.mode.to_i(8), "w:UTF-8").yields fh
 
-    expect(fh).to receive(:puts).with("foo\nbar")
+    fh.expects(:puts).with "foo\nbar"
 
     @catalog.write_class_file
   end
@@ -97,7 +98,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
   end
 
   it "should include a catalog_uuid" do
-    allow(SecureRandom).to receive(:uuid).and_return("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+    SecureRandom.stubs(:uuid).returns ("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
     catalog = Puppet::Resource::Catalog.new("host")
     expect(catalog.catalog_uuid).to eq("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
   end
@@ -234,29 +235,15 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @original.tag(*%w{one two three})
       @original.add_class(*%w{four five six})
 
-      @r1 = double(
-        'r1',
-        :ref      => "File[/a]",
-        :[]       => nil,
-        :virtual  => nil,
-        :catalog= => nil,
-      )
-      allow(@r1).to receive(:respond_to?)
-      allow(@r1).to receive(:respond_to?).with(:ref).and_return(true)
-      allow(@r1).to receive(:copy_as_resource).and_return(@r1)
-      allow(@r1).to receive(:is_a?).with(Puppet::Resource).and_return(true)
-
-      @r2 = double(
-        'r2',
-        :ref      => "File[/b]",
-        :[]       => nil,
-        :virtual  => nil,
-        :catalog= => nil,
-      )
-      allow(@r2).to receive(:respond_to?)
-      allow(@r2).to receive(:respond_to?).with(:ref).and_return(true)
-      allow(@r2).to receive(:copy_as_resource).and_return(@r2)
-      allow(@r2).to receive(:is_a?).with(Puppet::Resource).and_return(true)
+      @r1 = stub_everything 'r1', :ref => "File[/a]"
+      @r1.stubs(:respond_to?).with(:ref).returns(true)
+      @r1.stubs(:copy_as_resource).returns(@r1)
+      @r1.stubs(:is_a?).with(Puppet::Resource).returns(true)
+
+      @r2 = stub_everything 'r2', :ref => "File[/b]"
+      @r2.stubs(:respond_to?).with(:ref).returns(true)
+      @r2.stubs(:copy_as_resource).returns(@r2)
+      @r2.stubs(:is_a?).with(Puppet::Resource).returns(true)
 
       @resources = [@r1,@r2]
 
@@ -264,13 +251,13 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should transform the catalog to a resource catalog" do
-      expect(@original).to receive(:to_catalog).with(:to_resource)
+      @original.expects(:to_catalog).with { |h,b| h == :to_resource }
 
       @original.filter
     end
 
     it "should scan each catalog resource in turn and apply filtering block" do
-      @resources.each { |r| expect(r).to receive(:test?) }
+      @resources.each { |r| r.expects(:test?) }
       @original.filter do |r|
         r.test?
       end
@@ -334,7 +321,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should set itself as the resource's catalog if it is not a relationship graph" do
-      expect(@one).to receive(:catalog=).with(@catalog)
+      @one.expects(:catalog=).with(@catalog)
       @catalog.add_resource @one
     end
 
@@ -424,14 +411,14 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should remove all resources when asked" do
       @catalog.add_resource @one
       @catalog.add_resource @two
-      expect(@one).to receive(:remove)
-      expect(@two).to receive(:remove)
+      @one.expects :remove
+      @two.expects :remove
       @catalog.clear(true)
     end
 
     it "should support a mechanism for finishing resources" do
-      expect(@one).to receive(:finish)
-      expect(@two).to receive(:finish)
+      @one.expects :finish
+      @two.expects :finish
       @catalog.add_resource @one
       @catalog.add_resource @two
 
@@ -439,7 +426,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should make default resources when finalizing" do
-      expect(@catalog).to receive(:make_default_resources)
+      @catalog.expects(:make_default_resources)
       @catalog.finalize
     end
 
@@ -449,8 +436,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should optionally support an initialization block and should finalize after such blocks" do
-      expect(@one).to receive(:finish)
-      expect(@two).to receive(:finish)
+      @one.expects :finish
+      @two.expects :finish
       Puppet::Resource::Catalog.new("host") do |conf|
         conf.add_resource @one
         conf.add_resource @two
@@ -458,7 +445,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should inform the resource that it is the resource's catalog" do
-      expect(@one).to receive(:catalog=).with(@catalog)
+      @one.expects(:catalog=).with(@catalog)
       @catalog.add_resource @one
     end
 
@@ -541,14 +528,14 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should remove resource aliases when the target resource is removed" do
       @catalog.add_resource @one
       @catalog.alias(@one, "other")
-      expect(@one).to receive(:remove)
+      @one.expects :remove
       @catalog.remove_resource(@one)
       expect(@catalog.resource("notify", "other")).to be_nil
     end
 
     it "should add an alias for the namevar when the title and name differ on isomorphic resource types" do
       resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
-      expect(resource).to receive(:isomorphic?).and_return(true)
+      resource.expects(:isomorphic?).returns(true)
       @catalog.add_resource(resource)
       expect(@catalog.resource(:file, "other")).to equal(resource)
       expect(@catalog.resource(:file, @basepath+"/something").ref).to eq(resource.ref)
@@ -556,7 +543,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     it "should not add an alias for the namevar when the title and name differ on non-isomorphic resource types" do
       resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
-      expect(resource).to receive(:isomorphic?).and_return(false)
+      resource.expects(:isomorphic?).returns(false)
       @catalog.add_resource(resource)
       expect(@catalog.resource(:file, resource.title)).to equal(resource)
       # We can't use .should here, because the resources respond to that method.
@@ -565,8 +552,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     it "should provide a method to create additional resources that also registers the resource" do
       args = {:name => "/yay", :ensure => :file}
-      resource = double('file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay")
-      expect(Puppet::Type.type(:file)).to receive(:new).with(args).and_return(resource)
+      resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay"
+      Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
       @catalog.create_resource :file, args
       expect(@catalog.resource("File[/yay]")).to equal(resource)
     end
@@ -629,21 +616,21 @@ describe Puppet::Resource::Catalog, "when compiling" do
     before :each do
       @catalog = Puppet::Resource::Catalog.new("host")
 
-      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::RandomPrioritizer.new)
-      allow(Puppet::Transaction).to receive(:new).and_return(@transaction)
-      allow(@transaction).to receive(:evaluate)
-      allow(@transaction).to receive(:for_network_device=)
+      @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
+      Puppet::Transaction.stubs(:new).returns(@transaction)
+      @transaction.stubs(:evaluate)
+      @transaction.stubs(:for_network_device=)
 
-      allow(Puppet.settings).to receive(:use)
+      Puppet.settings.stubs(:use)
     end
 
     it "should create and evaluate a transaction" do
-      expect(@transaction).to receive(:evaluate)
+      @transaction.expects(:evaluate)
       @catalog.apply
     end
 
     it "should add a transaction evalution time to the report" do
-      expect(@transaction.report).to receive(:add_times).with(:transaction_evaluation, kind_of(Numeric))
+      @transaction.report.expects(:add_times).with(:transaction_evaluation, kind_of(Numeric))
       @catalog.apply
     end
 
@@ -667,17 +654,17 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should pass supplied tags on to the transaction" do
-      expect(@transaction).to receive(:tags=).with(%w{one two})
+      @transaction.expects(:tags=).with(%w{one two})
       @catalog.apply(:tags => %w{one two})
     end
 
     it "should set ignoreschedules on the transaction if specified in apply()" do
-      expect(@transaction).to receive(:ignoreschedules=).with(true)
+      @transaction.expects(:ignoreschedules=).with(true)
       @catalog.apply(:ignoreschedules => true)
     end
 
     it "should detect transaction failure and report it" do
-      allow(@transaction).to receive(:evaluate).and_raise(RuntimeError, 'transaction failed.')
+      @transaction.stubs(:evaluate).raises(RuntimeError, 'transaction failed.')
       report = Puppet::Transaction::Report.new('apply')
 
       expect { @catalog.apply(:report => report) }.to raise_error(RuntimeError)
@@ -687,28 +674,31 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     describe "host catalogs" do
+
       # super() doesn't work in the setup method for some reason
       before do
         @catalog.host_config = true
-        allow(Puppet::Util::Storage).to receive(:store)
+        Puppet::Util::Storage.stubs(:store)
       end
 
       it "should initialize the state database before applying a catalog" do
-        expect(Puppet::Util::Storage).to receive(:load)
+        Puppet::Util::Storage.expects(:load)
 
         # Short-circuit the apply, so we know we're loading before the transaction
-        expect(Puppet::Transaction).to receive(:new).and_raise(ArgumentError)
+        Puppet::Transaction.expects(:new).raises ArgumentError
         expect { @catalog.apply }.to raise_error(ArgumentError)
       end
 
       it "should sync the state database after applying" do
-        expect(Puppet::Util::Storage).to receive(:store)
-        allow(@transaction).to receive(:any_failed?).and_return(false)
+        Puppet::Util::Storage.expects(:store)
+        @transaction.stubs :any_failed? => false
         @catalog.apply
       end
+
     end
 
     describe "non-host catalogs" do
+
       before do
         @catalog.host_config = false
       end
@@ -720,10 +710,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
       end
 
       it "should never modify the state database" do
-        expect(Puppet::Util::Storage).not_to receive(:load)
-        expect(Puppet::Util::Storage).not_to receive(:store)
+        Puppet::Util::Storage.expects(:load).never
+        Puppet::Util::Storage.expects(:store).never
         @catalog.apply
       end
+
     end
   end
 
@@ -733,7 +724,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should get removed when the catalog is cleaned up" do
-      expect(@catalog.relationship_graph).to receive(:clear)
+      @catalog.relationship_graph.expects(:clear)
 
       @catalog.clear
 
@@ -749,18 +740,19 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should only write when it is a host catalog" do
-      expect(Puppet::FileSystem).not_to receive(:open).with(@file, 0640, "w:UTF-8")
+      Puppet::FileSystem.expects(:open).with(@file, 0640, "w:UTF-8").never
       @catalog.host_config = false
       Puppet[:graph] = true
       @catalog.write_graph(@name)
     end
+
   end
 
   describe "when indirecting" do
     before do
       @real_indirection = Puppet::Resource::Catalog.indirection
 
-      @indirection = double('indirection', :name => :catalog)
+      @indirection = stub 'indirection', :name => :catalog
     end
 
     it "should use the value of the 'catalog_terminus' setting to determine its terminus class" do
@@ -800,7 +792,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog.add_edge("one", "two")
 
       text = YAML.dump(@catalog)
-      @newcatalog = YAML.load(text)
+      @newcatalog = Puppet::Util::Yaml.safe_load(text, [Puppet::Resource::Catalog])
     end
 
     it "should get converted back to a catalog" do
@@ -876,20 +868,21 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
   context 'when dealing with parameters that have non-Data values' do
     context 'and rich_data is enabled' do
       before(:each) do
-        Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(Puppet.lookup(:environments).get(Puppet[:environment])))
-        Puppet[:rich_data] = true
+        Puppet.push_context(
+          :loaders => Puppet::Pops::Loaders.new(Puppet.lookup(:environments).get(Puppet[:environment])),
+          :rich_data => true)
       end
 
       after(:each) do
-        Puppet[:rich_data] = false
         Puppet.pop_context
       end
 
+
       let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
 
       it 'should generate rich value hash for parameter values that are not Data' do
         s = catalog_w_regexp.to_json
-        expect(s).to include('"parameters":{"message":{"__pcore_type__":"Regexp","__pcore_value__":"[a-z]+"}}')
+        expect(s).to include('"parameters":{"message":{"__ptype":"Regexp","__pvalue":"[a-z]+"}}')
       end
 
       it 'should read and convert rich value hash containing Regexp from json' do
@@ -958,7 +951,7 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
       let(:catalog_w_regexp)  { compile_to_catalog("notify {'foo': message => /[a-z]+/ }") }
 
       it 'should not generate rich value hash for parameter values that are not Data' do
-        expect(catalog_w_regexp.to_json).not_to include('"__pcore_type__"')
+        expect(catalog_w_regexp.to_json).not_to include('"__ptype"')
       end
 
       it 'should convert parameter containing Regexp into strings' do
@@ -1019,7 +1012,9 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
         expect(message['a']).to eql(nil)
         expect(message['b']).to eql(10)
       end
+
     end
+
   end
 end
 
@@ -1050,29 +1045,30 @@ describe Puppet::Resource::Catalog, "when converting to json" do
   end
 
   it "should convert its resources to a JSON-encoded array and store it as the 'resources' data" do
-    one = double('one', :to_data_hash => "one_resource", :ref => "Foo[one]")
-    two = double('two', :to_data_hash => "two_resource", :ref => "Foo[two]")
+    one = stub 'one', :to_data_hash => "one_resource", :ref => "Foo[one]"
+    two = stub 'two', :to_data_hash => "two_resource", :ref => "Foo[two]"
 
-    expect(one).to receive(:'[]').with(:alias).and_return(nil)
-    expect(two).to receive(:'[]').with(:alias).and_return(nil)
+    one.expects(:'[]').with(:alias).returns nil
+    two.expects(:'[]').with(:alias).returns nil
 
     @catalog.add_resource(one)
     @catalog.add_resource(two)
 
     # TODO this should really guarantee sort order
     expect(JSON.parse(@catalog.to_json,:create_additions => false)['resources'].sort).to eq(["one_resource", "two_resource"].sort)
+
   end
 
   it "should convert its edges to a JSON-encoded array and store it as the 'edges' data" do
-    one   = double('one',   :to_data_hash => "one_resource",   :ref => 'Foo[one]')
-    two   = double('two',   :to_data_hash => "two_resource",   :ref => 'Foo[two]')
-    three = double('three', :to_data_hash => "three_resource", :ref => 'Foo[three]')
+    one   = stub 'one',   :to_data_hash => "one_resource",   :ref => 'Foo[one]'
+    two   = stub 'two',   :to_data_hash => "two_resource",   :ref => 'Foo[two]'
+    three = stub 'three', :to_data_hash => "three_resource", :ref => 'Foo[three]'
 
     @catalog.add_edge(one, two)
     @catalog.add_edge(two, three)
 
-    expect(@catalog.edges_between(one, two  )[0]).to receive(:to_data_hash).and_return("one_two_json")
-    expect(@catalog.edges_between(two, three)[0]).to receive(:to_data_hash).and_return("two_three_json")
+    @catalog.edges_between(one, two  )[0].expects(:to_data_hash).returns "one_two_json"
+    @catalog.edges_between(two, three)[0].expects(:to_data_hash).returns "two_three_json"
 
     expect(JSON.parse(@catalog.to_json,:create_additions => false)['edges'].sort).to eq(%w{one_two_json two_three_json}.sort)
   end