puppet 4.0.0 → 4.5.0

data/spec/unit/network/authconfig_spec.rb

@@ -3,80 +3,80 @@ require 'spec_helper'
 
 require 'puppet/network/authconfig'
 
-describe Puppet::Network::AuthConfig do
+describe Puppet::Network::DefaultAuthProvider do
   before :each do
     Puppet::FileSystem.stubs(:stat).returns stub('stat', :ctime => :now)
     Time.stubs(:now).returns Time.now
 
-    Puppet::Network::AuthConfig.any_instance.stubs(:exists?).returns(true)
-    # FIXME @authconfig = Puppet::Network::AuthConfig.new("dummy")
+    Puppet::Network::DefaultAuthProvider.any_instance.stubs(:exists?).returns(true)
+    # FIXME @authprovider = Puppet::Network::DefaultAuthProvider.new("dummy")
   end
 
   describe "when initializing" do
     it "inserts default ACLs after setting initial rights" do
-      Puppet::Network::AuthConfig.any_instance.expects(:insert_default_acl)
-      Puppet::Network::AuthConfig.new
+      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.new
     end
   end
 
   describe "when defining an acl with mk_acl" do
     before :each do
-      Puppet::Network::AuthConfig.any_instance.stubs(:insert_default_acl)
-      @authconfig = Puppet::Network::AuthConfig.new
+      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
+      @authprovider = Puppet::Network::DefaultAuthProvider.new
     end
 
     it "should create a new right for each default acl" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/']).to be
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/']).to be
     end
 
     it "allows everyone for each default right" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/']).to be_globalallow
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/']).to be_globalallow
     end
 
     it "accepts an argument to restrict the method" do
-      @authconfig.mk_acl(:acl => '/', :method => :find)
-      expect(@authconfig.rights['/'].methods).to eq([:find])
+      @authprovider.mk_acl(:acl => '/', :method => :find)
+      expect(@authprovider.rights['/'].methods).to eq([:find])
     end
 
     it "creates rights with authentication set to true by default" do
-      @authconfig.mk_acl(:acl => '/')
-      expect(@authconfig.rights['/'].authentication).to be_truthy
+      @authprovider.mk_acl(:acl => '/')
+      expect(@authprovider.rights['/'].authentication).to be_truthy
     end
 
     it "accepts an argument to set the authentication requirement" do
-      @authconfig.mk_acl(:acl => '/', :authenticated => :any)
-      expect(@authconfig.rights['/'].authentication).to be_falsey
+      @authprovider.mk_acl(:acl => '/', :authenticated => :any)
+      expect(@authprovider.rights['/'].authentication).to be_falsey
     end
   end
 
   describe "when adding default ACLs" do
     before :each do
-      Puppet::Network::AuthConfig.any_instance.stubs(:insert_default_acl)
-      @authconfig = Puppet::Network::AuthConfig.new
-      Puppet::Network::AuthConfig.any_instance.unstub(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
+      @authprovider = Puppet::Network::DefaultAuthProvider.new
+      Puppet::Network::DefaultAuthProvider.any_instance.unstub(:insert_default_acl)
     end
 
-    Puppet::Network::AuthConfig::default_acl.each do |acl|
+    Puppet::Network::DefaultAuthProvider::default_acl.each do |acl|
       it "should create a default right for #{acl[:acl]}" do
-        @authconfig.stubs(:mk_acl)
-        @authconfig.expects(:mk_acl).with(acl)
-        @authconfig.insert_default_acl
+        @authprovider.stubs(:mk_acl)
+        @authprovider.expects(:mk_acl).with(acl)
+        @authprovider.insert_default_acl
       end
     end
 
     it "should log at info loglevel" do
       Puppet.expects(:info).at_least_once
-      @authconfig.insert_default_acl
+      @authprovider.insert_default_acl
     end
 
     it "creates an empty catch-all rule for '/' for any authentication request state" do
-      @authconfig.stubs(:mk_acl)
+      @authprovider.stubs(:mk_acl)
 
-      @authconfig.insert_default_acl
-      expect(@authconfig.rights['/']).to be_empty
-      expect(@authconfig.rights['/'].authentication).to be_falsey
+      @authprovider.insert_default_acl
+      expect(@authprovider.rights['/']).to be_empty
+      expect(@authprovider.rights['/'].authentication).to be_falsey
     end
 
     it '(CVE-2013-2275) allows report submission only for the node matching the certname by default' do
@@ -86,9 +86,9 @@ describe Puppet::Network::AuthConfig do
         :allow => '$1',
         :authenticated => true
       }
