puppet 6.0.10 → 6.1.0

data/spec/unit/network/http_pool_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http_pool'
 
@@ -50,22 +51,22 @@ describe Puppet::Network::HttpPool do
         ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
 
         Puppet[:ssl_client_ca_auth] = ca_cert_file
-        allow(Puppet::FileSystem).to receive(:exist?).with(ca_cert_file).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(ca_cert_file).returns(true)
       end
 
       def setup_standard_hostcert
         host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
-        allow(Puppet::FileSystem).to receive(:exist?).with(host_cert_file).and_return(true)
+        Puppet::FileSystem.stubs(:exist?).with(host_cert_file).returns(true)
 
         Puppet[:hostcert] = host_cert_file
       end
 
       def setup_standard_ssl_host
-        cert = double('cert', :content => 'real_cert')
-        key  = double('key',  :content => 'real_key')
-        host = double('host', :certificate => cert, :key => key, :ssl_store => double('store'))
+        cert = stub('cert', :content => 'real_cert')
+        key  = stub('key',  :content => 'real_key')
+        host = stub('host', :certificate => cert, :key => key, :ssl_store => stub('store'))
 
-        allow(Puppet::SSL::Host).to receive(:localhost).and_return(host)
+        Puppet::SSL::Host.stubs(:localhost).returns(host)
       end
 
       before do
@@ -77,24 +78,14 @@ describe Puppet::Network::HttpPool do
       it 'enables peer verification by default' do
         response = Net::HTTPOK.new('1.1', 200, 'body')
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true)
-        expect(conn).to receive(:execute_request) do |http, _|
-          expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-
-          response
-        end
-
+        conn.expects(:execute_request).with { |http, request| expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER) }.returns(response)
         conn.get('/')
       end
 
       it 'can disable peer verification' do
         response = Net::HTTPOK.new('1.1', 200, 'body')
         conn = Puppet::Network::HttpPool.http_instance("me", 54321, true, false)
-        expect(conn).to receive(:execute_request) do |http, _|
-          expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
-
-          response
-        end
-
+        conn.expects(:execute_request).with { |http, request| expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE) }.returns(response)
         conn.get('/')
       end
     end

data/spec/unit/network/http_spec.rb

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

data/spec/unit/network/resolver_spec.rb

@@ -1,10 +1,11 @@
+#!/usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/resolver'
 
 describe Puppet::Network::Resolver do
   before do
-    @dns_mock_object = double('dns')
-    allow(Resolv::DNS).to receive(:new).and_return(@dns_mock_object)
+    @dns_mock_object = mock('dns')
+    Resolv::DNS.stubs(:new).returns(@dns_mock_object)
 
     @rr_type         = Resolv::DNS::Resource::IN::SRV
     @test_srv_domain = "domain.com"
@@ -30,7 +31,7 @@ describe Puppet::Network::Resolver do
 
   describe 'when the domain is not known' do
     before :each do
-      allow(@dns_mock_object).to receive(:getresources).and_return(@test_records)
+      @dns_mock_object.stubs(:getresources).returns(@test_records)
     end
 
     describe 'because domain is nil' do
@@ -54,10 +55,10 @@ describe Puppet::Network::Resolver do
 
     it "should not yield anything" do
       # No records returned for a DNS entry without any SRV records
-      expect(@dns_mock_object).to receive(:getresources).with(
+      @dns_mock_object.expects(:getresources).with(
         "_x-puppet._tcp.#{@test_a_hostname}",
         @rr_type
-      ).and_return([])
+      ).returns([])
 
       resolver.each_srv_record(@test_a_hostname) do |hostname, port, remaining|
         raise Exception.new("host with no records passed block")
@@ -75,10 +76,10 @@ describe Puppet::Network::Resolver do
         2 => ["puppet4.domain.com"]
       }
 
