puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

data/spec/unit/puppet_pal_2pec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_pal'
@@ -385,8 +386,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
@@ -512,7 +513,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' => {
@@ -942,7 +943,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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 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'
@@ -24,8 +25,8 @@ describe Puppet do
   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',
@@ -35,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',
@@ -46,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',

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,14 +6,15 @@ 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)
+      Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
       Puppet.push_context({:loaders => loaders, :current_environment => env})
       if mock_pdb
         module Puppet::Util::Puppetdb
@@ -33,7 +35,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) { 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
@@ -44,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')
@@ -54,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
@@ -70,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
@@ -90,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
@@ -111,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
@@ -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
@@ -630,20 +617,20 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog = Puppet::Resource::Catalog.new("host")
 
       @transaction = Puppet::Transaction.new(@catalog, nil, Puppet::Graph::SequentialPrioritizer.new)
-      allow(Puppet::Transaction).to receive(:new).and_return(@transaction)
-      allow(@transaction).to receive(:evaluate)
-      allow(@transaction).to receive(:for_network_device=)
+      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
@@ -885,6 +877,7 @@ 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
@@ -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