puppet 4.5.3-universal-darwin → 4.6.1-universal-darwin

data/spec/unit/module_spec.rb

@@ -614,13 +614,6 @@ describe Puppet::Module do
     expect(@module).to be_has_metadata
   end
 
-  it "should have metadata if it has a metadata file and its data is not empty" do
-    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "{\"foo\" : \"bar\"}"
-
-    expect(@module).to be_has_metadata
-  end
-
   it "should not have metadata if has a metadata file and its data is empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "This is some invalid json.\n"
@@ -651,6 +644,49 @@ describe Puppet::Module do
     expect(@module.has_metadata?).to be_falsey
   end
 
+  describe 'when --strict is warning' do
+    before :each do
+      Puppet[:strict] = :warning
+    end
+
+    it "should warn about a failure to parse" do
+      Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+      File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+      expect(@module.has_metadata?).to be_falsey
+      expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file/)
+    end
+  end
+
+    describe 'when --strict is off' do
+      before :each do
+        Puppet[:strict] = :off
+      end
+
+      it "should warn about a failure to parse" do
+        Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+        File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+        expect(@module.has_metadata?).to be_falsey
+        expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file.*/)
+      end
+    end
+
+    describe 'when --strict is error' do
+      before :each do
+        Puppet[:strict] = :error
+      end
+
+      it "should fail on a failure to parse" do
+        Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+        File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+        expect do
+        expect(@module.has_metadata?).to be_falsey
+        end.to raise_error(/mymod has an invalid and unparsable metadata\.json file/)
+      end
+    end
+
   def a_module_with_metadata(data)
     text = data.to_pson
 

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -4,6 +4,8 @@ require 'puppet_spec/module_tool/shared_functions'
 require 'puppet_spec/module_tool/stub_source'
 require 'semver'
 
+require 'tmpdir'
+
 describe Puppet::ModuleTool::Applications::Installer do
   include PuppetSpec::ModuleTool::SharedFunctions
   include PuppetSpec::Files
@@ -32,6 +34,13 @@ describe Puppet::ModuleTool::Applications::Installer do
     installer.stubs(:module_repository).returns(remote_source)
   end
 
+  if Puppet.features.microsoft_windows?
+    before :each do
+      Puppet.settings.stubs(:[])
+      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('installertmp'))
+    end
+  end
+
   def installer(modname, target_dir, options)
     Puppet::ModuleTool.set_option_defaults(options)
     Puppet::ModuleTool::Applications::Installer.new(modname, target_dir, options)
@@ -358,6 +367,6 @@ describe Puppet::ModuleTool::Applications::Installer do
         end
       end
     end
-
   end
+
 end

data/spec/unit/module_tool/applications/unpacker_spec.rb

@@ -14,7 +14,8 @@ describe Puppet::ModuleTool::Applications::Unpacker do
   let(:working_dir) { tmpdir("working_dir") }
 
   before :each do
-    Puppet.settings[:module_working_dir] = working_dir
+    Puppet.settings.stubs(:[])
+    Puppet.settings.stubs(:[]).with(:module_working_dir).returns(working_dir)
   end
 
   it "should attempt to untar file to temporary location" do

data/spec/unit/module_tool/applications/upgrader_spec.rb

@@ -3,6 +3,7 @@ require 'puppet/module_tool/applications'
 require 'puppet_spec/module_tool/shared_functions'
 require 'puppet_spec/module_tool/stub_source'
 require 'semver'
+require 'tmpdir'
 
 describe Puppet::ModuleTool::Applications::Upgrader do
   include PuppetSpec::ModuleTool::SharedFunctions
@@ -31,6 +32,13 @@ describe Puppet::ModuleTool::Applications::Upgrader do
     installer.stubs(:module_repository).returns(remote_source)
   end
 
+  if Puppet.features.microsoft_windows?
+    before :each do
+      Puppet.settings.stubs(:[])
+      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('upgradertmp'))
+    end
+  end
+
   def upgrader(name, options = {})
     Puppet::ModuleTool.set_option_defaults(options)
     Puppet::ModuleTool::Applications::Upgrader.new(name, options)

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"/thefile\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"/thefile\" under \"#{destdir}\"")
   end
 
   it "does not allow a file to be written outside the destination directory" do
@@ -29,7 +29,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
   end
 
   it "does not allow a directory to be written outside the destination directory" do
@@ -38,7 +38,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
   end
 
   it "packs a tar file" do

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

@@ -16,7 +16,6 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
-    handler.stubs(:check_authorization)
     handler.stubs(:warn_if_near_expiration)
   end
 
