puppet 3.3.2 → 3.4.0.rc1

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

@@ -38,6 +38,9 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     class Puppet::TestModel::Memory < Puppet::Indirector::Memory
+      def supports_remote_requests?
+        true
+      end
     end
 
     Puppet::TestModel.indirection.terminus_class = :memory
@@ -150,9 +153,7 @@ describe Puppet::Network::HTTP::Handler do
 
   describe "when processing a request" do
     let(:response) do
-      obj = stub "http 200 ok"
-      obj.stubs(:[]=).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION, Puppet.version)
-      obj
+      { :status => 200 }
     end
 
     before do
@@ -163,7 +164,6 @@ describe Puppet::Network::HTTP::Handler do
     it "should check the client certificate for upcoming expiration" do
       request = a_request
       cert = mock 'cert'
-      handler.stubs(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
       handler.expects(:client_cert).returns(cert).with(request)
       handler.expects(:warn_if_near_expiration).with(cert)
 
@@ -201,33 +201,31 @@ describe Puppet::Network::HTTP::Handler do
       handler.process(request, response)
     end
 
-    it "should call the 'do' method and delegate authorization to the authorization layer" do
+    it "should return 403 if the request is not authorized" do
       request = a_request
       handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
 
-      handler.expects(:do_mymethod).with("facts", "key", {:node => "name"}, request, response)
+      handler.expects(:do_mymethod).never
+
+      handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"}).raises(Puppet::Network::AuthorizationError.new("forbidden"))
 
-      handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"})
+      handler.expects(:set_response).with(anything, anything, 403)
 
       handler.process(request, response)
     end
 
-    it "should return 403 if the request is not authorized" do
+    it "should return an error code if the indirection does not support remote requests" do
       request = a_request
-      handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
 
-      handler.expects(:do_mymethod).never
-
-      handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"}).raises(Puppet::Network::AuthorizationError.new("forbidden"))
-
-      handler.expects(:set_response).with(anything, anything, 403)
+      indirection.expects(:allow_remote_requests?).returns(false)
 
       handler.process(request, response)
+
+      expect(response[:status]).to eq 404
     end
 
     it "should serialize a controller exception when an exception is thrown while finding the model instance" do
-      request = a_request
-      handler.expects(:uri2indirection).returns(["facts", :find, "key", {:node => "name"}])
+      request = a_request_that_finds(Puppet::TestModel.new("key"))
 
       handler.expects(:do_find).raises(ArgumentError, "The exception")
       handler.expects(:set_response).with(anything, "The exception", 400)
@@ -302,7 +300,7 @@ describe Puppet::Network::HTTP::Handler do
         handler.expects(:set_response).with(response, data.render(:pson))
         handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        handler.do_find(indirection.name, "my data", {}, request, response)
+        handler.do_find(indirection, "my data", {}, request, response)
       end
 
       it "responds with a 406 error when no accept header is provided" do
@@ -311,7 +309,7 @@ describe Puppet::Network::HTTP::Handler do
         request = a_request_that_finds(data, :accept_header => nil)
 
         expect do
-          handler.do_find(indirection.name, "my data", {}, request, response)
+          handler.do_find(indirection, "my data", {}, request, response)
         end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
       end
 
@@ -321,7 +319,7 @@ describe Puppet::Network::HTTP::Handler do
         request = a_request_that_finds(data, :accept_header => "unknown, also/unknown")
 
         expect do
-          handler.do_find(indirection.name, "my data", {}, request, response)
+          handler.do_find(indirection, "my data", {}, request, response)
         end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
       end
 
@@ -334,7 +332,7 @@ describe Puppet::Network::HTTP::Handler do
         handler.expects(:set_response).with(response, data_string)
         handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        handler.do_find(indirection.name, "my data", {}, request, response)
+        handler.do_find(indirection, "my data", {}, request, response)
       end
 
       it "should return a 404 when no model instance can be found" do
@@ -342,7 +340,7 @@ describe Puppet::Network::HTTP::Handler do
         request = a_request_that_finds(data, :accept_header => "unknown, pson, yaml")
 
         expect do
-          handler.do_find(indirection.name, "my data", {}, request, response)
+          handler.do_find(indirection, "my data", {}, request, response)
         end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotFoundError)
       end
     end