-      @authconfig.stubs(:mk_acl)
-      @authconfig.expects(:mk_acl).with(acl)
-      @authconfig.insert_default_acl
+      @authprovider.stubs(:mk_acl)
+      @authprovider.expects(:mk_acl).with(acl)
+      @authprovider.insert_default_acl
     end
   end
 
@@ -107,3 +107,33 @@ describe Puppet::Network::AuthConfig do
     end
   end
 end
+
+describe Puppet::Network::AuthConfig do
+  after :each do
+    Puppet::Network::AuthConfig.authprovider_class = nil
+  end
+
+  class TestAuthProvider
+    def initialize(rights=nil); end
+    def check_authorization(method, path, params); end
+  end
+
+  it "instantiates authprovider_class with rights" do
+    Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
+    rights = Puppet::Network::Rights.new
+    TestAuthProvider.expects(:new).with(rights)
+    described_class.new(rights)
+  end
+
+  it "delegates authorization check to authprovider_class" do
+    Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
+    TestAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
+    described_class.new.check_authorization(:save, '/path/to/resource', {})
+  end
+
+  it "uses DefaultAuthProvider by default" do
+    Puppet::Network::AuthConfig.authprovider_class = nil
+    Puppet::Network::DefaultAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
+    described_class.new.check_authorization(:save, '/path/to/resource', {})
+  end
+end

data/spec/unit/network/authorization_spec.rb

@@ -1,5 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/network/http'
+require 'puppet/network/http/api/indirected_routes'
 require 'puppet/network/authorization'
 
 describe Puppet::Network::Authorization do
@@ -9,7 +11,7 @@ describe Puppet::Network::Authorization do
 
   subject { AuthTest.new }
 
-  describe "when creating an authconfig object" do
+  context "when creating an authconfig object" do
     before :each do
       # Other tests may have created an authconfig, so we have to undo that.
       @orig_auth_config = Puppet::Network::AuthConfigLoader.instance_variable_get(:@auth_config)
@@ -26,9 +28,35 @@ describe Puppet::Network::Authorization do
 
     it "creates default ACL entries if no file has been read" do
       Puppet::Network::AuthConfigParser.expects(:new_from_file).raises Errno::ENOENT
-      Puppet::Network::AuthConfig.any_instance.expects(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
 
       subject.authconfig
     end
   end
+
+  class TestAuthConfig
+    def check_authorization(method, path, params); end
+  end
+
+  class TestAuthConfigLoader
+    def self.authconfig
+      TestAuthConfig.new
+    end
+  end
+
+  context "when checking authorization" do
+    after :each do
+      Puppet::Network::Authorization.authconfigloader_class = nil
+    end
+
+    it "delegates to the authconfig object" do
+      Puppet::Network::Authorization.authconfigloader_class =
+          TestAuthConfigLoader
+      TestAuthConfig.any_instance.expects(:check_authorization).with(
+          :save, '/mypath', {:param1 => "value1"}).returns("yay, it worked!")
+      expect(subject.check_authorization(
+                 :save, '/mypath',
+                 {:param1 => "value1"})).to eq("yay, it worked!")
+    end
+  end
 end

data/spec/unit/network/authstore_spec.rb

@@ -180,7 +180,7 @@ describe Puppet::Network::AuthStore::Declaration do
   ].each { |invalid_ip|
     describe "when the pattern is an invalid IPv6 address such as #{invalid_ip}" do
       it "should raise an exception" do
-        expect { Puppet::Network::AuthStore::Declaration.new(:allow,invalid_ip) }.to raise_error
+        expect { Puppet::Network::AuthStore::Declaration.new(:allow,invalid_ip) }.to raise_error(Puppet::AuthStoreError, /Invalid pattern/)
       end
     end
   }