@@ -40,19 +39,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if there is no environment specified" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the environment is not alphanumeric" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not match the prefix" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not have the correct version" do
-      expect(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params) }).to raise_error(bad_request_error)
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
@@ -76,7 +75,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if the indirection name is not alphanumeric" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(bad_request_error)
     end
 
     it "should use the remainder of the URI as the indirection key" do
@@ -88,7 +87,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if no indirection key is specified" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to raise_error(bad_request_error)
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
@@ -124,7 +123,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if an indirection method cannot be picked" do
-      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(method_not_allowed_error)
     end
 
     it "should not URI unescape the indirection key" do
@@ -146,7 +145,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
                                                  Not(has_entry(:environment)))
       expect(lambda { handler.uri2indirection("GET",
                                               "#{master_url_prefix}/node/bar",
-                                              {:environment => 'bogus'}) }).to raise_error(ArgumentError)
+                                              {:environment => 'bogus'}) }).to raise_error(not_found_error)
     end
 
     it "should not URI unescape the indirection key as passed through to a call to check_authorization" do
@@ -219,46 +218,37 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
   end
 
   describe "when processing a request" do
-    it "should return not_authorized_code if the request is not authorized" do
-      request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
+    it "should raise not_authorized_error when authorization fails" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_heads(data)
 
       handler.expects(:check_authorization).raises(Puppet::Network::AuthorizationError.new("forbidden"))
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_authorized_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_authorized_error)
     end
 
-    it "should return 'not found' if the indirection does not support remote requests" do
+    it "should raise not_found_error if the indirection does not support remote requests" do
       request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
 
       indirection.expects(:allow_remote_requests?).returns(false)
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_found_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_found_error)
     end
 
-    it "should return 'bad request' if the environment does not exist" do
+    it "should raise not_found_error if the environment does not exist" do
       Puppet.override(:environments => Puppet::Environments::Static.new()) do
         request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
 
-        handler.call(request, response)
-
-        expect(response.code).to eq(bad_request_code)
+        expect {
+          handler.call(request, response)
+        }.to raise_error(not_found_error)
       end
     end
-
-    it "should serialize a controller exception when an exception is thrown while finding the model instance" do
-      request = a_request_that_finds(Puppet::IndirectorTesting.new("key"))
-      handler.expects(:do_find).raises(ArgumentError, "The exception")
-
-      handler.call(request, response)
-
-      expect(response.code).to eq(bad_request_code)
-      expect(response.body).to eq("The exception")
-      expect(response.type).to eq("text/plain")
-    end
   end
 
   describe "when finding a model instance" do
@@ -273,24 +263,24 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
-    it "responds with a not_acceptable_code error when no accept header is provided" do
+    it "raises not_acceptable_error when no accept header is provided" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => nil)
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_acceptable_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_acceptable_error)
     end
 
-    it "raises an error when no accepted formats are known" do
+    it "raises not_acceptable_error when no accepted formats are known" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => "unknown, also/unknown")
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_acceptable_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_acceptable_error)
     end
 
     it "should pass the result through without rendering it if the result is a string" do
@@ -305,12 +295,13 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
-    it "should return a not_found_code when no model instance can be found" do
+    it "should raise not_found_error when no model instance can be found" do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_finds(data, :accept_header => "unknown, text/pson")
 
-      handler.call(request, response)
-      expect(response.code).to eq(not_found_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_found_error)
     end
   end
 
@@ -335,13 +326,13 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
-    it "should return a not_found_code when searching returns nil" do
+    it "should raise not_found_error when searching returns nil" do
       request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, text/pson")
       indirection.expects(:search).returns(nil)
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_found_code)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_found_error)
     end
   end
 
@@ -383,9 +374,10 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       indirection.save(data, "my data")
       request = a_request_that_destroys(data, :accept_header => "unknown, also/unknown")
 
-      handler.call(request, response)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_acceptable_error)
 
-      expect(response.code).to eq(not_acceptable_code)
       expect(Puppet::IndirectorTesting.indirection.find("my data")).not_to be_nil
     end
   end
@@ -449,10 +441,11 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
 
-      handler.call(request, response)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_acceptable_error)
 
       expect(Puppet::IndirectorTesting.indirection.find("my data")).to be_nil
-      expect(response.code).to eq(not_acceptable_code)
     end
   end
 
@@ -467,15 +460,13 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.code).to eq(nil)
     end
 
-    it "should return a not_found_code when the model head call returns false" do
+    it "should raise not_found_error when the model head call returns false" do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_heads(data)
 