@@ -377,7 +375,7 @@ describe Puppet::Network::HTTP::Handler do
         handler.expects(:set_response).with(response, Puppet::TestModel.render_multiple(:pson, [data]))
         handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        handler.do_search(indirection.name, "my", {}, request, response)
+        handler.do_search(indirection, "my", {}, request, response)
       end
 
       it "should return [] when searching returns an empty array" do
@@ -386,7 +384,7 @@ describe Puppet::Network::HTTP::Handler do
         handler.expects(:set_response).with(response, Puppet::TestModel.render_multiple(:pson, []))
         handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        handler.do_search(indirection.name, "nothing", {}, request, response)
+        handler.do_search(indirection, "nothing", {}, request, response)
       end
 
       it "should return a 404 when searching returns nil" do
@@ -394,7 +392,7 @@ describe Puppet::Network::HTTP::Handler do
         indirection.expects(:search).returns(nil)
 
         expect do
-          handler.do_search(indirection.name, "nothing", {}, request, response)
+          handler.do_search(indirection, "nothing", {}, request, response)
         end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotFoundError)
       end
     end
@@ -405,7 +403,7 @@ describe Puppet::Network::HTTP::Handler do
         indirection.save(data, "my data")
         request = a_request_that_destroys(data)
 
-        handler.do_destroy(indirection.name, "my data", {}, request, response)
+        handler.do_destroy(indirection, "my data", {}, request, response)
 
         Puppet::TestModel.indirection.find("my data").should be_nil
       end
@@ -418,7 +416,7 @@ describe Puppet::Network::HTTP::Handler do
         handler.expects(:set_response).with(response, data.render(:yaml))
         handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:yaml))
 
-        handler.do_destroy(indirection.name, "my data", {}, request, response)
+        handler.do_destroy(indirection, "my data", {}, request, response)
       end
 
       it "uses the first supported format for the response" do
@@ -429,7 +427,7 @@ describe Puppet::Network::HTTP::Handler do
         handler.expects(:set_response).with(response, data.render(:pson))
         handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        handler.do_destroy(indirection.name, "my data", {}, request, response)
+        handler.do_destroy(indirection, "my data", {}, request, response)
       end
 
       it "raises an error and does not destory when no accepted formats are known" do
@@ -438,7 +436,7 @@ describe Puppet::Network::HTTP::Handler do
         request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
 
         expect do
-          handler.do_destroy(indirection.name, "my data", {}, request, response)
+          handler.do_destroy(indirection, "my data", {}, request, response)
         end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
 
         Puppet::TestModel.indirection.find("my data").should_not be_nil
@@ -460,7 +458,7 @@ describe Puppet::Network::HTTP::Handler do
         request[:content_type_header] = "application/x-raw"
         request[:body] = ''
 
-        handler.do_save(indirection.name, "test", {}, request, response)
+        handler.do_save(indirection, "test", {}, request, response)
 
         Puppet::TestModel.indirection.find("test").data.should == ''
       end
@@ -469,7 +467,7 @@ describe Puppet::Network::HTTP::Handler do
         data = Puppet::TestModel.new("my data", "some data")
         request = a_request_that_submits(data)
 
-        handler.do_save(indirection.name, "my data", {}, request, response)
+        handler.do_save(indirection, "my data", {}, request, response)
 
         Puppet::TestModel.indirection.find("my data").should == data
       end
@@ -481,7 +479,7 @@ describe Puppet::Network::HTTP::Handler do
         handler.expects(:set_response).with(response, data.render(:yaml))
         handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:yaml))
 
