puppet 6.4.0-universal-darwin → 6.4.1-universal-darwin

data/spec/unit/puppet_pal_2pec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_pal'
@@ -386,8 +385,8 @@ describe 'Puppet Pal' do
       end
 
       {  nil      => Puppet::Error,
-        '0xWAT'   => Puppet::ParseErrorWithIssue, 
-        '$0 = 1'  => Puppet::ParseErrorWithIssue, 
+        '0xWAT'   => Puppet::ParseErrorWithIssue,
+        '$0 = 1'  => Puppet::ParseErrorWithIssue,
         'else 32' => Puppet::ParseErrorWithIssue,
       }.each_pair do |input, error_class|
         it "'parse_string' raises an error for invalid input: '#{input}'" do
@@ -513,7 +512,7 @@ describe 'Puppet Pal' do
 
     # TODO: there is something amiss with the metadata wrt dependencies - when metadata is present there is an error
     #       that dependencies could not be resolved. Metadata is therefore commented out.
-    #       Dependency based visibility is probably something that we should remove... 
+    #       Dependency based visibility is probably something that we should remove...
     let(:modules) {
       {
         'a' => {
@@ -943,7 +942,7 @@ describe 'Puppet Pal' do
         testing_env_dir # creates the structure
         other_modules1 = File.join(environments_dir, 'other_env1/modules')
         other_modules2 = File.join(environments_dir, 'other_env2/modules')
-        result = Puppet::Pal.in_environment('pal_env', envpath: environments_dir, 
+        result = Puppet::Pal.in_environment('pal_env', envpath: environments_dir,
           pre_modulepath: [other_modules1],
           post_modulepath: [other_modules2],
           facts: node_facts

data/spec/unit/puppet_pal_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require_relative 'puppet_pal_2pec'

data/spec/unit/puppet_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
 require 'puppet_spec/files'
@@ -25,8 +24,8 @@ describe Puppet do
   end
 
   it 'should propagate --modulepath to base environment' do
-    Puppet::Node::Environment.expects(:create).with(
-      is_a(Symbol), ['/my/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    expect(Puppet::Node::Environment).to receive(:create).with(
+      be_a(Symbol), ['/my/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',
@@ -36,8 +35,8 @@ describe Puppet do
   end
 
   it 'empty modulepath does not override basemodulepath' do
-    Puppet::Node::Environment.expects(:create).with(
-      is_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    expect(Puppet::Node::Environment).to receive(:create).with(
+      be_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',
@@ -47,8 +46,8 @@ describe Puppet do
   end
 
   it 'nil modulepath does not override basemodulepath' do
-    Puppet::Node::Environment.expects(:create).with(
-      is_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
+    expect(Puppet::Node::Environment).to receive(:create).with(
+      be_a(Symbol), ['/base/modules'], Puppet::Node::Environment::NO_MANIFEST)
 
     Puppet.base_context({
       :environmentpath => '/envs',

data/spec/unit/relationship_spec.rb

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

data/spec/unit/reports/http_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/reports'
 
@@ -8,19 +7,19 @@ describe processor do
   subject { Puppet::Transaction::Report.new.extend(processor) }
 
   describe "when setting up the connection" do
-    let(:http) { stub_everything "http" }
+    let(:http) { double("http") }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     before :each do
-      http.expects(:post).returns(httpok)
+      expect(http).to receive(:post).and_return(httpok)
     end
 
     it "configures the connection for ssl when using https" do
       Puppet[:reporturl] = 'https://testing:8080/the/path'
 
-      Puppet::Network::HttpPool.expects(:connection).with(
-        'testing', 8080, has_entry(ssl_context: instance_of(Puppet::SSL::SSLContext))
-      ).returns http
+      expect(Puppet::Network::HttpPool).to receive(:connection).with(
+        'testing', 8080, hash_including(ssl_context: instance_of(Puppet::SSL::SSLContext))
+      ).and_return(http)
 
       subject.process
     end
@@ -28,26 +27,26 @@ describe processor do
     it "does not configure the connection for ssl when using http" do
       Puppet[:reporturl] = 'http://testing:8080/the/path'
 
-      Puppet::Network::HttpPool.expects(:connection).with(
+      expect(Puppet::Network::HttpPool).to receive(:connection).with(
         'testing', 8080, use_ssl: false, ssl_context: nil
-      ).returns http
+      ).and_return(http)
 
       subject.process
     end
   end
 
   describe "when making a request" do
-    let(:connection) { stub_everything "connection" }
+    let(:connection) { double("connection") }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
     let(:options) { {:metric_id => [:puppet, :report, :http]} }
 
     before :each do
-      Puppet::Network::HttpPool.expects(:connection).returns(connection)
+      expect(Puppet::Network::HttpPool).to receive(:connection).and_return(connection)
     end
 
     it "should use the path specified by the 'reporturl' setting" do
       report_path = URI.parse(Puppet[:reporturl]).path
-      connection.expects(:post).with(report_path, anything, anything, options).returns(httpok)
+      expect(connection).to receive(:post).with(report_path, anything, anything, options).and_return(httpok)
 
       subject.process
     end
@@ -55,24 +54,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"
 
-      connection.expects(:post).with(anything, anything, anything,
-                                     {:metric_id => [:puppet, :report, :http],
-                                      :basic_auth => {
-                                        :user => 'user',
-                                        :password => 'pass'
-                                      }}).returns(httpok)
+      expect(connection).to receive(:post).with(anything, anything, anything,
+                                                {:metric_id => [:puppet, :report, :http],
+                                                 :basic_auth => {
+                                                   :user => 'user',
+                                                   :password => 'pass'
+                                                 }}).and_return(httpok)
 
       subject.process
     end
 
     it "should give the body as the report as YAML" do
-      connection.expects(:post).with(anything, subject.to_yaml, anything, options).returns(httpok)
+      expect(connection).to receive(:post).with(anything, subject.to_yaml, anything, options).and_return(httpok)
 
       subject.process
     end
 
     it "should set content-type to 'application/x-yaml'" do
-      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml"), options).returns(httpok)
+      expect(connection).to receive(:post).with(anything, anything, hash_including("Content-Type" => "application/x-yaml"), options).and_return(httpok)
 
       subject.process
     end
@@ -81,9 +80,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, '')
-          connection.expects(:post).returns(response)
+          expect(connection).to receive(:post).and_return(response)
 
-          Puppet.expects(:err).never
+          expect(Puppet).not_to receive(:err)
           subject.process
         end
       end
@@ -91,13 +90,12 @@ 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, '')
-          connection.expects(:post).returns(response)
+          expect(connection).to receive(:post).and_return(response)
 
-          Puppet.expects(:err)
+          expect(Puppet).to receive(:err)
           subject.process
         end
       end
     end
-
   end
 end

data/spec/unit/reports/store_spec.rb

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

data/spec/unit/reports_spec.rb

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

data/spec/unit/resource/capability_finder_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require_relative '../pops/parser/parser_rspec_helper'
 require 'puppet/resource/capability_finder'
@@ -6,15 +5,14 @@ require 'puppet/resource/capability_finder'
 describe Puppet::Resource::CapabilityFinder do
   context 'when PuppetDB is not configured' do
     it 'should error' do
-      Puppet::Util.expects(:const_defined?).with('Puppetdb').returns false
+      expect(Puppet::Util).to receive(:const_defined?).with('Puppetdb').and_return(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
-      Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+      allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
       Puppet.push_context({:loaders => loaders, :current_environment => env})
       if mock_pdb
         module Puppet::Util::Puppetdb
@@ -35,7 +33,7 @@ describe Puppet::Resource::CapabilityFinder do
     let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
     let(:response_body) { [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}] }
-    let(:response) { stub('response', :body => response_body.to_json) }
+    let(:response) { double('response', :body => response_body.to_json) }
 
     def make_cap_type
       Puppet::Type.newtype :cap, :is_capability => true do
@@ -46,8 +44,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
-        Puppet::Util::Puppetdb.expects(:query_puppetdb).returns(response_body)
-        Puppet::Util::Puppetdb::Http.expects(:action).never
+        expect(Puppet::Util::Puppetdb).to receive(:query_puppetdb).and_return(response_body)
+        expect(Puppet::Util::Puppetdb::Http).not_to receive(:action)
 
         result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
         expect(result['host']).to eq('ahost')
@@ -56,11 +54,11 @@ describe Puppet::Resource::CapabilityFinder do
 
     describe "when query_puppetdb method is unavailable" do
       before :each do
-        Puppet::Util::Puppetdb.stubs(:respond_to?).with(:query_puppetdb).returns false
+        allow(Puppet::Util::Puppetdb).to receive(:respond_to?).with(:query_puppetdb).and_return(false)
       end
 
       it 'should call Puppet::Util::PuppetDB::Http.action' do
-        Puppet::Util::Puppetdb::Http.expects(:action).returns(response)
+        expect(Puppet::Util::Puppetdb::Http).to receive(:action).and_return(response)
         result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
         expect(result['host']).to eq('ahost')
       end
@@ -72,14 +70,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"}}]
-        Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+        allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(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
-        Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns []
+        allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return([])
 
         result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
         expect(result).to be_nil
@@ -92,7 +90,7 @@ describe Puppet::Resource::CapabilityFinder do
         end
 
         before :each do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
         end
 
         it 'should return the resource matching environment' do
@@ -113,30 +111,30 @@ describe Puppet::Resource::CapabilityFinder do
         end
 
         before :each do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
         end
 
         it 'should return the resource matching code_id' do
-          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"chost"}}]
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return([{"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
-          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns []
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return([])
 
           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
-          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns resources
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return(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
-          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', nil, capability).returns resources
+          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', nil, capability).and_return(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,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
@@ -11,7 +10,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
   before do
     @basepath = make_absolute("/somepath")
     # stub this to not try to create state.yaml
-    Puppet::Util::Storage.stubs(:store)
+    allow(Puppet::Util::Storage).to receive(:store)
   end
 
   it "should support json, pson, dot, yaml" do
@@ -71,11 +70,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     Puppet[:classfile] = File.expand_path("/class/file")
 
-    fh = mock 'filehandle'
+    fh = double('filehandle')
     classfile = Puppet.settings.setting(:classfile)
-    Puppet::FileSystem.expects(:open).with(classfile.value, classfile.mode.to_i(8), "w:UTF-8").yields fh
+    expect(Puppet::FileSystem).to receive(:open).with(classfile.value, classfile.mode.to_i(8), "w:UTF-8").and_yield(fh)
 
-    fh.expects(:puts).with "foo\nbar"
+    expect(fh).to receive(:puts).with("foo\nbar")
 
     @catalog.write_class_file
   end
@@ -98,7 +97,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
   end
 
   it "should include a catalog_uuid" do
-    SecureRandom.stubs(:uuid).returns ("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+    allow(SecureRandom).to receive(:uuid).and_return("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
     catalog = Puppet::Resource::Catalog.new("host")
     expect(catalog.catalog_uuid).to eq("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
   end
@@ -235,15 +234,29 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @original.tag(*%w{one two three})
       @original.add_class(*%w{four five six})
 
-      @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)
+      @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)
 
       @resources = [@r1,@r2]
 
@@ -251,13 +264,13 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should transform the catalog to a resource catalog" do
-      @original.expects(:to_catalog).with { |h,b| h == :to_resource }
+      expect(@original).to receive(:to_catalog).with(:to_resource)
 
       @original.filter
     end
 
     it "should scan each catalog resource in turn and apply filtering block" do
-      @resources.each { |r| r.expects(:test?) }
+      @resources.each { |r| expect(r).to receive(:test?) }
       @original.filter do |r|
         r.test?
       end
@@ -321,7 +334,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
-      @one.expects(:catalog=).with(@catalog)
+      expect(@one).to receive(:catalog=).with(@catalog)
       @catalog.add_resource @one
     end
 
@@ -411,14 +424,14 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should remove all resources when asked" do
       @catalog.add_resource @one
       @catalog.add_resource @two
-      @one.expects :remove
-      @two.expects :remove
+      expect(@one).to receive(:remove)
+      expect(@two).to receive(:remove)
       @catalog.clear(true)
     end
 
     it "should support a mechanism for finishing resources" do
-      @one.expects :finish
-      @two.expects :finish
+      expect(@one).to receive(:finish)
+      expect(@two).to receive(:finish)
       @catalog.add_resource @one
       @catalog.add_resource @two
 
@@ -426,7 +439,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should make default resources when finalizing" do
-      @catalog.expects(:make_default_resources)
+      expect(@catalog).to receive(:make_default_resources)
       @catalog.finalize
     end
 
@@ -436,8 +449,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should optionally support an initialization block and should finalize after such blocks" do
-      @one.expects :finish
-      @two.expects :finish
+      expect(@one).to receive(:finish)
+      expect(@two).to receive(:finish)
       Puppet::Resource::Catalog.new("host") do |conf|
         conf.add_resource @one
         conf.add_resource @two
@@ -445,7 +458,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should inform the resource that it is the resource's catalog" do
-      @one.expects(:catalog=).with(@catalog)
+      expect(@one).to receive(:catalog=).with(@catalog)
       @catalog.add_resource @one
     end
 
@@ -528,14 +541,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")
-      @one.expects :remove
+      expect(@one).to receive(: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"
-      resource.expects(:isomorphic?).returns(true)
+      expect(resource).to receive(:isomorphic?).and_return(true)
       @catalog.add_resource(resource)
       expect(@catalog.resource(:file, "other")).to equal(resource)
       expect(@catalog.resource(:file, @basepath+"/something").ref).to eq(resource.ref)
@@ -543,7 +556,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"
-      resource.expects(:isomorphic?).returns(false)
+      expect(resource).to receive(:isomorphic?).and_return(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.
@@ -552,8 +565,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 = stub 'file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay"
-      Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
+      resource = double('file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay")
+      expect(Puppet::Type.type(:file)).to receive(:new).with(args).and_return(resource)
       @catalog.create_resource :file, args
       expect(@catalog.resource("File[/yay]")).to equal(resource)
     end
@@ -617,20 +630,20 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog = Puppet::Resource::Catalog.new("host")
 
       @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::Transaction).to receive(:new).and_return(@transaction)
+      allow(@transaction).to receive(:evaluate)
+      allow(@transaction).to receive(:for_network_device=)
 
-      Puppet.settings.stubs(:use)
+      allow(Puppet.settings).to receive(:use)
     end
 
     it "should create and evaluate a transaction" do
-      @transaction.expects(:evaluate)
+      expect(@transaction).to receive(:evaluate)
       @catalog.apply
     end
 
     it "should add a transaction evalution time to the report" do
-      @transaction.report.expects(:add_times).with(:transaction_evaluation, kind_of(Numeric))
+      expect(@transaction.report).to receive(:add_times).with(:transaction_evaluation, kind_of(Numeric))
       @catalog.apply
     end
 
@@ -654,17 +667,17 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should pass supplied tags on to the transaction" do
-      @transaction.expects(:tags=).with(%w{one two})
+      expect(@transaction).to receive(:tags=).with(%w{one two})
       @catalog.apply(:tags => %w{one two})
     end
 
     it "should set ignoreschedules on the transaction if specified in apply()" do
-      @transaction.expects(:ignoreschedules=).with(true)
+      expect(@transaction).to receive(:ignoreschedules=).with(true)
       @catalog.apply(:ignoreschedules => true)
     end
 
     it "should detect transaction failure and report it" do
-      @transaction.stubs(:evaluate).raises(RuntimeError, 'transaction failed.')
+      allow(@transaction).to receive(:evaluate).and_raise(RuntimeError, 'transaction failed.')
       report = Puppet::Transaction::Report.new('apply')
 
       expect { @catalog.apply(:report => report) }.to raise_error(RuntimeError)
@@ -674,31 +687,28 @@ 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
-        Puppet::Util::Storage.stubs(:store)
+        allow(Puppet::Util::Storage).to receive(:store)
       end
 
       it "should initialize the state database before applying a catalog" do
-        Puppet::Util::Storage.expects(:load)
+        expect(Puppet::Util::Storage).to receive(:load)
 
         # Short-circuit the apply, so we know we're loading before the transaction
-        Puppet::Transaction.expects(:new).raises ArgumentError
+        expect(Puppet::Transaction).to receive(:new).and_raise(ArgumentError)
         expect { @catalog.apply }.to raise_error(ArgumentError)
       end
 
       it "should sync the state database after applying" do
-        Puppet::Util::Storage.expects(:store)
-        @transaction.stubs :any_failed? => false
+        expect(Puppet::Util::Storage).to receive(:store)
+        allow(@transaction).to receive(:any_failed?).and_return(false)
         @catalog.apply
       end
-
     end
 
     describe "non-host catalogs" do
-
       before do
         @catalog.host_config = false
       end
@@ -710,11 +720,10 @@ describe Puppet::Resource::Catalog, "when compiling" do
       end
 
       it "should never modify the state database" do
-        Puppet::Util::Storage.expects(:load).never
-        Puppet::Util::Storage.expects(:store).never
+        expect(Puppet::Util::Storage).not_to receive(:load)
+        expect(Puppet::Util::Storage).not_to receive(:store)
         @catalog.apply
       end
-
     end
   end
 
@@ -724,7 +733,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should get removed when the catalog is cleaned up" do
-      @catalog.relationship_graph.expects(:clear)
+      expect(@catalog.relationship_graph).to receive(:clear)
 
       @catalog.clear
 
@@ -740,19 +749,18 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should only write when it is a host catalog" do
-      Puppet::FileSystem.expects(:open).with(@file, 0640, "w:UTF-8").never
+      expect(Puppet::FileSystem).not_to receive(:open).with(@file, 0640, "w:UTF-8")
       @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 = stub 'indirection', :name => :catalog
+      @indirection = double('indirection', :name => :catalog)
     end
 
     it "should use the value of the 'catalog_terminus' setting to determine its terminus class" do
@@ -877,7 +885,6 @@ describe Puppet::Resource::Catalog, "when converting a resource catalog to json"
         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
@@ -1012,9 +1019,7 @@ 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
 
@@ -1045,30 +1050,29 @@ 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 = stub 'one', :to_data_hash => "one_resource", :ref => "Foo[one]"
-    two = stub 'two', :to_data_hash => "two_resource", :ref => "Foo[two]"
+    one = double('one', :to_data_hash => "one_resource", :ref => "Foo[one]")
+    two = double('two', :to_data_hash => "two_resource", :ref => "Foo[two]")
 
-    one.expects(:'[]').with(:alias).returns nil
-    two.expects(:'[]').with(:alias).returns nil
+    expect(one).to receive(:'[]').with(:alias).and_return(nil)
+    expect(two).to receive(:'[]').with(:alias).and_return(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   = 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]'
+    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]')
 
     @catalog.add_edge(one, two)
     @catalog.add_edge(two, three)
 
-    @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(@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")
 
     expect(JSON.parse(@catalog.to_json,:create_additions => false)['edges'].sort).to eq(%w{one_two_json two_three_json}.sort)
   end