-      handler.call(request, response)
-
-      expect(response.code).to eq(not_found_code)
-      expect(response.type).to eq("text/plain")
-      expect(response.body).to eq("Not Found: Could not find indirector_testing my data")
+      expect {
+        handler.call(request, response)
+      }.to raise_error(not_found_error)
     end
   end
 end

data/spec/unit/network/http/api/master/v3_spec.rb

@@ -1,8 +1,11 @@
 require 'spec_helper'
 
 require 'puppet/network/http'
+require 'puppet_spec/network'
 
 describe Puppet::Network::HTTP::API::Master::V3 do
+  include PuppetSpec::Network
+
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
   let(:master_url_prefix) { "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3" }
   let(:master_routes) {
@@ -29,11 +32,11 @@ describe Puppet::Network::HTTP::API::Master::V3 do
     expect(response.code).to eq(200)
   end
 
-  it "responds to unknown paths with a 404" do
+  it "responds to unknown paths by raising not_found_error" do
     request = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_url_prefix}/unknown")
-    master_routes.process(request, response)
 
-    expect(response.code).to eq(404)
-    expect(response.body).to match("Not Found: Could not find indirection 'unknown'")
+    expect {
+      master_routes.process(request, response)
+    }.to raise_error(not_found_error)
   end
 end

data/spec/unit/network/rights_spec.rb

@@ -24,7 +24,7 @@ describe Puppet::Network::Rights do
       rights = Puppet::Network::Rights.new
       why_forbidden = rights.is_request_forbidden_and_why?(:head, "/indirection_name/key", {})
       expect(why_forbidden).to be_instance_of(Puppet::Network::AuthorizationError)
-      expect(why_forbidden.to_s).to eq("Forbidden request:  access to /indirection_name/key [find]")
+      expect(why_forbidden.to_s).to eq("Forbidden request: /indirection_name/key [find]")
     end
   end
 

data/spec/unit/parameter_spec.rb

@@ -190,4 +190,15 @@ describe Puppet::Parameter do
       )).to eq("{'1' => 'foo', 'bar' => ['2', '3', '4'], 'baz' => {'quux' => 'two', 'qux' => '1'}}")
     end
   end
+
+  describe 'formatting messages' do
+    it "formats messages as-is when the parameter is not sensitive" do
+      expect(@parameter.format("hello %s", "world")).to eq("hello world")
+    end
+
+    it "formats messages with redacted values when the parameter is not sensitive" do
+      @parameter.sensitive = true
+      expect(@parameter.format("hello %s", "world")).to eq("hello [redacted]")
+    end
+  end
 end

data/spec/unit/parser/compiler_spec.rb

@@ -99,10 +99,6 @@ describe Puppet::Parser::Compiler do
     expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /Compilation has been halted because.*bad environment/)
   end
 
-  it "should include the resource type collection helper" do
-    expect(Puppet::Parser::Compiler.ancestors).to be_include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   it "should be able to return a class list containing all added classes" do
     @compiler.add_class ""
     @compiler.add_class "one"
@@ -117,13 +113,8 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.node).to equal(@node)
     end
 
-    it "should detect when ast nodes are absent" do
-      expect(@compiler.ast_nodes?).to be_falsey
-    end
-
-    it "should detect when ast nodes are present" do
-      @known_resource_types.expects(:nodes?).returns true
-      expect(@compiler.ast_nodes?).to be_truthy
+    it "the set of ast_nodes should be empty" do
+      expect(@compiler.environment.known_resource_types.nodes?).to be_falsey
     end
 
     it "should copy the known_resource_types version to the catalog" do
@@ -608,14 +599,13 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should raise an error if a class is not found" do
-      @scope.expects(:find_hostclass).with("notfound").returns(nil)
+      @scope.environment.known_resource_types.expects(:find_hostclass).with("notfound").returns(nil)
       expect{ @compiler.evaluate_classes(%w{notfound}, @scope) }.to raise_error(Puppet::Error, /Could not find class/)
     end
 
     it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
-      @compiler.topscope.expects(:find_hostclass).with('foo').returns(nil)
       expect{ @compiler.compile }.to raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
@@ -624,9 +614,7 @@ describe Puppet::Parser::Compiler do
 
     before do
       Puppet.settings[:data_binding_terminus] = "none"
-      @class = stub 'class', :name => "my::class"
-      @scope.stubs(:find_hostclass).with("myclass").returns(@class)
-
+      @class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "myclass")
       @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
     end
 
@@ -658,7 +646,7 @@ describe Puppet::Parser::Compiler do
       def define_class(name, parameters)
         @node.classes[name] = parameters
         klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => @ast_obj, 'p2' => @ast_obj})
-        @compiler.topscope.known_resource_types.add klass
+        @compiler.environment.known_resource_types.add klass
       end
 
       def compile