-        handler.do_save(indirection.name, "my data", {}, request, response)
+        handler.do_save(indirection, "my data", {}, request, response)
       end
 
       it "uses the first supported format for the response" do
@@ -491,7 +489,7 @@ describe Puppet::Network::HTTP::Handler do
         handler.expects(:set_response).with(response, data.render(:pson))
         handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        handler.do_save(indirection.name, "my data", {}, request, response)
+        handler.do_save(indirection, "my data", {}, request, response)
       end
 
       it "raises an error and does not save when no accepted formats are known" do
@@ -499,7 +497,7 @@ describe Puppet::Network::HTTP::Handler do
         request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
 
         expect do
-          handler.do_save(indirection.name, "my data", {}, request, response)
+          handler.do_save(indirection, "my data", {}, request, response)
         end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
 
         Puppet::TestModel.indirection.find("my data").should be_nil
@@ -543,7 +541,8 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     def set_response(response, body, status = 200)
-      "my_result"
+      response[:body] = body
+      response[:status] = status
     end
 
     def http_method(request)

data/spec/unit/network/http_pool_spec.rb

@@ -3,6 +3,10 @@ require 'spec_helper'
 require 'puppet/network/http_pool'
 
 describe Puppet::Network::HttpPool do
+  before :each do
+    Puppet::SSL::Key.indirection.terminus_class = :memory
+    Puppet::SSL::CertificateRequest.indirection.terminus_class = :memory
+  end
 
   describe "when managing http instances" do
 
@@ -26,15 +30,14 @@ describe Puppet::Network::HttpPool do
     describe 'peer verification' do
       def setup_standard_ssl_configuration
         ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
-        FileTest.stubs(:exist?).with(ca_cert_file).returns(true)
 
-        ssl_configuration = stub('ssl_configuration', :ca_auth_file => ca_cert_file)
-        Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_configuration).returns(ssl_configuration)
+        Puppet[:ssl_client_ca_auth] = ca_cert_file
+        Puppet::FileSystem::File.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')
-        FileTest.stubs(:exist?).with(host_cert_file).returns(true)
+        Puppet::FileSystem::File.stubs(:exist?).with(host_cert_file).returns(true)
 
         Puppet[:hostcert] = host_cert_file
       end
@@ -44,7 +47,7 @@ describe Puppet::Network::HttpPool do
         key  = stub('key',  :content => 'real_key')
         host = stub('host', :certificate => cert, :key => key, :ssl_store => stub('store'))
 
-        Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_host).returns(host)
+        Puppet::SSL::Host.stubs(:localhost).returns(host)
       end
 
       before do

data/spec/unit/node/environment_spec.rb

@@ -20,111 +20,97 @@ describe Puppet::Node::Environment do
     it "should use the filetimeout for the ttl for the modulepath" do
       Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout])
     end
-  
+
     it "should use the filetimeout for the ttl for the module list" do
       Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
     end
-  
+
     it "should use the default environment if no name is provided while initializing an environment" do
       Puppet[:environment] = "one"
       Puppet::Node::Environment.new.name.should == :one
     end
-  
+
     it "should treat environment instances as singletons" do
       Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one"))
     end
-  
+
     it "should treat an environment specified as names or strings as equivalent" do
       Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one"))
     end
-  
+
     it "should return its name when converted to a string" do
       Puppet::Node::Environment.new(:one).to_s.should == "one"
     end
-  
+
     it "should just return any provided environment if an environment is provided as the name" do
       one = Puppet::Node::Environment.new(:one)
       Puppet::Node::Environment.new(one).should equal(one)
     end
-  
+
     describe "when managing known resource types" do
       before do
         @collection = Puppet::Resource::TypeCollection.new(env)
         env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
-        Thread.current[:known_resource_types] = nil
+        $known_resource_types = nil
       end
-  
+
       it "should create a resource type collection if none exists" do
         Puppet::Resource::TypeCollection.expects(:new).with(env).returns @collection
         env.known_resource_types.should equal(@collection)
       end
-  
+
       it "should reuse any existing resource type collection" do
         env.known_resource_types.should equal(env.known_resource_types)
       end