@@ -301,7 +301,7 @@ describe Puppet::Network::AuthStore::Declaration do
 
       issue_7477 = !(IPAddr.new(ip) rescue false)
 
-      describe "on rubies with a fix for issue [7477](http://goo.gl/Bb1LU)", :if => issue_7477
+      describe "on rubies with a fix for issue [7477](https://goo.gl/Bb1LU)", :if => issue_7477
         it "should match the specified IP" do
           expect(declaration).to be_match('www.testsite.org',ip)
         end

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -127,22 +127,17 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(ArgumentError)
     end
 
-    it "should URI unescape the indirection key" do
+    it "should not URI unescape the indirection key" do
       escaped = URI.escape("foo bar")
-      indirection, method, key, final_params = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
-      expect(key).to eq("foo bar")
+      indirection, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
+      expect(key).to eq(escaped)
     end
 
-    it "should pass through a proper environment param in a call to check_authorization" do
-      handler.expects(:check_authorization).with(anything,
-                                                 anything,
-                                                 all_of(
-                                                   has_entry(:environment,
-                                                             is_a(Puppet::Node::Environment)),
-                                                   has_entry(:environment,
-                                                             responds_with(:name,
-                                                                           :env))))
-      handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
+    it "should not unescape the URI passed through in a call to check_authorization" do
+      key_escaped = URI.escape("foo bar")
+      uri_escaped = "#{master_url_prefix}/node/#{key_escaped}"
+      handler.expects(:check_authorization).with(anything, uri_escaped, anything)
+      indirection, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
     end
 
     it "should not pass through an environment to check_authorization and fail if the environment is unknown" do
@@ -153,6 +148,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
                                               "#{master_url_prefix}/node/bar",
                                               {:environment => 'bogus'}) }).to raise_error(ArgumentError)
     end