@@ -697,7 +685,7 @@ describe Puppet::Parser::Compiler do
         ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
         klasses.each do |name|
           klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => ast_obj, 'p2' => ast_obj})
-          @compiler.topscope.known_resource_types.add klass
+          @compiler.environment.known_resource_types.add klass
         end
         catalog = @compiler.compile
 
@@ -710,7 +698,7 @@ describe Puppet::Parser::Compiler do
       klass = {'foo'=>{'a'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {'a' => nil, 'b' => nil})
-      @compiler.topscope.known_resource_types.add klass
+      @compiler.environment.known_resource_types.add klass
       expect { @compiler.compile }.to raise_error(Puppet::PreformattedError, /Class\[Foo\]: expects a value for parameter 'b'/)
     end
 
@@ -718,14 +706,14 @@ describe Puppet::Parser::Compiler do
       klass = {'foo'=>{'3'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
-      @compiler.topscope.known_resource_types.add klass
+      @compiler.environment.known_resource_types.add klass
       expect { @compiler.compile }.to raise_error(Puppet::PreformattedError, /Class\[Foo\]: has no parameter named '3'/)
     end
 
     it "should ensure class is in catalog without params" do
       @node.classes = klasses = {'foo'=>nil}
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
-      @compiler.topscope.known_resource_types.add foo
+      @compiler.environment.known_resource_types.add foo
       catalog = @compiler.compile
       expect(catalog.classes).to include 'foo'
     end
@@ -766,7 +754,7 @@ describe Puppet::Parser::Compiler do
 
     it "should skip classes previously evaluated with different capitalization" do
       @compiler.catalog.stubs(:tag)
-      @scope.stubs(:find_hostclass).with("MyClass").returns(@class)
+      @scope.environment.known_resource_types.stubs(:find_hostclass).with("MyClass").returns(@class)
       @scope.stubs(:class_scope).with(@class).returns(@scope)
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
@@ -778,8 +766,7 @@ describe Puppet::Parser::Compiler do
   describe "when evaluating AST nodes with no AST nodes present" do
 
     it "should do nothing" do
-      @compiler.expects(:ast_nodes?).returns(false)
-      @compiler.known_resource_types.expects(:nodes).never
+      @compiler.environment.known_resource_types.stubs(:nodes).returns(false)
       Puppet::Parser::Resource.expects(:new).never
 
       @compiler.send(:evaluate_ast_node)
@@ -789,16 +776,16 @@ describe Puppet::Parser::Compiler do
   describe "when evaluating AST nodes with AST nodes present" do
 
     before do
-      @compiler.known_resource_types.stubs(:nodes?).returns true
+      @compiler.environment.known_resource_types.stubs(:nodes?).returns true
 
       # Set some names for our test
       @node.stubs(:names).returns(%w{a b c})
-      @compiler.known_resource_types.stubs(:node).with("a").returns(nil)
-      @compiler.known_resource_types.stubs(:node).with("b").returns(nil)
-      @compiler.known_resource_types.stubs(:node).with("c").returns(nil)
+      @compiler.environment.known_resource_types.stubs(:node).with("a").returns(nil)
+      @compiler.environment.known_resource_types.stubs(:node).with("b").returns(nil)
+      @compiler.environment.known_resource_types.stubs(:node).with("c").returns(nil)
 
       # It should check this last, of course.
-      @compiler.known_resource_types.stubs(:node).with("default").returns(nil)
+      @compiler.environment.known_resource_types.stubs(:node).with("default").returns(nil)
     end
 
     it "should fail if the named node cannot be found" do
@@ -807,7 +794,7 @@ describe Puppet::Parser::Compiler do
 
     it "should evaluate the first node class matching the node name" do
       node_class = stub 'node', :name => "c", :evaluate_code => nil
-      @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
+      @compiler.environment.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
@@ -817,7 +804,7 @@ describe Puppet::Parser::Compiler do
 
     it "should match the default node if no matching node can be found" do
       node_class = stub 'node', :name => "default", :evaluate_code => nil
-      @compiler.known_resource_types.stubs(:node).with("default").returns(node_class)
+      @compiler.environment.known_resource_types.stubs(:node).with("default").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
@@ -827,7 +814,7 @@ describe Puppet::Parser::Compiler do
 
     it "should evaluate the node resource immediately rather than using lazy evaluation" do
       node_class = stub 'node', :name => "c"
-      @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
+      @compiler.environment.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
@@ -969,7 +956,6 @@ describe Puppet::Parser::Compiler do
     end
   end
 
-
   describe "when managing resource overrides" do
 
     before do