-  
+
       it "should perform the initial import when creating a new collection" do
         env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
         env.known_resource_types
       end
-  
+
       it "should return the same collection even if stale if it's the same thread" do
         Puppet::Resource::TypeCollection.stubs(:new).returns @collection
         env.known_resource_types.stubs(:stale?).returns true
-  
+
         env.known_resource_types.should equal(@collection)
       end
-  
+
       it "should return the current thread associated collection if there is one" do
-        Thread.current[:known_resource_types] = @collection
-  
+        $known_resource_types = @collection
+
         env.known_resource_types.should equal(@collection)
       end
-  
-      it "should give to all threads using the same environment the same collection if the collection isn't stale" do
-        @original_thread_type_collection = Puppet::Resource::TypeCollection.new(env)
-        Puppet::Resource::TypeCollection.expects(:new).with(env).returns @original_thread_type_collection
-        env.known_resource_types.should equal(@original_thread_type_collection)
-  
-        @original_thread_type_collection.expects(:require_reparse?).returns(false)
-        Puppet::Resource::TypeCollection.stubs(:new).with(env).returns @collection
-  
-        t = Thread.new {
-          env.known_resource_types.should equal(@original_thread_type_collection)
-        }
-        t.join
-      end
-  
+
       it "should generate a new TypeCollection if the current one requires reparsing" do
         old_type_collection = env.known_resource_types
         old_type_collection.stubs(:require_reparse?).returns true
-        Thread.current[:known_resource_types] = nil
+        $known_resource_types = nil
         new_type_collection = env.known_resource_types
-  
+
         new_type_collection.should be_a Puppet::Resource::TypeCollection
         new_type_collection.should_not equal(old_type_collection)
       end
     end
-  
+
     it "should validate the modulepath directories" do
       real_file = tmpdir('moduledir')
       path = %W[/one /two #{real_file}].join(File::PATH_SEPARATOR)
-  
+
       Puppet[:modulepath] = path
-  
+
       env.modulepath.should == [real_file]
     end
-  
+
     it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
       Puppet::Util.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do
         module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
         env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two}
         env.expects(:[]).with(:modulepath).returns module_path
-  
+
         env.modulepath.should == %w{/l1 /l2 /one /two}
       end
     end
-  
+
     describe "when validating modulepath or manifestdir directories" do
       before :each do
         @path_one = tmpdir("path_one")
@@ -132,69 +118,69 @@ describe Puppet::Node::Environment do
         sep = File::PATH_SEPARATOR
         Puppet[:modulepath] = "#{@path_one}#{sep}#{@path_two}"
       end
-  
+
       it "should not return non-directories" do
         FileTest.expects(:directory?).with(@path_one).returns true
         FileTest.expects(:directory?).with(@path_two).returns false
-  
+
         env.validate_dirs([@path_one, @path_two]).should == [@path_one]
       end
-  
+
       it "should use the current working directory to fully-qualify unqualified paths" do
         FileTest.stubs(:directory?).returns true
-  
         two = File.expand_path("two")
+
         env.validate_dirs([@path_one, 'two']).should == [@path_one, two]
       end
     end
-  
+
     describe "when modeling a specific environment" do
       it "should have a method for returning the environment name" do
         Puppet::Node::Environment.new("testing").name.should == :testing
       end
-  
+
       it "should provide an array-like accessor method for returning any environment-specific setting" do
         env.should respond_to(:[])
       end
-  
+
       it "should ask the Puppet settings instance for the setting qualified with the environment name" do
         Puppet.settings.set_value(:server, "myval", :testing)
         env[:server].should == "myval"
       end
-  
+
       it "should be able to return an individual module that exists in its module path" do
         env.stubs(:modules).returns [Puppet::Module.new('one', "/one", mock("env"))]
-  
+
         mod = env.module('one')
         mod.should be_a(Puppet::Module)
         mod.name.should == 'one'
       end