+
+    it "should not URI unescape the indirection key as passed through to a call to check_authorization" do
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 all_of(
+                                                     has_entry(:environment,
+                                                               is_a(Puppet::Node::Environment)),
+                                                     has_entry(:environment,
+                                                               responds_with(:name,
+                                                                             :env))))
+      handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
+    end
+
   end
 
   describe "when converting a request into a URI" do

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::API::Master::V3::Environment do
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
+
+  around :each do |example|
+    environment = Puppet::Node::Environment.create(:production, [], '/manifests')
+    loader = Puppet::Environments::Static.new(environment)
+    Puppet.override(:environments => loader) do
+      example.run
+    end
+  end
+
+  it "returns the environment catalog" do
+    request = Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }, :routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(response.code).to eq(200)
+
+    catalog = JSON.parse(response.body)
+    expect(catalog['environment']).to eq('production')
+    expect(catalog['applications']).to eq({})
+  end
+
+  it "returns 404 if the environment doesn't exist" do
+    request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/development")
+
+    expect { subject.call(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError, /development is not a known environment/)
+  end
+
+  it "omits code_id if unspecified" do
+    request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to be_nil
+  end
+
+  it "includes code_id if specified" do
+    request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to eq('12345')
+  end
+
+  it "uses code_id from the catalog if it differs from the request" do
+    request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
+
+    Puppet::Resource::Catalog.any_instance.stubs(:code_id).returns('67890')
+
+    subject.call(request, response)
+
+    expect(JSON.parse(response.body)['code_id']).to eq('67890')
+  end
+end
+

data/spec/unit/network/http/compression_spec.rb

@@ -173,7 +173,7 @@ describe "http compression" do
       it "should raise the error the second time" do
         @inflater.stubs(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
         Zlib::Inflate.expects(:new).with.returns(@inflater)
-        expect { @adapter.uncompress("chunk") }.to raise_error
+        expect { @adapter.uncompress("chunk") }.to raise_error(Zlib::DataError, /not a zlib stream/)
       end
 
       it "should finish the stream on close" do

data/spec/unit/network/http/connection_spec.rb

@@ -42,31 +42,18 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  context "when methods that accept a block are called with a block" do
-    let (:host) { "my_server" }
+  context "when handling requests", :vcr do
+    let (:host) { "my-server" }
     let (:port) { 8140 }
     let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
 
-    before :each do
-      httpok.stubs(:body).returns ""
-
-      # This stubbing relies a bit more on knowledge of the internals of Net::HTTP
-      # than I would prefer, but it works on ruby 1.8.7 and 1.9.3, and it seems
-      # valuable enough to have tests for blocks that this is probably warranted.
-      socket = stub_everything("socket")
-      TCPSocket.stubs(:open).returns(socket)
-
-      Net::HTTP::Post.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Head.any_instance.stubs(:exec).returns("")
-      Net::HTTP::Get.any_instance.stubs(:exec).returns("")
-      Net::HTTPResponse.stubs(:read_new).returns(httpok)
-    end
-
-    [:request_get, :request_head, :request_post].each do |method|
+    { :request_get  => {},
+      :request_head => {},
+      :request_post => "param: value" }.each do |method,body|
       context "##{method}" do
         it "should yield to the block" do
           block_executed = false
-          subject.send(method, "/foo", {}) do |response|
+          subject.send(method, "/foo", body) do |response|
             block_executed = true
           end
           expect(block_executed).to eq(true)
@@ -118,6 +105,14 @@ describe Puppet::Network::HTTP::Connection do
     let (:host) { "my_server" }
     let (:port) { 8140 }
 
+    before :all do
+      WebMock.disable!
+    end
+
+    after :all do
+      WebMock.enable!
+    end
+
     it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
       connection = Puppet::Network::HTTP::Connection.new(
         host, port,
@@ -168,6 +163,7 @@ describe Puppet::Network::HTTP::Connection do
 
       Net::HTTP.any_instance.stubs(:start)
       Net::HTTP.any_instance.stubs(:request).returns(httpok)
+      Puppet::Network::HTTP::Pool.any_instance.stubs(:setsockopts)
 
       connection.get('request')
     end

data/spec/unit/network/http/factory_spec.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
+require 'puppet/util/http_proxy'
 
 describe Puppet::Network::HTTP::Factory do
   before :each do
@@ -41,13 +42,25 @@ describe Puppet::Network::HTTP::Factory do
 
     it "should not set a proxy if the value is 'none'" do
       Puppet[:http_proxy_host] = 'none'
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_address).to be_nil
     end
 
+    it 'should not set a proxy if a no_proxy env var matches the destination' do
+      Puppet[:http_proxy_host] = proxy_host
+      Puppet[:http_proxy_port] = proxy_port
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns true
+      conn = create_connection(site)
+
+      expect(conn.proxy_address).to be_nil
+      expect(conn.proxy_port).to be_nil
+    end
+
     it 'sets proxy_address' do
       Puppet[:http_proxy_host] = proxy_host
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_address).to eq(proxy_host)
@@ -56,6 +69,7 @@ describe Puppet::Network::HTTP::Factory do
     it 'sets proxy address and port' do
       Puppet[:http_proxy_host] = proxy_host
       Puppet[:http_proxy_port] = proxy_port
+      Puppet::Util::HttpProxy.expects(:no_proxy?).returns false
       conn = create_connection(site)
 
       expect(conn.proxy_port).to eq(proxy_port)

data/spec/unit/network/http/handler_spec.rb

@@ -131,11 +131,6 @@ describe Puppet::Network::HTTP::Handler do
       handler.process(request, response)
     end
 
-    it "should raise an error if the request is formatted in an unknown format" do
-      handler.stubs(:content_type_header).returns "unknown format"
-      expect { handler.request_format(request) }.to raise_error
-    end
-
     it "should still find the correct format if content type contains charset information" do
       request = Puppet::Network::HTTP::Request.new({ 'content-type' => "text/plain; charset=UTF-8" },
                                                    {}, 'GET', '/', nil)

data/spec/unit/network/http/pool_spec.rb

@@ -109,6 +109,31 @@ describe Puppet::Network::HTTP::Pool do
       end rescue nil
     end
 
+    it 'sets keepalive bit on network socket' do
+      pool = create_pool
+      s = Socket.new(Socket::PF_INET, Socket::SOCK_STREAM)
+      pool.setsockopts(Net::BufferedIO.new(s))
+
+      # On windows, Socket.getsockopt() doesn't return exactly the same data
+      # as an equivalent Socket::Option.new() statement, so we strip off the
+      # unrelevant bits only on this platform.
+      #
+      # To make sure we're not voiding the test case by doing this, we check
+      # both with and without the keepalive bit set.
+      #
+      # This workaround can be removed once all the ruby versions we care about
+      # have the patch from https://bugs.ruby-lang.org/issues/11958 applied.
+      #
+      if Puppet::Util::Platform.windows?
+        keepalive   = Socket::Option.bool(:INET, :SOCKET, :KEEPALIVE, true).data[0]
+        nokeepalive = Socket::Option.bool(:INET, :SOCKET, :KEEPALIVE, false).data[0]
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).data).to eq(keepalive)
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).data).to_not eq(nokeepalive)
+      else
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).bool).to eq(true)
+      end
+    end
+
     context 'when releasing connections' do
       it 'releases HTTP connections' do
         conn = create_connection(site)