-      expect(@dns_mock_object).to receive(:getresources).with(
+      @dns_mock_object.expects(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).and_return(@test_records)
+      ).returns(@test_records)
 
       resolver.each_srv_record(@test_srv_domain) do |hostname, port|
         expected_priority = order.keys.min
@@ -103,15 +104,15 @@ describe Puppet::Network::Resolver do
         2 => ["puppet4.domain.com"]
       }
 
-      expect(@dns_mock_object).to receive(:getresources).with(
+      @dns_mock_object.expects(:getresources).with(
         "_x-puppet-report._tcp.#{@test_srv_domain}",
         @rr_type
-      ).and_return([])
+      ).returns([])
 
-      expect(@dns_mock_object).to receive(:getresources).with(
+      @dns_mock_object.expects(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).and_return(@test_records)
+      ).returns(@test_records)
 
       resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
@@ -144,15 +145,15 @@ describe Puppet::Network::Resolver do
         Resolv::DNS::Resource::IN::SRV.new(4,         1,      8140, "puppet4.bad.domain.com")
       ]
 
-      expect(@dns_mock_object).to receive(:getresources).with(
+      @dns_mock_object.expects(:getresources).with(
         "_x-puppet-report._tcp.#{@test_srv_domain}",
         @rr_type
-      ).and_return(@test_records)
+      ).returns(@test_records)
 
-      allow(@dns_mock_object).to receive(:getresources).with(
+      @dns_mock_object.stubs(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).and_return(bad_records)
+      ).returns(bad_records)
 
       resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
@@ -199,7 +200,7 @@ describe Puppet::Network::Resolver do
         end
 
         total_weight.times do |n|
-          expect(Kernel).to receive(:rand).once.with(total_weight).and_return(n)
+          Kernel.expects(:rand).once.with(total_weight).returns(n)
           server = resolver.find_weighted_server(records)
           seen[server] += 1
         end
@@ -214,10 +215,10 @@ describe Puppet::Network::Resolver do
 
   describe "caching records" do
     it "should query DNS when no cache entry exists, then retrieve the cached value" do
-      expect(@dns_mock_object).to receive(:getresources).with(
+      @dns_mock_object.expects(:getresources).with(
         "_x-puppet._tcp.#{@test_srv_domain}",
         @rr_type
-      ).and_return(@test_records).once
+      ).returns(@test_records).once
 
       fetched_servers = []
       resolver.each_srv_record(@test_srv_domain) do |server, port|
@@ -225,7 +226,7 @@ describe Puppet::Network::Resolver do
       end
 
       cached_servers = []
-      expect(resolver).to receive(:expired?).and_return(false)
+      resolver.expects(:expired?).returns false
       resolver.each_srv_record(@test_srv_domain) do |server, port|
         cached_servers << server
       end
@@ -241,10 +242,10 @@ describe Puppet::Network::Resolver do
         ttl_record2.instance_variable_set(:@ttl, 20)
         records = [ttl_record1, ttl_record2]
 
-        expect(@dns_mock_object).to receive(:getresources).with(
+        @dns_mock_object.expects(:getresources).with(
           "_x-puppet._tcp.#{@test_srv_domain}",
           @rr_type
-        ).and_return(records)
+        ).returns(records)
       end
 
       it "should save the shortest TTL among records for a service" do
@@ -258,7 +259,7 @@ describe Puppet::Network::Resolver do
           expect(server).to match(/puppet.*domain\.com/)
         end
 
-        expect(resolver).to receive(:expired?).with(:puppet).and_return(false)
+        resolver.expects(:expired?).with(:puppet).returns false
         # Load from cache
         resolver.each_srv_record(@test_srv_domain) do |server, port|
           expect(server).to match(/puppet.*domain\.com/)
@@ -266,11 +267,11 @@ describe Puppet::Network::Resolver do
 
         new_record = Resolv::DNS::Resource::IN::SRV.new(0, 20, 8140, "new.domain.com")
         new_record.instance_variable_set(:@ttl, 10)