-  
+
       it "should not return a module if the module doesn't exist" do
         env.stubs(:modules).returns [Puppet::Module.new('one', "/one", mock("env"))]
-  
+
         env.module('two').should be_nil
       end
-  
+
       it "should return nil if asked for a module that does not exist in its path" do
         modpath = tmpdir('modpath')
         env.modulepath = [modpath]
-  
+
         env.module("one").should be_nil
       end
-  
+
       describe "module data" do
         before do
           dir = tmpdir("deep_path")
-  
+
           @first = File.join(dir, "first")
           @second = File.join(dir, "second")
           Puppet[:modulepath] = "#{@first}#{File::PATH_SEPARATOR}#{@second}"
-  
+
           FileUtils.mkdir_p(@first)
           FileUtils.mkdir_p(@second)
         end
-  
+
         describe "#modules_by_path" do
           it "should return an empty list if there are no modules" do
             env.modules_by_path.should == {
@@ -202,19 +188,19 @@ describe Puppet::Node::Environment do
               @second => []
             }
           end
-  
+
           it "should include modules even if they exist in multiple dirs in the modulepath" do
             modpath1 = File.join(@first, "foo")
             FileUtils.mkdir_p(modpath1)
             modpath2 = File.join(@second, "foo")
             FileUtils.mkdir_p(modpath2)
-  
+
             env.modules_by_path.should == {
               @first  => [Puppet::Module.new('foo', modpath1, env)],
               @second => [Puppet::Module.new('foo', modpath2, env)]
             }
           end
-  
+
           it "should ignore modules with invalid names" do
             FileUtils.mkdir_p(File.join(@first, 'foo'))
             FileUtils.mkdir_p(File.join(@first, 'foo2'))
@@ -226,12 +212,12 @@ describe Puppet::Node::Environment do
             FileUtils.mkdir_p(File.join(@first, '-foo'))
             FileUtils.mkdir_p(File.join(@first, 'foo-'))
             FileUtils.mkdir_p(File.join(@first, 'foo--bar'))
-  
+
             env.modules_by_path[@first].collect{|mod| mod.name}.sort.should == %w{foo foo-bar foo2 foo_bar}
           end
-  
+
         end
-  
+
         describe "#module_requirements" do
           it "should return a list of what modules depend on other modules" do
             PuppetSpec::Modules.create(
@@ -266,7 +252,7 @@ describe Puppet::Node::Environment do
                 :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => "~3.0.0" }]
               }
             )