@@ -150,6 +175,7 @@ describe Puppet::Network::HTTP::Pool do
       conn = create_connection(site)
       pool = create_pool
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -169,6 +195,7 @@ describe Puppet::Network::HTTP::Pool do
 
       conn = create_connection(site)
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -179,6 +206,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -205,6 +233,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool_with_expired_connections(site, conn)
       pool.factory.expects(:create_connection => stub('conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end
@@ -217,6 +246,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool_with_expired_connections(site, conn)
       pool.factory.expects(:create_connection => stub('open_conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end

data/spec/unit/network/http/rack/rest_spec.rb

@@ -65,6 +65,13 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
         expect(@handler.path(req)).to eq("/foo/bar")
       end
 
+      it "should return the unescaped path for an escaped request path" do
+        unescaped_path = '/foo/bar baz'
+        escaped_path = URI.escape(unescaped_path)
+        req = mk_req(escaped_path)
+        expect(@handler.path(req)).to eq(unescaped_path)
+      end
+
       it "should return the request body as the body" do
         req = mk_req('/foo/bar', :input => 'mybody')
         expect(@handler.body(req)).to eq("mybody")

data/spec/unit/network/rights_spec.rb

@@ -29,7 +29,7 @@ describe Puppet::Network::Rights do
   end
 
   it "should throw an error if type can't be determined" do
-    expect { @right.newright("name") }.to raise_error
+    expect { @right.newright("name") }.to raise_error(ArgumentError, /Unknown right type/)
   end
 
   describe "when creating new path ACLs" do
@@ -40,7 +40,7 @@ describe Puppet::Network::Rights do
     end
 
     it "should throw an error if the acl uri path is not absolute" do
-      expect { @right.newright("name")}.to raise_error
+      expect { @right.newright("name")}.to raise_error(ArgumentError, /Unknown right type/)
     end
 
     it "should create a new ACL with the correct path" do
@@ -351,7 +351,7 @@ describe Puppet::Network::Rights do
     it "should raise an error if the method is already filtered" do
       @acl.restrict_method(:save)
 
-      expect { @acl.restrict_method(:save) }.to raise_error
+      expect { @acl.restrict_method(:save) }.to raise_error(ArgumentError, /'save' is already in the '\/path'/)
     end
 
     it "should allow setting an environment filters" do

data/spec/unit/node/environment_spec.rb

@@ -428,6 +428,16 @@ describe Puppet::Node::Environment do
     end
 
     describe "when performing initial import" do
+      let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+      around :each do |example|
+        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        Puppet.override(:loaders => loaders, :current_environment => env) do
+          example.run
+          Puppet::Pops::Loaders.clear
+        end
+      end
+
       it "loads from Puppet[:code]" do
         Puppet[:code] = "define foo {}"
         krt = env.known_resource_types