-        expect(@dns_mock_object).to receive(:getresources).with(
+        @dns_mock_object.expects(:getresources).with(
           "_x-puppet._tcp.#{@test_srv_domain}",
           @rr_type
-        ).and_return([new_record])
-        expect(resolver).to receive(:expired?).with(:puppet).and_return(true)
+        ).returns([new_record])
+        resolver.expects(:expired?).with(:puppet).returns true
         # Refresh from DNS
         resolver.each_srv_record(@test_srv_domain) do |server, port|
           expect(server).to eq("new.domain.com")

data/spec/unit/network/rights_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/rights'
@@ -117,58 +118,58 @@ describe Puppet::Network::Rights do
 
   describe "when checking if right is allowed" do
     before :each do
-      allow(@right).to receive(:right).and_return(nil)
+      @right.stubs(:right).returns(nil)
 
-      @pathacl = double('pathacl', :"<=>" => 1, :line => 0, :file => 'dummy')
-      allow(Puppet::Network::Rights::Right).to receive(:new).and_return(@pathacl)
+      @pathacl = stub 'pathacl', :"<=>" => 1, :line => 0, :file => 'dummy'
+      Puppet::Network::Rights::Right.stubs(:new).returns(@pathacl)
     end
 
     it "should delegate to is_forbidden_and_why?" do
-      expect(@right).to receive(:is_forbidden_and_why?).with("namespace", :node => "host.domain.com", :ip => "127.0.0.1").and_return(nil)
+      @right.expects(:is_forbidden_and_why?).with("namespace", :node => "host.domain.com", :ip => "127.0.0.1").returns(nil)
 
       @right.allowed?("namespace", "host.domain.com", "127.0.0.1")
     end
 
     it "should return true if is_forbidden_and_why? returns nil" do
-      allow(@right).to receive(:is_forbidden_and_why?).and_return(nil)
+      @right.stubs(:is_forbidden_and_why?).returns(nil)
       expect(@right.allowed?("namespace", :args)).to be_truthy
     end
 
     it "should return false if is_forbidden_and_why? returns an AuthorizationError" do
-      allow(@right).to receive(:is_forbidden_and_why?).and_return(Puppet::Network::AuthorizationError.new("forbidden"))
+      @right.stubs(:is_forbidden_and_why?).returns(Puppet::Network::AuthorizationError.new("forbidden"))
       expect(@right.allowed?("namespace", :args1, :args2)).to be_falsey
     end
 
     it "should pass the match? return to allowed?" do
       @right.newright("/path/to/there")
 
-      expect(@pathacl).to receive(:match?).and_return(:match)
-      expect(@pathacl).to receive(:allowed?).with(anything, anything, hash_including(match: :match)).and_return(true)
+      @pathacl.expects(:match?).returns(:match)
+      @pathacl.expects(:allowed?).with { |node,ip,h| h[:match] == :match }.returns(true)
 
       expect(@right.is_forbidden_and_why?("/path/to/there", {})).to eq(nil)
     end
 
     describe "with path acls" do
       before :each do
-        @long_acl = double('longpathacl', :name => "/path/to/there", :line => 0, :file => 'dummy')
-        allow(Puppet::Network::Rights::Right).to receive(:new).with("/path/to/there", 0, nil).and_return(@long_acl)
+        @long_acl = stub 'longpathacl', :name => "/path/to/there", :line => 0, :file => 'dummy'
+        Puppet::Network::Rights::Right.stubs(:new).with("/path/to/there", 0, nil).returns(@long_acl)
 
-        @short_acl = double('shortpathacl', :name => "/path/to", :line => 0, :file => 'dummy')
-        allow(Puppet::Network::Rights::Right).to receive(:new).with("/path/to", 0, nil).and_return(@short_acl)
+        @short_acl = stub 'shortpathacl', :name => "/path/to", :line => 0, :file => 'dummy'
+        Puppet::Network::Rights::Right.stubs(:new).with("/path/to", 0, nil).returns(@short_acl)
 