-  
+
             env.module_requirements.should == {
               'puppetlabs/alpha' => [],
               'puppetlabs/foo' => [
@@ -297,7 +283,7 @@ describe Puppet::Node::Environment do
             }
           end
         end
-  
+
         describe ".module_by_forge_name" do
           it "should find modules by forge_name" do
             mod = PuppetSpec::Modules.create(
@@ -308,7 +294,7 @@ describe Puppet::Node::Environment do
             )
             env.module_by_forge_name('puppetlabs/baz').should == mod
           end
-  
+
           it "should not find modules with same name by the wrong author" do
             mod = PuppetSpec::Modules.create(
               'baz',
@@ -318,17 +304,17 @@ describe Puppet::Node::Environment do
             )
             env.module_by_forge_name('puppetlabs/baz').should == nil
           end
-  
+
           it "should return nil when the module can't be found" do
             env.module_by_forge_name('ima/nothere').should be_nil
           end
         end
-  
+
         describe ".modules" do
           it "should return an empty list if there are no modules" do
             env.modules.should == []
           end
-  
+
           it "should return a module named for every directory in each module path" do
             %w{foo bar}.each do |mod_name|
               FileUtils.mkdir_p(File.join(@first, mod_name))
@@ -338,14 +324,14 @@ describe Puppet::Node::Environment do
             end
             env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
           end
-  
+
           it "should remove duplicates" do
             FileUtils.mkdir_p(File.join(@first,  'foo'))
             FileUtils.mkdir_p(File.join(@second, 'foo'))
-  
+
             env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
           end
-  
+
           it "should ignore modules with invalid names" do
             FileUtils.mkdir_p(File.join(@first, 'foo'))
             FileUtils.mkdir_p(File.join(@first, 'foo2'))
@@ -353,63 +339,63 @@ describe Puppet::Node::Environment do
             FileUtils.mkdir_p(File.join(@first, 'foo_bar'))
             FileUtils.mkdir_p(File.join(@first, 'foo=bar'))
             FileUtils.mkdir_p(File.join(@first, 'foo bar'))
-  
+
             env.modules.collect{|mod| mod.name}.sort.should == %w{foo foo-bar foo2 foo_bar}
           end
-  
+
           it "should create modules with the correct environment" do
             FileUtils.mkdir_p(File.join(@first, 'foo'))
             env.modules.each {|mod| mod.environment.should == env }
           end
-  
+
         end
       end
-  
+
       it "should cache the module list" do
         env.modulepath = %w{/a}
         Dir.expects(:entries).once.with("/a").returns %w{foo}
-  
+
         env.modules
         env.modules
       end
     end
-  
+
     describe Puppet::Node::Environment::Helper do
       before do
         @helper = Object.new
         @helper.extend(Puppet::Node::Environment::Helper)
       end
-  
+
       it "should be able to set and retrieve the environment as a symbol" do
         @helper.environment = :foo
         @helper.environment.name.should == :foo
       end
-  
+
       it "should accept an environment directly" do
         @helper.environment = Puppet::Node::Environment.new(:foo)
         @helper.environment.name.should == :foo
       end
-  
+
       it "should accept an environment as a string" do
         @helper.environment = 'foo'
         @helper.environment.name.should == :foo
       end
     end
-  
+
     describe "when performing initial import" do
       before do
         @parser = Puppet::Parser::ParserFactory.parser("test")
 #        @parser = Puppet::Parser::EParserAdapter.new(Puppet::Parser::Parser.new("test")) # TODO: FIX PARSER FACTORY
         Puppet::Parser::ParserFactory.stubs(:parser).returns @parser
       end
-  
+
       it "should set the parser's string to the 'code' setting and parse if code is available" do
         Puppet.settings[:code] = "my code"
         @parser.expects(:string=).with "my code"
         @parser.expects(:parse)
         env.instance_eval { perform_initial_import }
       end
-  
+
       it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
         filename = tmpfile('myfile')
         File.open(filename, 'w'){|f| }
@@ -418,7 +404,7 @@ describe Puppet::Node::Environment do
         @parser.expects(:parse)
         env.instance_eval { perform_initial_import }
       end
-  
+
       it "should pass the manifest file to the parser even if it does not exist on disk" do
         filename = tmpfile('myfile')
         Puppet.settings[:code] = ""
@@ -427,15 +413,15 @@ describe Puppet::Node::Environment do
         @parser.expects(:parse).once
         env.instance_eval { perform_initial_import }
       end
-  
+
       it "should fail helpfully if there is an error importing" do
-        File.stubs(:exist?).returns true
+        Puppet::FileSystem::File.stubs(:exist?).returns true
         env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)
         @parser.expects(:file=).once
         @parser.expects(:parse).raises ArgumentError
         lambda { env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error)
       end
-  
+
       it "should not do anything if the ignore_import settings is set" do
         Puppet.settings[:ignoreimport] = true
         @parser.expects(:string=).never
@@ -443,11 +429,11 @@ describe Puppet::Node::Environment do
         @parser.expects(:parse).never
         env.instance_eval { perform_initial_import }
       end
-  
+
       it "should mark the type collection as needing a reparse when there is an error parsing" do
         @parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
         env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)
-  
+
         lambda { env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error, /Syntax error at .../)
         env.known_resource_types.require_reparse?.should be_true
       end
@@ -465,5 +451,5 @@ describe Puppet::Node::Environment do
     end
     it_behaves_like 'the environment'
   end
-  
+
 end