-        allow(@long_acl).to receive(:"<=>").with(@short_acl).and_return(0)
-        allow(@short_acl).to receive(:"<=>").with(@long_acl).and_return(0)
+        @long_acl.stubs(:"<=>").with(@short_acl).returns(0)
+        @short_acl.stubs(:"<=>").with(@long_acl).returns(0)
       end
 
       it "should select the first match" do
         @right.newright("/path/to", 0)
         @right.newright("/path/to/there", 0)
 
-        allow(@long_acl).to receive(:match?).and_return(true)
-        allow(@short_acl).to receive(:match?).and_return(true)
+        @long_acl.stubs(:match?).returns(true)
+        @short_acl.stubs(:match?).returns(true)
 
-        expect(@short_acl).to receive(:allowed?).and_return(true)
-        expect(@long_acl).not_to receive(:allowed?)
+        @short_acl.expects(:allowed?).returns(true)
+        @long_acl.expects(:allowed?).never
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -177,11 +178,11 @@ describe Puppet::Network::Rights do
         @right.newright("/path/to/there", 0, nil)
         @right.newright("/path/to", 0, nil)
 
-        allow(@long_acl).to receive(:match?).and_return(true)
-        allow(@short_acl).to receive(:match?).and_return(true)
+        @long_acl.stubs(:match?).returns(true)
+        @short_acl.stubs(:match?).returns(true)
 
-        expect(@long_acl).to receive(:allowed?).and_return(:dunno)
-        expect(@short_acl).to receive(:allowed?).and_return(true)
+        @long_acl.expects(:allowed?).returns(:dunno)
+        @short_acl.expects(:allowed?).returns(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -190,11 +191,11 @@ describe Puppet::Network::Rights do
         @right.newright("/path/to/there", 0)
         @right.newright("/path/to", 0)
 
-        allow(@long_acl).to receive(:match?).and_return(false)
-        allow(@short_acl).to receive(:match?).and_return(true)
+        @long_acl.stubs(:match?).returns(false)
+        @short_acl.stubs(:match?).returns(true)
 
-        expect(@long_acl).not_to receive(:allowed?)
-        expect(@short_acl).to receive(:allowed?).and_return(true)
+        @long_acl.expects(:allowed?).never
+        @short_acl.expects(:allowed?).returns(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -202,8 +203,8 @@ describe Puppet::Network::Rights do
       it "should not raise an AuthorizationError if allowed" do
         @right.newright("/path/to/there", 0)
 
-        allow(@long_acl).to receive(:match?).and_return(true)
-        allow(@long_acl).to receive(:allowed?).and_return(true)
+        @long_acl.stubs(:match?).returns(true)
+        @long_acl.stubs(:allowed?).returns(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -211,8 +212,8 @@ describe Puppet::Network::Rights do
       it "should raise an AuthorizationError if the match is denied" do
         @right.newright("/path/to/there", 0, nil)
 
-        allow(@long_acl).to receive(:match?).and_return(true)
-        allow(@long_acl).to receive(:allowed?).and_return(false)
+        @long_acl.stubs(:match?).returns(true)
+        @long_acl.stubs(:allowed?).returns(false)
 
         expect(@right.is_forbidden_and_why?("/path/to/there", {})).to be_instance_of(Puppet::Network::AuthorizationError)
       end
@@ -224,25 +225,25 @@ describe Puppet::Network::Rights do
 
     describe "with regex acls" do
       before :each do
-        @regex_acl1 = double('regex_acl1', :name => "/files/(.*)/myfile", :line => 0, :file => 'dummy')
-        allow(Puppet::Network::Rights::Right).to receive(:new).with("~ /files/(.*)/myfile", 0, nil).and_return(@regex_acl1)
+        @regex_acl1 = stub 'regex_acl1', :name => "/files/(.*)/myfile", :line => 0, :file => 'dummy'
+        Puppet::Network::Rights::Right.stubs(:new).with("~ /files/(.*)/myfile", 0, nil).returns(@regex_acl1)
 
-        @regex_acl2 = double('regex_acl2', :name => "/files/(.*)/myfile/", :line => 0, :file => 'dummy')
-        allow(Puppet::Network::Rights::Right).to receive(:new).with("~ /files/(.*)/myfile/", 0, nil).and_return(@regex_acl2)
+        @regex_acl2 = stub 'regex_acl2', :name => "/files/(.*)/myfile/", :line => 0, :file => 'dummy'
+        Puppet::Network::Rights::Right.stubs(:new).with("~ /files/(.*)/myfile/", 0, nil).returns(@regex_acl2)
 
-        allow(@regex_acl1).to receive(:"<=>").with(@regex_acl2).and_return(0)
-        allow(@regex_acl2).to receive(:"<=>").with(@regex_acl1).and_return(0)
+        @regex_acl1.stubs(:"<=>").with(@regex_acl2).returns(0)
+        @regex_acl2.stubs(:"<=>").with(@regex_acl1).returns(0)
       end
 
       it "should select the first match" do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        allow(@regex_acl1).to receive(:match?).and_return(true)
-        allow(@regex_acl2).to receive(:match?).and_return(true)
+        @regex_acl1.stubs(:match?).returns(true)
+        @regex_acl2.stubs(:match?).returns(true)
 
-        expect(@regex_acl1).to receive(:allowed?).and_return(true)
-        expect(@regex_acl2).not_to receive(:allowed?)
+        @regex_acl1.expects(:allowed?).returns(true)
+        @regex_acl2.expects(:allowed?).never
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -251,11 +252,11 @@ describe Puppet::Network::Rights do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        allow(@regex_acl1).to receive(:match?).and_return(true)
-        allow(@regex_acl2).to receive(:match?).and_return(true)
+        @regex_acl1.stubs(:match?).returns(true)
+        @regex_acl2.stubs(:match?).returns(true)
 
-        expect(@regex_acl1).to receive(:allowed?).and_return(:dunno)
-        expect(@regex_acl2).to receive(:allowed?).and_return(true)
+        @regex_acl1.expects(:allowed?).returns(:dunno)
+        @regex_acl2.expects(:allowed?).returns(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -264,11 +265,11 @@ describe Puppet::Network::Rights do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        allow(@regex_acl1).to receive(:match?).and_return(false)
-        allow(@regex_acl2).to receive(:match?).and_return(true)
+        @regex_acl1.stubs(:match?).returns(false)
+        @regex_acl2.stubs(:match?).returns(true)
 
-        expect(@regex_acl1).not_to receive(:allowed?)
-        expect(@regex_acl2).to receive(:allowed?).and_return(true)
+        @regex_acl1.expects(:allowed?).never
+        @regex_acl2.expects(:allowed?).returns(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -276,8 +277,8 @@ describe Puppet::Network::Rights do
       it "should not raise an AuthorizationError if allowed" do
         @right.newright("~ /files/(.*)/myfile", 0)
 
-        allow(@regex_acl1).to receive(:match?).and_return(true)
-        allow(@regex_acl1).to receive(:allowed?).and_return(true)
+        @regex_acl1.stubs(:match?).returns(true)
+        @regex_acl1.stubs(:allowed?).returns(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -424,13 +425,13 @@ describe Puppet::Network::Rights do
       end
 
       it "should interpolate allow/deny patterns with the given match" do
-        expect(@acl).to receive(:interpolate).with(:match)
+        @acl.expects(:interpolate).with(:match)
 
         @acl.allowed?("me","127.0.0.1", { :method => :save, :match => :match, :authenticated => true })
       end
 
       it "should reset interpolation after the match" do
-        expect(@acl).to receive(:reset_interpolation)
+        @acl.expects(:reset_interpolation)
 
         @acl.allowed?("me","127.0.0.1", { :method => :save, :match => :match, :authenticated => true })
       end

data/spec/unit/node/environment_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'tmpdir'
@@ -111,7 +112,7 @@ describe Puppet::Node::Environment do
 
     describe "when managing known resource types" do
       before do
-        allow(env).to receive(:perform_initial_import).and_return(Puppet::Parser::AST::Hostclass.new(''))
+        env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       end
 
       it "creates a resource type collection if none exists" do
@@ -123,13 +124,13 @@ describe Puppet::Node::Environment do
       end
 
       it "performs the initial import when creating a new collection" do
-        expect(env).to receive(:perform_initial_import).and_return(Puppet::Parser::AST::Hostclass.new(''))
+        env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
         env.known_resource_types
       end
 
       it "generates a new TypeCollection if the current one requires reparsing" do
         old_type_collection = env.known_resource_types
-        allow(old_type_collection).to receive(:parse_failed?).and_return(true)
+        old_type_collection.stubs(:parse_failed?).returns true
 
         env.check_for_reparse
 
@@ -170,7 +171,7 @@ describe Puppet::Node::Environment do
       end
 
       context "when disable_per_environment_manifest is true" do
-        let(:config) { double('config') }
+        let(:config) { mock('config') }
         let(:global_modulepath) { ["/global/modulepath"] }
         let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, global_modulepath) }
 
@@ -179,12 +180,12 @@ describe Puppet::Node::Environment do
         end
 
         def assert_manifest_conflict(expectation, envconf_manifest_value)
-          expect(config).to receive(:setting).with(:manifest).and_return(
-            double('setting', :value => envconf_manifest_value)
+          config.expects(:setting).with(:manifest).returns(
+            mock('setting', :value => envconf_manifest_value)
           )
           environment = Puppet::Node::Environment.create(:directory, [], '/default/manifests/site.pp')
           loader = Puppet::Environments::Static.new(environment)
-          allow(loader).to receive(:get_conf).and_return(envconf)
+          loader.stubs(:get_conf).returns(envconf)
 
           Puppet.override(:environments => loader) do
             if expectation
@@ -403,7 +404,7 @@ describe Puppet::Node::Environment do
           it "creates modules with the correct environment" do
             PuppetSpec::Modules.generate_files('foo', first_modulepath)
 
-            env.modules.each do |mod|
+            env.modules.each do |mod| 
               expect(mod.environment).to eq(env)
             end
           end
@@ -418,7 +419,7 @@ describe Puppet::Node::Environment do
               }
             )
 
-            expect(Puppet).to receive(:log_exception).with(be_a(Puppet::Module::MissingMetadata))
+            Puppet.expects(:log_exception).with(is_a(Puppet::Module::MissingMetadata))
 
             env.modules
           end
@@ -430,7 +431,7 @@ describe Puppet::Node::Environment do
       let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
       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})
       end
 
@@ -494,9 +495,9 @@ describe Puppet::Node::Environment do
 
   describe "managing module translations" do
     it "creates a new text domain the first time we try to use the text domain" do
-      expect(Puppet::GettextConfig).to receive(:reset_text_domain).with(env.name)
-      expect(Puppet::ModuleTranslations).to receive(:load_from_modulepath)
-      expect(Puppet::GettextConfig).to receive(:clear_text_domain)
+      Puppet::GettextConfig.expects(:reset_text_domain).with(env.name)
+      Puppet::ModuleTranslations.expects(:load_from_modulepath)
+      Puppet::GettextConfig.expects(:clear_text_domain)
 
       env.with_text_domain do; end
     end
@@ -504,7 +505,7 @@ describe Puppet::Node::Environment do
     it "uses the existing text domain once it has been created" do
       env.with_text_domain do; end
 
-      expect(Puppet::GettextConfig).to receive(:use_text_domain).with(env.name)
+      Puppet::GettextConfig.expects(:use_text_domain).with(env.name)
       env.with_text_domain do; end
     end