diff --git a/spec/integration/indirector/file_content/file_server_spec.rb b/spec/integration/indirector/file_content/file_server_spec.rb
index ee0db17a9..f2b72b697 100755
--- a/spec/integration/indirector/file_content/file_server_spec.rb
+++ b/spec/integration/indirector/file_content/file_server_spec.rb
@@ -1,89 +1,91 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/file_server'
 require 'shared_behaviours/file_server_terminus'
 
 require 'puppet_spec/files'
 
 describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
   it_should_behave_like "Puppet::Indirector::FileServerTerminus"
   include PuppetSpec::Files
 
   before do
     @terminus = Puppet::Indirector::FileContent::FileServer.new
     @test_class = Puppet::FileServing::Content
     Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
   end
 
   it "should find plugin file content in the environment specified in the request" do
     path = tmpfile("file_content_with_env")
 
     Dir.mkdir(path)
 
     modpath = File.join(path, "mod")
     FileUtils.mkdir_p(File.join(modpath, "lib"))
     file = File.join(modpath, "lib", "file.rb")
     File.open(file, "wb") { |f| f.write "1\r\n" }
 
     Puppet.settings[:modulepath] = "/no/such/file"
 
     env = Puppet::Node::Environment.create(:foo, [path])
 
     result = Puppet::FileServing::Content.indirection.search("plugins", :environment => env, :recurse => true)
 
     result.should_not be_nil
     result.length.should == 2
     result.map {|x| x.should be_instance_of(Puppet::FileServing::Content) }
     result.find {|x| x.relative_path == 'file.rb' }.content.should == "1\r\n"
   end
 
   it "should find file content in modules" do
     path = tmpfile("file_content")
 
     Dir.mkdir(path)
 
     modpath = File.join(path, "mymod")
     FileUtils.mkdir_p(File.join(modpath, "files"))
     file = File.join(modpath, "files", "myfile")
     File.open(file, "wb") { |f| f.write "1\r\n" }
 
     env = Puppet::Node::Environment.create(:foo, [path])
 
     result = Puppet::FileServing::Content.indirection.find("modules/mymod/myfile", :environment => env)
 
     result.should_not be_nil
     result.should be_instance_of(Puppet::FileServing::Content)
     result.content.should == "1\r\n"
   end
 
   it "should find file content in files when node name expansions are used" do
     Puppet::FileSystem.stubs(:exist?).returns true
     Puppet::FileSystem.stubs(:exist?).with(Puppet[:fileserverconfig]).returns(true)
 
-    @path = tmpfile("file_server_testing")
+    path = tmpfile("file_server_testing")
 
-    Dir.mkdir(@path)
-    subdir = File.join(@path, "mynode")
+    Dir.mkdir(path)
+    subdir = File.join(path, "mynode")
     Dir.mkdir(subdir)
     File.open(File.join(subdir, "myfile"), "wb") { |f| f.write "1\r\n" }
 
     # Use a real mount, so the integration is a bit deeper.
-    @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
-    @mount1.stubs(:allowed?).returns true
-    @mount1.path = File.join(@path, "%h")
+    mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
+    mount1.stubs(:allowed?).returns true
+    mount1.path = File.join(path, "%h")
+
+    parser = stub 'parser', :changed? => false
+    parser.stubs(:parse).returns("one" => mount1)
 
-    @parser = stub 'parser', :changed? => false
-    @parser.stubs(:parse).returns("one" => @mount1)
+    Puppet::FileServing::Configuration::Parser.stubs(:new).returns(parser)
 
-    Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
+    path = File.join(path, "myfile")
 
-    path = File.join(@path, "myfile")
+    env = Puppet::Node::Environment.create(:foo, [])
 
-    result = Puppet::FileServing::Content.indirection.find("one/myfile", :environment => "foo", :node => "mynode")
+    result = Puppet::FileServing::Content.indirection.find("one/myfile", :environment => env, :node => "mynode")
 
     result.should_not be_nil
     result.should be_instance_of(Puppet::FileServing::Content)
     result.content.should == "1\r\n"
   end
 end
diff --git a/spec/unit/configurer/fact_handler_spec.rb b/spec/unit/configurer/fact_handler_spec.rb
index 3e3c033ae..8d933655a 100755
--- a/spec/unit/configurer/fact_handler_spec.rb
+++ b/spec/unit/configurer/fact_handler_spec.rb
@@ -1,89 +1,96 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/configurer'
 require 'puppet/configurer/fact_handler'
 require 'matchers/json'
 
 class FactHandlerTester
   include Puppet::Configurer::FactHandler
 
+  attr_accessor :environment
+
+  def initialize(environment)
+    self.environment = environment
+  end
+
   def reload_facter
     # don't want to do this in tests
   end
 end
 
 describe Puppet::Configurer::FactHandler do
   include JSONMatchers
 
+  let(:facthandler) { FactHandlerTester.new('production') }
+
   before :each do
-    @facthandler = FactHandlerTester.new
     Puppet::Node::Facts.indirection.terminus_class = :memory
   end
 
   describe "when finding facts" do
     it "should use the node name value to retrieve the facts" do
       foo_facts = Puppet::Node::Facts.new('foo')
       bar_facts = Puppet::Node::Facts.new('bar')
       Puppet::Node::Facts.indirection.save(foo_facts)
       Puppet::Node::Facts.indirection.save(bar_facts)
       Puppet[:certname] = 'foo'
       Puppet[:node_name_value] = 'bar'
 
-      @facthandler.find_facts.should == bar_facts
+      facthandler.find_facts.should == bar_facts
     end
 
     it "should set the facts name based on the node_name_fact" do
       facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
       Puppet::Node::Facts.indirection.save(facts)
       Puppet[:node_name_fact] = 'my_name_fact'
 
-      @facthandler.find_facts.name.should == 'other_node_name'
+      facthandler.find_facts.name.should == 'other_node_name'
     end
 
     it "should set the node_name_value based on the node_name_fact" do
       facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
       Puppet::Node::Facts.indirection.save(facts)
       Puppet[:node_name_fact] = 'my_name_fact'
 
-      @facthandler.find_facts
+      facthandler.find_facts
 
       Puppet[:node_name_value].should == 'other_node_name'
     end
 
     it "should fail if finding facts fails" do
       Puppet::Node::Facts.indirection.expects(:find).raises RuntimeError
 
-      expect { @facthandler.find_facts }.to raise_error(Puppet::Error, /Could not retrieve local facts/)
+      expect { facthandler.find_facts }.to raise_error(Puppet::Error, /Could not retrieve local facts/)
     end
 
     it "should only load fact plugins once" do
       Puppet::Node::Facts.indirection.expects(:find).once
-      @facthandler.find_facts
+      facthandler.find_facts
     end
   end
 
   it "should serialize and CGI escape the fact values for uploading" do
     facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
     Puppet::Node::Facts.indirection.save(facts)
-    text = CGI.escape(@facthandler.find_facts.render(:pson))
+    text = CGI.escape(facthandler.find_facts.render(:pson))
 
-    @facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
+    facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
   end
 
   it "should properly accept facts containing a '+'" do
     facts = Puppet::Node::Facts.new('foo', 'afact' => 'a+b')
     Puppet::Node::Facts.indirection.save(facts)
-    text = CGI.escape(@facthandler.find_facts.render(:pson))
+    text = CGI.escape(facthandler.find_facts.render(:pson))
 
-    @facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
+    facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
   end
 
   it "should generate valid facts data against the facts schema" do
     facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
     Puppet::Node::Facts.indirection.save(facts)
 
-    expect(CGI.unescape(@facthandler.facts_for_uploading[:facts])).to validate_against('api/schemas/facts.json')
+    expect(CGI.unescape(facthandler.facts_for_uploading[:facts])).to validate_against('api/schemas/facts.json')
   end
 
 end
 
diff --git a/spec/unit/indirector/node/exec_spec.rb b/spec/unit/indirector/node/exec_spec.rb
index 092d430bb..b39483f92 100755
--- a/spec/unit/indirector/node/exec_spec.rb
+++ b/spec/unit/indirector/node/exec_spec.rb
@@ -1,76 +1,87 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/node/exec'
 require 'puppet/indirector/request'
 
 describe Puppet::Node::Exec do
   before do
     @indirection = mock 'indirection'
     Puppet.settings[:external_nodes] = File.expand_path("/echo")
     @searcher = Puppet::Node::Exec.new
   end
 
   describe "when constructing the command to run" do
     it "should use the external_node script as the command" do
       Puppet[:external_nodes] = "/bin/echo"
       @searcher.command.should == %w{/bin/echo}
     end
 
     it "should throw an exception if no external node command is set" do
       Puppet[:external_nodes] = "none"
       proc { @searcher.find(stub('request', :key => "foo")) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when handling the results of the command" do
+    let(:testing_env) { Puppet::Node::Environment.create(:testing, []) }
+    let(:other_env) { Puppet::Node::Environment.create(:other, []) }
+
     before do
       @name = "yay"
       @node = Puppet::Node.new(@name)
       @node.stubs(:fact_merge)
       Puppet::Node.expects(:new).with(@name).returns(@node)
       @result = {}
       # Use a local variable so the reference is usable in the execute definition.
       result = @result
       @searcher.meta_def(:execute) do |command, arguments|
         return YAML.dump(result)
       end
 
       @request = Puppet::Indirector::Request.new(:node, :find, @name, nil)
     end
 
+    around do |example|
+      envs = Puppet::Environments::Static.new(testing_env, other_env)
+
+      Puppet.override(:environments => envs) do
+        example.run
+      end
+    end
+
     it "should translate the YAML into a Node instance" do
       # Use an empty hash
       @searcher.find(@request).should equal(@node)
     end
 
     it "should set the resulting parameters as the node parameters" do
       @result[:parameters] = {"a" => "b", "c" => "d"}
       @searcher.find(@request)
       @node.parameters.should == {"a" => "b", "c" => "d"}
     end
 
     it "should set the resulting classes as the node classes" do
       @result[:classes] = %w{one two}
       @searcher.find(@request)
       @node.classes.should == [ 'one', 'two' ]
     end
 
     it "should merge the node's facts with its parameters" do
       @node.expects(:fact_merge)
       @searcher.find(@request)
     end
 
     it "should set the node's environment if one is provided" do
-      @result[:environment] = "yay"
+      @result[:environment] = "testing"
       @searcher.find(@request)
-      @node.environment.to_s.should == 'yay'
+      expect(@node.environment.name).to eq(:testing)
     end
 
     it "should set the node's environment based on the request if not otherwise provided" do
-      @request.environment = "boo"
+      @request.environment = "other"
       @searcher.find(@request)
-      @node.environment.to_s.should == 'boo'
+      expect(@node.environment.name).to eq(:other)
     end
   end
 end
diff --git a/spec/unit/indirector/request_spec.rb b/spec/unit/indirector/request_spec.rb
index 03d79843f..3f0819ac4 100755
--- a/spec/unit/indirector/request_spec.rb
+++ b/spec/unit/indirector/request_spec.rb
@@ -1,492 +1,507 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet/indirector/request'
 
 describe Puppet::Indirector::Request do
   include JSONMatchers
 
   describe "when initializing" do
     it "should always convert the indirection name to a symbol" do
       Puppet::Indirector::Request.new("ind", :method, "mykey", nil).indirection_name.should == :ind
     end
 
     it "should use provided value as the key if it is a string" do
       Puppet::Indirector::Request.new(:ind, :method, "mykey", nil).key.should == "mykey"
     end
 
     it "should use provided value as the key if it is a symbol" do
       Puppet::Indirector::Request.new(:ind, :method, :mykey, nil).key.should == :mykey
     end
 
     it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
       instance = mock 'instance', :name => "mykey"
       request = Puppet::Indirector::Request.new(:ind, :method, nil, instance)
       request.key.should == "mykey"
       request.instance.should equal(instance)
     end
 
     it "should support options specified as a hash" do
       expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil, :one => :two) }.to_not raise_error
     end
 
     it "should support nil options" do
       expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil) }.to_not raise_error
     end
 
     it "should support unspecified options" do
       expect { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.to_not raise_error
     end
 
     it "should use an empty options hash if nil was provided" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, nil).options.should == {}
     end
 
     it "should default to a nil node" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).node.should be_nil
     end
 
     it "should set its node attribute if provided in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "foo.com").node.should == "foo.com"
     end
 
     it "should default to a nil ip" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).ip.should be_nil
     end
 
     it "should set its ip attribute if provided in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ip => "192.168.0.1").ip.should == "192.168.0.1"
     end
 
     it "should default to being unauthenticated" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_authenticated
     end
 
     it "should set be marked authenticated if configured in the options" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :authenticated => "eh").should be_authenticated
     end
 
     it "should keep its options as a hash even if a node is specified" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :node => "eh").options.should be_instance_of(Hash)
     end
 
     it "should keep its options as a hash even if another option is specified" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :foo => "bar").options.should be_instance_of(Hash)
     end
 
     it "should treat options other than :ip, :node, and :authenticated as options rather than attributes" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :server => "bar").options[:server].should == "bar"
     end
 
     it "should normalize options to use symbols as keys" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, "foo" => "bar").options[:foo].should == "bar"
     end
 
     describe "and the request key is a URI" do
       let(:file) { File.expand_path("/my/file with spaces") }
+      let(:an_environment) { Puppet::Node::Environment.create(:an_environment, []) }
+      let(:env_loaders) { Puppet::Environments::Static.new(an_environment) }
+
+      around(:each) do |example|
+        Puppet.override({ :environments => env_loaders }, "Static environment loader for specs") do
+          example.run
+        end
+      end
 
       describe "and the URI is a 'file' URI" do
         before do
           @request = Puppet::Indirector::Request.new(:ind, :method, "#{URI.unescape(Puppet::Util.path_to_uri(file).to_s)}", nil)
         end
 
         it "should set the request key to the unescaped full file path" do
           @request.key.should == file
         end
 
         it "should not set the protocol" do
           @request.protocol.should be_nil
         end
 
         it "should not set the port" do
           @request.port.should be_nil
         end
 
         it "should not set the server" do
           @request.server.should be_nil
         end
       end
 
       it "should set the protocol to the URI scheme" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).protocol.should == "http"
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).protocol.should == "http"
       end
 
       it "should set the server if a server is provided" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).server.should == "host"
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).server.should == "host"
       end
 
       it "should set the server and port if both are provided" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host:543/stuff", nil).port.should == 543
+        Puppet::Indirector::Request.new(:ind, :method, "http://host:543/an_environment", nil).port.should == 543
       end
 
       it "should default to the masterport if the URI scheme is 'puppet'" do
         Puppet[:masterport] = "321"
-        Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff", nil).port.should == 321
+        Puppet::Indirector::Request.new(:ind, :method, "puppet://host/an_environment", nil).port.should == 321
       end
 
       it "should use the provided port if the URI scheme is not 'puppet'" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff", nil).port.should == 80
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).port.should == 80
       end
 
       it "should set the request key to the unescaped key part path from the URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "http://host/environment/terminus/stuff with spaces", nil).key.should == "stuff with spaces"
+        Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment/terminus/stuff with spaces", nil).key.should == "stuff with spaces"
       end
 
       it "should set the :uri attribute to the full URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "http:///stu ff", nil).uri.should == 'http:///stu ff'
+        Puppet::Indirector::Request.new(:ind, :method, "http:///an_environment/stu ff", nil).uri.should == 'http:///an_environment/stu ff'
       end
 
       it "should not parse relative URI" do
         Puppet::Indirector::Request.new(:ind, :method, "foo/bar", nil).uri.should be_nil
       end
 
       it "should not parse opaque URI" do
         Puppet::Indirector::Request.new(:ind, :method, "mailto:joe", nil).uri.should be_nil
       end
     end
 
     it "should allow indication that it should not read a cached instance" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_cache => true).should be_ignore_cache
     end
 
     it "should default to not ignoring the cache" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_ignore_cache
     end
 
     it "should allow indication that it should not not read an instance from the terminus" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil, :ignore_terminus => true).should be_ignore_terminus
     end
 
     it "should default to not ignoring the terminus" do
       Puppet::Indirector::Request.new(:ind, :method, :key, nil).should_not be_ignore_terminus
     end
   end
 
   it "should look use the Indirection class to return the appropriate indirection" do
     ind = mock 'indirection'
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     request.indirection.should equal(ind)
   end
 
   it "should use its indirection to look up the appropriate model" do
     ind = mock 'indirection'
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     ind.expects(:model).returns "mymodel"
 
     request.model.should == "mymodel"
   end
 
   it "should fail intelligently when asked to find a model but the indirection cannot be found" do
     Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     expect { request.model }.to raise_error(ArgumentError)
   end
 
   it "should have a method for determining if the request is plural or singular" do
     Puppet::Indirector::Request.new(:myind, :method, :key, nil).should respond_to(:plural?)
   end
 
   it "should be considered plural if the method is 'search'" do
     Puppet::Indirector::Request.new(:myind, :search, :key, nil).should be_plural
   end
 
   it "should not be considered plural if the method is not 'search'" do
     Puppet::Indirector::Request.new(:myind, :find, :key, nil).should_not be_plural
   end
 
   it "should use its uri, if it has one, as its string representation" do
-    Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz", nil).to_s.should == "foo://bar/baz"
+    Puppet.override({
+      :environments => Puppet::Environments::Static.new(
+        Puppet::Node::Environment.create(:baz, [])
+      )},
+      "Static loader for spec") do
+
+      Puppet::Indirector::Request.new(:myind, :find, "foo://bar/baz", nil).to_s.should == "foo://bar/baz"
+    end
   end
 
   it "should use its indirection name and key, if it has no uri, as its string representation" do
     Puppet::Indirector::Request.new(:myind, :find, "key", nil) == "/myind/key"
   end
 
   it "should be able to return the URI-escaped key" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key.should == URI.escape("my key")
   end
 
   it "should set its environment to an environment instance when a string is specified as its environment" do
     env = Puppet::Node::Environment.create(:foo, [])
 
     Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
       Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => "foo").environment.should == env
     end
   end
 
   it "should use any passed in environment instances as its environment" do
     env = Puppet::Node::Environment.create(:foo, [])
 
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => env).environment.should equal(env)
   end
 
   it "should use the current environment when none is provided" do
     configured = Puppet::Node::Environment.create(:foo, [])
 
     Puppet[:environment] = "foo"
 
     expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).environment).to eq(Puppet.lookup(:current_environment))
   end
 
   it "should support converting its options to a hash" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil ).should respond_to(:to_hash)
   end
 
   it "should include all of its attributes when its options are converted to a hash" do
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :node => 'foo').to_hash[:node].should == 'foo'
   end
 
   describe "when building a query string from its options" do
     def a_request_with_options(options)
       Puppet::Indirector::Request.new(:myind, :find, "my key", nil, options)
     end
 
     def the_parsed_query_string_from(request)
       CGI.parse(request.query_string.sub(/^\?/, ''))
     end
 
     it "should return an empty query string if there are no options" do
       request = a_request_with_options(nil)
 
       request.query_string.should == ""
     end
 
     it "should return an empty query string if the options are empty" do
       request = a_request_with_options({})
 
       request.query_string.should == ""
     end
 
     it "should prefix the query string with '?'" do
       request = a_request_with_options(:one => "two")
 
       request.query_string.should =~ /^\?/
     end
 
     it "should include all options in the query string, separated by '&'" do
       request = a_request_with_options(:one => "two", :three => "four")
 
       the_parsed_query_string_from(request).should == {
         "one" => ["two"],
         "three" => ["four"]
       }
     end
 
     it "should ignore nil options" do
       request = a_request_with_options(:one => "two", :three => nil)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["two"]
       }
     end
 
     it "should convert 'true' option values into strings" do
       request = a_request_with_options(:one => true)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["true"]
       }
     end
 
     it "should convert 'false' option values into strings" do
       request = a_request_with_options(:one => false)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["false"]
       }
     end
 
     it "should convert to a string all option values that are integers" do
       request = a_request_with_options(:one => 50)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["50"]
       }
     end
 
     it "should convert to a string all option values that are floating point numbers" do
       request = a_request_with_options(:one => 1.2)
 
       the_parsed_query_string_from(request).should == {
         "one" => ["1.2"]
       }
     end
 
     it "should CGI-escape all option values that are strings" do
       request = a_request_with_options(:one => "one two")
 
       the_parsed_query_string_from(request).should == {
         "one" => ["one two"]
       }
     end
 
     it "should convert an array of values into multiple entries for the same key" do
       request = a_request_with_options(:one => %w{one two})
 
       the_parsed_query_string_from(request).should == {
         "one" => ["one", "two"]
       }
     end
 
     it "should stringify simple data types inside an array" do
       request = a_request_with_options(:one => ['one', nil])
 
       the_parsed_query_string_from(request).should == {
         "one" => ["one"]
       }
     end
 
     it "should error if an array contains another array" do
       request = a_request_with_options(:one => ['one', ["not allowed"]])
 
       expect { request.query_string }.to raise_error(ArgumentError)
     end
 
     it "should error if an array contains illegal data" do
       request = a_request_with_options(:one => ['one', { :not => "allowed" }])
 
       expect { request.query_string }.to raise_error(ArgumentError)
     end
 
     it "should convert to a string and CGI-escape all option values that are symbols" do
       request = a_request_with_options(:one => :"sym bol")
 
       the_parsed_query_string_from(request).should == {
         "one" => ["sym bol"]
       }
     end
 
     it "should fail if options other than booleans or strings are provided" do
       request = a_request_with_options(:one => { :one => :two })
 
       expect { request.query_string }.to raise_error(ArgumentError)
     end
   end
 
   context '#do_request' do
     before :each do
       @request = Puppet::Indirector::Request.new(:myind, :find, "my key", nil)
     end
 
     context 'when not using SRV records' do
       before :each do
         Puppet.settings[:use_srv_records] = false
       end
 
       it "yields the request with the default server and port when no server or port were specified on the original request" do
         count = 0
         rval = @request.do_request(:puppet, 'puppet.example.com', '90210') do |got|
           count += 1
           got.server.should == 'puppet.example.com'
           got.port.should   == '90210'
           'Block return value'
         end
         count.should == 1
 
         rval.should == 'Block return value'
       end
     end
 
     context 'when using SRV records' do
       before :each do
         Puppet.settings[:use_srv_records] = true
         Puppet.settings[:srv_domain]      = 'example.com'
       end
 
       it "yields the request with the original server and port unmodified" do
         @request.server = 'puppet.example.com'
         @request.port   = '90210'
 
         count = 0
         rval = @request.do_request do |got|
           count += 1
           got.server.should == 'puppet.example.com'
           got.port.should   == '90210'
           'Block return value'
         end
         count.should == 1
 
         rval.should == 'Block return value'
       end
 
       context "when SRV returns servers" do
         before :each do
           @dns_mock = mock('dns')
           Resolv::DNS.expects(:new).returns(@dns_mock)
 
           @port = 7205
           @host = '_x-puppet._tcp.example.com'
           @srv_records = [Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @host)]
 
           @dns_mock.expects(:getresources).
             with("_x-puppet._tcp.#{Puppet.settings[:srv_domain]}", Resolv::DNS::Resource::IN::SRV).
             returns(@srv_records)
         end
 
         it "yields a request using the server and port from the SRV record" do
           count = 0
           rval = @request.do_request do |got|
             count += 1
             got.server.should == '_x-puppet._tcp.example.com'
             got.port.should == 7205
 
             @block_return
           end
           count.should == 1
 
           rval.should == @block_return
         end
 
         it "should fall back to the default server when the block raises a SystemCallError" do
           count = 0
           second_pass = nil
 
           rval = @request.do_request(:puppet, 'puppet', 8140) do |got|
             count += 1
 
             if got.server == '_x-puppet._tcp.example.com' then
               raise SystemCallError, "example failure"
             else
               second_pass = got
             end
 
             @block_return
           end
 
           second_pass.server.should == 'puppet'
           second_pass.port.should   == 8140
           count.should == 2
 
           rval.should == @block_return
         end
       end
     end
   end
 
   describe "#remote?" do
     def request(options = {})
       Puppet::Indirector::Request.new('node', 'find', 'localhost', nil, options)
     end
 
     it "should not be unless node or ip is set" do
       request.should_not be_remote
     end
 
     it "should be remote if node is set" do
       request(:node => 'example.com').should be_remote
     end
 
     it "should be remote if ip is set" do
       request(:ip => '127.0.0.1').should be_remote
     end
 
     it "should be remote if node and ip are set" do
       request(:node => 'example.com', :ip => '127.0.0.1').should be_remote
     end
   end
 end
diff --git a/spec/unit/network/http/api/v1_spec.rb b/spec/unit/network/http/api/v1_spec.rb
index 3ec1b08d2..3f3999608 100755
--- a/spec/unit/network/http/api/v1_spec.rb
+++ b/spec/unit/network/http/api/v1_spec.rb
@@ -1,498 +1,513 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/http'
 require 'puppet/network/http/api/v1'
 require 'puppet/indirector_testing'
 
 describe Puppet::Network::HTTP::API::V1 do
   let(:not_found_code) { Puppet::Network::HTTP::Error::HTTPNotFoundError::CODE }
   let(:not_acceptable_code) { Puppet::Network::HTTP::Error::HTTPNotAcceptableError::CODE }
   let(:not_authorized_code) { Puppet::Network::HTTP::Error::HTTPNotAuthorizedError::CODE }
 
   let(:indirection) { Puppet::IndirectorTesting.indirection }
   let(:handler) { Puppet::Network::HTTP::API::V1.new }
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 
   def a_request_that_heads(data, request = {})
     Puppet::Network::HTTP::Request.from_hash({
       :headers => {
         'accept' => request[:accept_header],
         'content-type' => "text/pson", },
       :method => "HEAD",
       :path => "/production/#{indirection.name}/#{data.value}",
       :params => {},
     })
   end
 
   def a_request_that_submits(data, request = {})
     Puppet::Network::HTTP::Request.from_hash({
       :headers => {
         'accept' => request[:accept_header],
         'content-type' => request[:content_type_header] || "text/pson", },
       :method => "PUT",
       :path => "/production/#{indirection.name}/#{data.value}",
       :params => {},
       :body => request[:body].nil? ? data.render("pson") : request[:body]
     })
   end
 
   def a_request_that_destroys(data, request = {})
     Puppet::Network::HTTP::Request.from_hash({
       :headers => {
         'accept' => request[:accept_header],
         'content-type' => "text/pson", },
       :method => "DELETE",
       :path => "/production/#{indirection.name}/#{data.value}",
       :params => {},
       :body => ''
     })
   end
 
   def a_request_that_finds(data, request = {})
     Puppet::Network::HTTP::Request.from_hash({
       :headers => {
         'accept' => request[:accept_header],
         'content-type' => "text/pson", },
       :method => "GET",
       :path => "/production/#{indirection.name}/#{data.value}",
       :params => {},
       :body => ''
     })
   end
 
   def a_request_that_searches(key, request = {})
     Puppet::Network::HTTP::Request.from_hash({
       :headers => {
         'accept' => request[:accept_header],
         'content-type' => "text/pson", },
       :method => "GET",
       :path => "/production/#{indirection.name}s/#{key}",
       :params => {},
       :body => ''
     })
   end
 
 
   before do
     Puppet::IndirectorTesting.indirection.terminus_class = :memory
     Puppet::IndirectorTesting.indirection.terminus.clear
     handler.stubs(:check_authorization)
     handler.stubs(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
+    let(:environment) { Puppet::Node::Environment.create(:env, []) }
+    let(:env_loaders) { Puppet::Environments::Static.new(environment) }
+
     before do
       handler.stubs(:handler).returns "foo"
     end
 
+    around do |example|
+      Puppet.override(:environments => env_loaders) do
+        example.run
+      end
+    end
+
     it "should require the http method, the URI, and the query parameters" do
       # Not a terribly useful test, but an important statement for the spec
       lambda { handler.uri2indirection("/foo") }.should raise_error(ArgumentError)
     end
 
     it "should use the first field of the URI as the environment" do
       handler.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].to_s.should == "env"
     end
 
     it "should fail if the environment is not alphanumeric" do
       lambda { handler.uri2indirection("GET", "/env ness/foo/bar", {}) }.should raise_error(ArgumentError)
     end
 
     it "should use the environment from the URI even if one is specified in the parameters" do
       handler.uri2indirection("GET", "/env/foo/bar", {:environment => "otherenv"})[3][:environment].to_s.should == "env"
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
       handler.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" })[3].should_not include({ :bucket_path => "/malicious/path" })
     end
 
     it "should pass allowed parameters through" do
       handler.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" })[3].should include({ :allowed_param => "value" })
     end
 
     it "should return the environment as a Puppet::Node::Environment" do
       handler.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].should be_a(Puppet::Node::Environment)
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
       handler.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" })[3].should_not include({ :bucket_path => "/malicious/path" })
     end
 
     it "should pass allowed parameters through" do
       handler.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" })[3].should include({ :allowed_param => "value" })
     end
 
     it "should use the second field of the URI as the indirection name" do
       handler.uri2indirection("GET", "/env/foo/bar", {})[0].should == "foo"
     end
 
     it "should fail if the indirection name is not alphanumeric" do
       lambda { handler.uri2indirection("GET", "/env/foo ness/bar", {}) }.should raise_error(ArgumentError)
     end
 
     it "should use the remainder of the URI as the indirection key" do
       handler.uri2indirection("GET", "/env/foo/bar", {})[2].should == "bar"
     end
 
     it "should support the indirection key being a /-separated file path" do
       handler.uri2indirection("GET", "/env/foo/bee/baz/bomb", {})[2].should == "bee/baz/bomb"
     end
 
     it "should fail if no indirection key is specified" do
       lambda { handler.uri2indirection("GET", "/env/foo/", {}) }.should raise_error(ArgumentError)
       lambda { handler.uri2indirection("GET", "/env/foo", {}) }.should raise_error(ArgumentError)
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
       handler.uri2indirection("GET", "/env/foo/bar", {})[1].should == :find
     end
 
     it "should choose 'find' as the indirection method if the http method is a POST and the indirection name is singular" do
       handler.uri2indirection("POST", "/env/foo/bar", {})[1].should == :find
     end
 
     it "should choose 'head' as the indirection method if the http method is a HEAD and the indirection name is singular" do
       handler.uri2indirection("HEAD", "/env/foo/bar", {})[1].should == :head
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is plural" do
       handler.uri2indirection("GET", "/env/foos/bar", {})[1].should == :search
     end
 
     it "should change indirection name to 'status' if the http method is a GET and the indirection name is statuses" do
       handler.uri2indirection("GET", "/env/statuses/bar", {})[0].should == 'status'
     end
 
     it "should change indirection name to 'probe' if the http method is a GET and the indirection name is probes" do
       handler.uri2indirection("GET", "/env/probes/bar", {})[0].should == 'probe'
     end
 
     it "should choose 'delete' as the indirection method if the http method is a DELETE and the indirection name is singular" do
       handler.uri2indirection("DELETE", "/env/foo/bar", {})[1].should == :destroy
     end
 
     it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is singular" do
       handler.uri2indirection("PUT", "/env/foo/bar", {})[1].should == :save
     end
 
     it "should fail if an indirection method cannot be picked" do
       lambda { handler.uri2indirection("UPDATE", "/env/foo/bar", {}) }.should raise_error(ArgumentError)
     end
 
     it "should URI unescape the indirection key" do
       escaped = URI.escape("foo bar")
       indirection_name, method, key, params = handler.uri2indirection("GET", "/env/foo/#{escaped}", {})
       key.should == "foo bar"
     end
   end
 
   describe "when converting a request into a URI" do
-    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => "myenv") }
+    let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
+    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
+
+    before do
+      handler.stubs(:handler).returns "foo"
+    end
 
     it "should use the environment as the first field of the URI" do
       handler.class.indirection2uri(request).split("/")[1].should == "myenv"
     end
 
     it "should use the indirection as the second field of the URI" do
       handler.class.indirection2uri(request).split("/")[2].should == "foo"
     end
 
     it "should pluralize the indirection name if the method is 'search'" do
       request.stubs(:method).returns :search
       handler.class.indirection2uri(request).split("/")[2].should == "foos"
     end
 
     it "should use the escaped key as the remainder of the URI" do
       escaped = URI.escape("with spaces")
       handler.class.indirection2uri(request).split("/")[3].sub(/\?.+/, '').should == escaped
     end
 
     it "should add the query string to the URI" do
       request.expects(:query_string).returns "?query"
       handler.class.indirection2uri(request).should =~ /\?query$/
     end
   end
 
   describe "when converting a request into a URI with body" do
-    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => "myenv") }
+    let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
+    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
     it "should use the environment as the first field of the URI" do
       handler.class.request_to_uri_and_body(request).first.split("/")[1].should == "myenv"
     end
 
     it "should use the indirection as the second field of the URI" do
       handler.class.request_to_uri_and_body(request).first.split("/")[2].should == "foo"
     end
 
     it "should use the escaped key as the remainder of the URI" do
       escaped = URI.escape("with spaces")
       handler.class.request_to_uri_and_body(request).first.split("/")[3].sub(/\?.+/, '').should == escaped
     end
 
     it "should return the URI and body separately" do
       handler.class.request_to_uri_and_body(request).should == ["/myenv/foo/with%20spaces", "foo=bar"]
     end
   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"))
 
       handler.expects(:check_authorization).raises(Puppet::Network::AuthorizationError.new("forbidden"))
 
       handler.call(request, response)
 
       expect(response.code).to eq(not_authorized_code)
     end
 
     it "should return 'not found' 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)
     end
 
     it "should return 'not found' 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(not_found_code)
       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(400)
       expect(response.body).to eq("The exception")
       expect(response.type).to eq("text/plain")
     end
   end
 
   describe "when finding a model instance" do
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_finds(data, :accept_header => "unknown, pson")
 
       handler.call(request, response)
 
       expect(response.body).to eq(data.render(:pson))
       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
       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)
     end
 
     it "raises an 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)
     end
 
     it "should pass the result through without rendering it if the result is a string" do
       data = Puppet::IndirectorTesting.new("my data")
       data_string = "my data string"
       request = a_request_that_finds(data, :accept_header => "text/pson")
       indirection.expects(:find).returns(data_string)
 
       handler.call(request, response)
 
       expect(response.body).to eq(data_string)
       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
       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)
     end
   end
 
   describe "when searching for model instances" do
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_searches("my", :accept_header => "unknown, text/pson")
 
       handler.call(request, response)
 
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
       expect(response.body).to eq(Puppet::IndirectorTesting.render_multiple(:pson, [data]))
     end
 
     it "should return [] when searching returns an empty array" do
       request = a_request_that_searches("nothing", :accept_header => "unknown, text/pson")
 
       handler.call(request, response)
 
       expect(response.body).to eq("[]")
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
     it "should return a not_found_code when searching returns nil" do
       request = a_request_that_searches("nothing", :accept_header => "unknown, text/pson")
       indirection.expects(:search).returns(nil)
 
       handler.call(request, response)
 
       expect(response.code).to eq(not_found_code)
     end
   end
 
   describe "when destroying a model instance" do
     it "destroys the data indicated in the request" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_destroys(data)
 
       handler.call(request, response)
 
       Puppet::IndirectorTesting.indirection.find("my data").should be_nil
     end
 
     it "responds with pson when no Accept header is given" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_destroys(data, :accept_header => nil)
 
       handler.call(request, response)
 
       expect(response.body).to eq(data.render(:pson))
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_destroys(data, :accept_header => "unknown, text/pson")
 
       handler.call(request, response)
 
       expect(response.body).to eq(data.render(:pson))
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
     it "raises an error and does not destroy when no accepted formats are known" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
 
       handler.call(request, response)
 
       expect(response.code).to eq(not_acceptable_code)
       Puppet::IndirectorTesting.indirection.find("my data").should_not be_nil
     end
   end
 
   describe "when saving a model instance" do
     it "allows an empty body when the format supports it" do
       class Puppet::IndirectorTesting::Nonvalidatingmemory < Puppet::IndirectorTesting::Memory
         def validate_key(_)
           # nothing
         end
       end
 
       indirection.terminus_class = :nonvalidatingmemory
 
       data = Puppet::IndirectorTesting.new("test")
       request = a_request_that_submits(data,
                                        :content_type_header => "application/x-raw",
                                        :body => '')
 
       handler.call(request, response)
 
       # PUP-3272 this test fails when yaml is removed and pson is used. Instead of returning an
       # empty string, the a string '""' is returned - Don't know what the expecation is, if this is
       # corrent or not.
       # (helindbe)
       #
       Puppet::IndirectorTesting.indirection.find("test").name.should == ''
     end
 
     it "saves the data sent in the request" do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_submits(data)
 
       handler.call(request, response)
 
       saved = Puppet::IndirectorTesting.indirection.find("my data")
       expect(saved.name).to eq(data.name)
     end
 
     it "responds with pson when no Accept header is given" do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_submits(data, :accept_header => nil)
 
       handler.call(request, response)
 
       expect(response.body).to eq(data.render(:pson))
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_submits(data, :accept_header => "unknown, text/pson")
 
       handler.call(request, response)
 
       expect(response.body).to eq(data.render(:pson))
       expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
     it "raises an error and does not save when no accepted formats are known" do
       data = Puppet::IndirectorTesting.new("my data")
       request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
 
       handler.call(request, response)
 
       expect(Puppet::IndirectorTesting.indirection.find("my data")).to be_nil
       expect(response.code).to eq(not_acceptable_code)
     end
   end
 
   describe "when performing head operation" do
     it "should not generate a response when a model head call succeeds" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
       request = a_request_that_heads(data)
 
       handler.call(request, response)
 
       expect(response.code).to eq(nil)
     end
 
     it "should return a not_found_code 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")
     end
   end
 end
diff --git a/spec/unit/node_spec.rb b/spec/unit/node_spec.rb
index 9db2c8ec5..210db7990 100755
--- a/spec/unit/node_spec.rb
+++ b/spec/unit/node_spec.rb
@@ -1,299 +1,321 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
 
 describe Puppet::Node do
   include JSONMatchers
 
   let(:environment) { Puppet::Node::Environment.create(:bar, []) }
   let(:env_loader) { Puppet::Environments::Static.new(environment) }
 
   describe "when managing its environment" do
-    it "should use any set environment" do
-      Puppet.override(:environments => env_loader) do
-        Puppet::Node.new("foo", :environment => "bar").environment.should == environment
-      end
-    end
 
-    it "should support providing an actual environment instance" do
-      Puppet::Node.new("foo", :environment => environment).environment.name.should == :bar
+    it "supports providing an actual environment instance" do
+      expect(Puppet::Node.new("foo", :environment => environment).environment.name).to eq(:bar)
     end
 
-    it "should determine its environment from its parameters if no environment is set" do
-      Puppet.override(:environments => env_loader) do
-        Puppet::Node.new("foo", :parameters => {"environment" => :bar}).environment.should == environment
+    context "present in a loader" do
+      around do |example|
+        Puppet.override(:environments => env_loader) do
+          example.run
+        end
       end
-    end
 
-    it "should use the configured environment if no environment is provided" do
-      Puppet[:environment] = environment.name.to_s
+      it "uses any set environment" do
+        expect(Puppet::Node.new("foo", :environment => "bar").environment).to eq(environment)
+      end
 
-      Puppet.override(:environments => env_loader) do
-        Puppet::Node.new("foo").environment.should == environment
+      it "determines its environment from its parameters if no environment is set" do
+        expect(Puppet::Node.new("foo", :parameters => {"environment" => :bar}).environment).to eq(environment)
       end
-    end
 
-    it "should allow the environment to be set after initialization" do
-      node = Puppet::Node.new("foo")
-      node.environment = :bar
-      node.environment.name.should == :bar
-    end
+      it "uses the configured environment if no environment is provided" do
+        Puppet[:environment] = environment.name.to_s
+        expect(Puppet::Node.new("foo").environment).to eq(environment)
+      end
+
+      it "allows the environment to be set after initialization" do
+        node = Puppet::Node.new("foo")
+        node.environment = :bar
+        expect(node.environment.name).to eq(:bar)
+      end
 
-    it "should allow its environment to be set by parameters after initialization" do
-      node = Puppet::Node.new("foo")
-      node.parameters["environment"] = :bar
-      node.environment.name.should == :bar
+      it "allows its environment to be set by parameters after initialization" do
+        node = Puppet::Node.new("foo")
+        node.parameters["environment"] = :bar
+        expect(node.environment.name).to eq(:bar)
+      end
     end
   end
 
-  it "can round-trip through pson" do
-    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
-    node = Puppet::Node.new("hello",
-                            :environment => 'kjhgrg',
-                            :classes => ['erth', 'aiu'],
-                            :parameters => {"hostname"=>"food"}
-                           )
-    new_node = Puppet::Node.convert_from('pson', node.render('pson'))
-    new_node.environment.should == node.environment
-    new_node.parameters.should == node.parameters
-    new_node.classes.should == node.classes
-    new_node.name.should == node.name
-  end
+  describe "serialization" do
+    around do |example|
+      Puppet.override(:environments => env_loader) do
+        example.run
+      end
+    end
 
-  it "validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
-    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
-    node = Puppet::Node.new("hello",
-                            :environment => 'kjhgrg',
-                            :classes => ['erth', 'aiu'],
-                            :parameters => {"hostname"=>"food"}
-                           )
-    expect(node.to_pson).to validate_against('api/schemas/node.json')
-  end
+    it "can round-trip through pson" do
+      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      node = Puppet::Node.new("hello",
+                              :environment => 'bar',
+                              :classes => ['erth', 'aiu'],
+                              :parameters => {"hostname"=>"food"}
+                             )
+      new_node = Puppet::Node.convert_from('pson', node.render('pson'))
+      expect(new_node.environment).to eq(node.environment)
+      expect(new_node.parameters).to eq(node.parameters)
+      expect(new_node.classes).to eq(node.classes)
+      expect(new_node.name).to eq(node.name)
+    end
+
+    it "validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
+      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      node = Puppet::Node.new("hello",
+                              :environment => 'bar',
+                              :classes => ['erth', 'aiu'],
+                              :parameters => {"hostname"=>"food"}
+                             )
+      expect(node.to_pson).to validate_against('api/schemas/node.json')
+    end
 
-  it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
-    facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
-    node = Puppet::Node.new("hello",
-                            :environment => 'kjhgrg'
-                           )
-    expect(node.to_pson).to validate_against('api/schemas/node.json')
+    it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
+      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      node = Puppet::Node.new("hello",
+                              :environment => 'bar'
+                             )
+      expect(node.to_pson).to validate_against('api/schemas/node.json')
+    end
   end
 
   describe "when converting to json" do
     before do
       @node = Puppet::Node.new("mynode")
     end
 
-    it "should provide its name" do
-      @node.should set_json_attribute('name').to("mynode")
+    it "provide its name" do
+      expect(@node).to set_json_attribute('name').to("mynode")
     end
 
-    it "should include the classes if set" do
+    it "includes the classes if set" do
       @node.classes = %w{a b c}
-      @node.should set_json_attribute("classes").to(%w{a b c})
+      expect(@node).to set_json_attribute("classes").to(%w{a b c})
     end
 
-    it "should not include the classes if there are none" do
-      @node.should_not set_json_attribute('classes')
+    it "does not include the classes if there are none" do
+      expect(@node).to_not set_json_attribute('classes')
     end
 
-    it "should include parameters if set" do
+    it "includes parameters if set" do
       @node.parameters = {"a" => "b", "c" => "d"}
-      @node.should set_json_attribute('parameters').to({"a" => "b", "c" => "d"})
+      expect(@node).to set_json_attribute('parameters').to({"a" => "b", "c" => "d"})
     end
 
-    it "should not include the parameters if there are none" do
-      @node.should_not set_json_attribute('parameters')
+    it "does not include the parameters if there are none" do
+      expect(@node).to_not set_json_attribute('parameters')
     end
 
-    it "should include the environment" do
+    it "includes the environment" do
       @node.environment = "production"
-      @node.should set_json_attribute('environment').to('production')
+      expect(@node).to set_json_attribute('environment').to('production')
     end
   end
 
   describe "when converting from json" do
     before do
       @node = Puppet::Node.new("mynode")
       @format = Puppet::Network::FormatHandler.format('pson')
     end
 
     def from_json(json)
       @format.intern(Puppet::Node, json)
     end
 
-    it "should set its name" do
-      Puppet::Node.should read_json_attribute('name').from(@node.to_pson).as("mynode")
+    it "sets its name" do
+      expect(Puppet::Node).to read_json_attribute('name').from(@node.to_pson).as("mynode")
     end
 
-    it "should include the classes if set" do
+    it "includes the classes if set" do
       @node.classes = %w{a b c}
-      Puppet::Node.should read_json_attribute('classes').from(@node.to_pson).as(%w{a b c})
+      expect(Puppet::Node).to read_json_attribute('classes').from(@node.to_pson).as(%w{a b c})
     end
 
-    it "should include parameters if set" do
+    it "includes parameters if set" do
       @node.parameters = {"a" => "b", "c" => "d"}
-      Puppet::Node.should read_json_attribute('parameters').from(@node.to_pson).as({"a" => "b", "c" => "d"})
+      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_pson).as({"a" => "b", "c" => "d"})
     end
 
     it "deserializes environment to environment_name as a string" do
       @node.environment = environment
-      Puppet::Node.should read_json_attribute('environment_name').from(@node.to_pson).as('bar')
+      expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_pson).as('bar')
     end
   end
 end
 
 describe Puppet::Node, "when initializing" do
   before do
     @node = Puppet::Node.new("testnode")
   end
 
-  it "should set the node name" do
-    @node.name.should == "testnode"
+  it "sets the node name" do
+    expect(@node.name).to eq("testnode")
   end
 
-  it "should not allow nil node names" do
-    proc { Puppet::Node.new(nil) }.should raise_error(ArgumentError)
+  it "does not allow nil node names" do
+    expect { Puppet::Node.new(nil) }.to raise_error(ArgumentError)
   end
 
-  it "should default to an empty parameter hash" do
-    @node.parameters.should == {}
+  it "defaults to an empty parameter hash" do
+    expect(@node.parameters).to eq({})
   end
 
-  it "should default to an empty class array" do
-    @node.classes.should == []
+  it "defaults to an empty class array" do
+    expect(@node.classes).to eq([])
   end
 
-  it "should note its creation time" do
-    @node.time.should be_instance_of(Time)
+  it "notes its creation time" do
+    expect(@node.time).to be_instance_of(Time)
   end
 
-  it "should accept parameters passed in during initialization" do
+  it "accepts parameters passed in during initialization" do
     params = {"a" => "b"}
     @node = Puppet::Node.new("testing", :parameters => params)
-    @node.parameters.should == params
+    expect(@node.parameters).to eq(params)
   end
 
-  it "should accept classes passed in during initialization" do
+  it "accepts classes passed in during initialization" do
     classes = %w{one two}
     @node = Puppet::Node.new("testing", :classes => classes)
-    @node.classes.should == classes
+    expect(@node.classes).to eq(classes)
   end
 
-  it "should always return classes as an array" do
+  it "always returns classes as an array" do
     @node = Puppet::Node.new("testing", :classes => "myclass")
-    @node.classes.should == ["myclass"]
+    expect(@node.classes).to eq(["myclass"])
   end
 end
 
 describe Puppet::Node, "when merging facts" do
   before do
     @node = Puppet::Node.new("testnode")
-    Puppet::Node::Facts.indirection.stubs(:find).with(@node.name, instance_of(Hash)).returns(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
+    Puppet[:facts_terminus] = :memory
+    Puppet::Node::Facts.indirection.save(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
   end
 
-  it "should fail intelligently if it cannot find facts" do
-    Puppet::Node::Facts.indirection.expects(:find).with(@node.name, instance_of(Hash)).raises "foo"
-    lambda { @node.fact_merge }.should raise_error(Puppet::Error)
+  it "recovers with a Puppet::Error if something is thrown from the facts indirection" do
+    Puppet::Node::Facts.indirection.expects(:find).raises "something bad happened in the indirector"
+    expect { @node.fact_merge }.to raise_error(Puppet::Error, /Could not retrieve facts for testnode: something bad happened in the indirector/)
   end
 
-  it "should prefer parameters already set on the node over facts from the node" do
+  it "prefers parameters already set on the node over facts from the node" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.fact_merge
-    @node.parameters["one"].should == "a"
+    expect(@node.parameters["one"]).to eq("a")
   end
 
-  it "should add passed parameters to the parameter list" do
+  it "adds passed parameters to the parameter list" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.fact_merge
-    @node.parameters["two"].should == "b"
+    expect(@node.parameters["two"]).to eq("b")
   end
 
-  it "should accept arbitrary parameters to merge into its parameters" do
+  it "accepts arbitrary parameters to merge into its parameters" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
     @node.merge "two" => "three"
-    @node.parameters["two"].should == "three"
+    expect(@node.parameters["two"]).to eq("three")
   end
 
-  it "should add the environment to the list of parameters" do
-    Puppet[:environment] = "one"
-    @node = Puppet::Node.new("testnode", :environment => "one")
-    @node.merge "two" => "three"
-    @node.parameters["environment"].should == "one"
-  end
+  context "with an env loader" do
+    let(:environment) { Puppet::Node::Environment.create(:one, []) }
+    let(:env_loader) { Puppet::Environments::Static.new(environment) }
 
-  it "should not set the environment if it is already set in the parameters" do
-    Puppet[:environment] = "one"
-    @node = Puppet::Node.new("testnode", :environment => "one")
-    @node.merge "environment" => "two"
-    @node.parameters["environment"].should == "two"
+    around do |example|
+      Puppet.override(:environments => env_loader) do
+        example.run
+      end
+    end
+
+    it "adds the environment to the list of parameters" do
+      Puppet[:environment] = "one"
+      @node = Puppet::Node.new("testnode", :environment => "one")
+      @node.merge "two" => "three"
+      expect(@node.parameters["environment"]).to eq("one")
+    end
+
+    it "nots set the environment if it is already set in the parameters" do
+      Puppet[:environment] = "one"
+      @node = Puppet::Node.new("testnode", :environment => "one")
+      @node.merge "environment" => "two"
+      expect(@node.parameters["environment"]).to eq("two")
+    end
   end
 end
 
 describe Puppet::Node, "when indirecting" do
-  it "should default to the 'plain' node terminus" do
+  it "defaults to the 'plain' node terminus" do
     Puppet::Node.indirection.reset_terminus_class
 
-    Puppet::Node.indirection.terminus_class.should == :plain
+    expect(Puppet::Node.indirection.terminus_class).to eq(:plain)
   end
 end
 
 describe Puppet::Node, "when generating the list of names to search through" do
   before do
     @node = Puppet::Node.new("foo.domain.com", :parameters => {"hostname" => "yay", "domain" => "domain.com"})
   end
 
-  it "should return an array of names" do
-    @node.names.should be_instance_of(Array)
+  it "returns an array of names" do
+    expect(@node.names).to be_instance_of(Array)
   end
 
   describe "and the node name is fully qualified" do
-    it "should contain an entry for each part of the node name" do
-      @node.names.should be_include("foo.domain.com")
-      @node.names.should be_include("foo.domain")
-      @node.names.should be_include("foo")
+    it "contains an entry for each part of the node name" do
+      expect(@node.names).to include("foo.domain.com")
+      expect(@node.names).to include("foo.domain")
+      expect(@node.names).to include("foo")
     end
   end
 
-  it "should include the node's fqdn" do
-    @node.names.should be_include("yay.domain.com")
+  it "includes the node's fqdn" do
+    expect(@node.names).to include("yay.domain.com")
   end
 
-  it "should combine and include the node's hostname and domain if no fqdn is available" do
-    @node.names.should be_include("yay.domain.com")
+  it "combines and include the node's hostname and domain if no fqdn is available" do
+    expect(@node.names).to include("yay.domain.com")
   end
 
-  it "should contain an entry for each name available by stripping a segment of the fqdn" do
+  it "contains an entry for each name available by stripping a segment of the fqdn" do
     @node.parameters["fqdn"] = "foo.deep.sub.domain.com"
-    @node.names.should be_include("foo.deep.sub.domain")
-    @node.names.should be_include("foo.deep.sub")
+    expect(@node.names).to include("foo.deep.sub.domain")
+    expect(@node.names).to include("foo.deep.sub")
   end
 
   describe "and :node_name is set to 'cert'" do
     before do
       Puppet[:strict_hostname_checking] = false
       Puppet[:node_name] = "cert"
     end
 
-    it "should use the passed-in key as the first value" do
-      @node.names[0].should == "foo.domain.com"
+    it "uses the passed-in key as the first value" do
+      expect(@node.names[0]).to eq("foo.domain.com")
     end
 
     describe "and strict hostname checking is enabled" do
-      it "should only use the passed-in key" do
+      it "only uses the passed-in key" do
         Puppet[:strict_hostname_checking] = true
-        @node.names.should == ["foo.domain.com"]
+        expect(@node.names).to eq(["foo.domain.com"])
       end
     end
   end
 
   describe "and :node_name is set to 'facter'" do
     before do
       Puppet[:strict_hostname_checking] = false
       Puppet[:node_name] = "facter"
     end
 
-    it "should use the node's 'hostname' fact as the first value" do
-      @node.names[0].should == "yay"
+    it "uses the node's 'hostname' fact as the first value" do
+      expect(@node.names[0]).to eq("yay")
     end
   end
 end
diff --git a/spec/unit/parser/compiler_spec.rb b/spec/unit/parser/compiler_spec.rb
index dc7b4e537..1f42c2cbf 100755
--- a/spec/unit/parser/compiler_spec.rb
+++ b/spec/unit/parser/compiler_spec.rb
@@ -1,928 +1,938 @@
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
 
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
 
   def initialize(type, title)
     @type = type
     @title = title
   end
 
   def [](attr)
     return nil if attr == :stage
     :main
   end
 
   def ref
     "#{type.to_s.capitalize}[#{title}]"
   end
 
   def evaluated?
     @evaluated
   end
 
   def builtin_type?
     @builtin
   end
 
   def virtual?
     @virtual
   end
 
   def class?
     false
   end
 
   def stage?
     false
   end
 
   def evaluate
   end
 
   def file
     "/fake/file/goes/here"
   end
 
   def line
     "42"
   end
 end
 
 describe Puppet::Parser::Compiler do
   include PuppetSpec::Files
   include Matchers::Resource
 
   def resource(type, title)
     Puppet::Parser::Resource.new(type, title, :scope => @scope)
   end
 
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+
   before :each do
     # Push me faster, I wanna go back in time!  (Specifically, freeze time
     # across the test since we have a bunch of version == timestamp code
     # hidden away in the implementation and we keep losing the race.)
     # --daniel 2011-04-21
     now = Time.now
     Time.stubs(:now).returns(now)
 
-    environment = Puppet::Node::Environment.create(:testing, [])
     @node = Puppet::Node.new("testnode",
                              :facts => Puppet::Node::Facts.new("facts", {}),
                              :environment => environment)
     @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler, :source => stub('source'))
     @scope_resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope)
     @scope.resource = @scope_resource
   end
 
   it "should have a class method that compiles, converts, and returns a catalog" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     converted_catalog = stub 'converted_catalog'
     catalog.expects(:to_resource).returns converted_catalog
 
     Puppet::Parser::Compiler.compile(@node).should equal(converted_catalog)
   end
 
   it "should fail intelligently when a class-level compile fails" do
     Puppet::Parser::Compiler.expects(:new).raises ArgumentError
     lambda { Puppet::Parser::Compiler.compile(@node) }.should raise_error(Puppet::Error)
   end
 
   it "should use the node's environment as its environment" do
     @compiler.environment.should equal(@node.environment)
   end
 
   it "fails if the node's environment has validation errors" do
     conflicted_environment = Puppet::Node::Environment.create(:testing, [], '/some/environment.conf/manifest.pp')
     conflicted_environment.stubs(:validation_errors).returns(['bad environment'])
     @node.environment = conflicted_environment
     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
     Puppet::Parser::Compiler.ancestors.should 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"
     @compiler.add_class "two"
 
     @compiler.classlist.sort.should == %w{one two}.sort
   end
 
   it "should clear the global caches before compile" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     catalog.expects(:to_resource)
 
     $known_resource_types = "rspec"
     $env_module_directories = "rspec"
 
     Puppet::Parser::Compiler.compile(@node)
 
     $known_resource_types = nil
     $env_module_directories = nil
   end
 
   describe "when initializing" do
 
     it "should set its node attribute" do
       @compiler.node.should equal(@node)
     end
     it "should detect when ast nodes are absent" do
       @compiler.ast_nodes?.should be_false
     end
 
     it "should detect when ast nodes are present" do
       @known_resource_types.expects(:nodes?).returns true
       @compiler.ast_nodes?.should be_true
     end
 
     it "should copy the known_resource_types version to the catalog" do
       @compiler.catalog.version.should == @known_resource_types.version
     end
 
     it "should copy any node classes into the class list" do
       node = Puppet::Node.new("mynode")
       node.classes = %w{foo bar}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should transform node class hashes into a class list" do
       node = Puppet::Node.new("mynode")
       node.classes = {'foo'=>{'one'=>'p1'}, 'bar'=>{'two'=>'p2'}}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should add a 'main' stage to the catalog" do
       @compiler.catalog.resource(:stage, :main).should be_instance_of(Puppet::Parser::Resource)
     end
   end
 
   describe "when managing scopes" do
 
     it "should create a top scope" do
       @compiler.topscope.should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should be able to create new scopes" do
       @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should set the parent scope of the new scope to be the passed-in parent" do
       scope = mock 'scope'
       newscope = @compiler.newscope(scope)
 
       newscope.parent.should equal(scope)
     end
 
     it "should set the parent scope of the new scope to its topscope if the parent passed in is nil" do
       scope = mock 'scope'
       newscope = @compiler.newscope(nil)
 
       newscope.parent.should equal(@compiler.topscope)
     end
   end
 
   describe "when compiling" do
 
     def compile_methods
       [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
         :finish, :store, :extract, :evaluate_relationships]
     end
 
     # Stub all of the main compile methods except the ones we're specifically interested in.
     def compile_stub(*except)
       (compile_methods - except).each { |m| @compiler.stubs(m) }
     end
 
     it "should set node parameters as variables in the top scope" do
       params = {"a" => "b", "c" => "d"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.topscope['a'].should == "b"
       @compiler.topscope['c'].should == "d"
     end
 
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.catalog.client_version.should == "2"
       @compiler.catalog.server_version.should == "3"
     end
 
     it "should evaluate the main class if it exists" do
       compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
       main_class.expects(:evaluate_code).with { |r| r.is_a?(Puppet::Parser::Resource) }
       @compiler.topscope.expects(:source=).with(main_class)
 
       @compiler.compile
     end
 
     it "should create a new, empty 'main' if no main class exists" do
       compile_stub(:evaluate_main)
       @compiler.compile
       @known_resource_types.find_hostclass([""], "").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should add an edge between the main stage and main class" do
       @compiler.compile
       (stage = @compiler.catalog.resource(:stage, "main")).should be_instance_of(Puppet::Parser::Resource)
       (klass = @compiler.catalog.resource(:class, "")).should be_instance_of(Puppet::Parser::Resource)
 
       @compiler.catalog.edge?(stage, klass).should be_true
     end
 
     it "should evaluate all added collections" do
       colls = []
       # And when the collections fail to evaluate.
       colls << mock("coll1-false")
       colls << mock("coll2-false")
       colls.each { |c| c.expects(:evaluate).returns(false) }
 
       @compiler.add_collection(colls[0])
       @compiler.add_collection(colls[1])
 
       compile_stub(:evaluate_generators)
       @compiler.compile
     end
 
     it "should ignore builtin resources" do
       resource = resource(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources" do
       resource = CompilerTestResource.new(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true }
 
       @compiler.compile
     end
 
     it "should not evaluate already-evaluated resources" do
       resource = resource(:file, "testing")
       resource.stubs(:evaluated?).returns true
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources created by evaluating other resources" do
       resource = CompilerTestResource.new(:file, "testing")
       @compiler.add_resource(@scope, resource)
 
       resource2 = CompilerTestResource.new(:file, "other")
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true; @compiler.add_resource(@scope, resource2) }
       resource2.expects(:evaluate).with { |*whatever| resource2.evaluated = true }
 
 
       @compiler.compile
     end
 
     describe "when finishing" do
       before do
         @compiler.send(:evaluate_main)
         @catalog = @compiler.catalog
       end
 
       def add_resource(name, parent = nil)
         resource = Puppet::Parser::Resource.new "file", name, :scope => @scope
         @compiler.add_resource(@scope, resource)
         @catalog.add_edge(parent, resource) if parent
         resource
       end
 
       it "should call finish() on all resources" do
         # Add a resource that does respond to :finish
         resource = Puppet::Parser::Resource.new "file", "finish", :scope => @scope
         resource.expects(:finish)
 
         @compiler.add_resource(@scope, resource)
 
         # And one that does not
         dnf_resource = stub_everything "dnf", :ref => "File[dnf]", :type => "file"
 
         @compiler.add_resource(@scope, dnf_resource)
 
         @compiler.send(:finish)
       end
 
       it "should call finish() in add_resource order" do
         resources = sequence('resources')
 
         resource1 = add_resource("finish1")
         resource1.expects(:finish).in_sequence(resources)
 
         resource2 = add_resource("finish2")
         resource2.expects(:finish).in_sequence(resources)
 
         @compiler.send(:finish)
       end
 
       it "should add each container's metaparams to its contained resources" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
 
         @compiler.send(:finish)
         resource1[:noop].should be_true
       end
 
       it "should add metaparams recursively" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
 
       it "should prefer metaparams from immediate parents" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         resource1[:noop] = false
 
         @compiler.send(:finish)
         resource2[:noop].should be_false
       end
 
       it "should merge tags downward" do
         main = @catalog.resource(:class, :main)
         main.tag("one")
 
         resource1 = add_resource("meh", main)
         resource1.tag "two"
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2.tags.should be_include("one")
         resource2.tags.should be_include("two")
       end
 
       it "should work if only middle resources have metaparams set" do
         main = @catalog.resource(:class, :main)
 
         resource1 = add_resource("meh", main)
         resource1[:noop] = true
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
     end
 
     it "should return added resources in add order" do
       resource1 = resource(:file, "yay")
       @compiler.add_resource(@scope, resource1)
       resource2 = resource(:file, "youpi")
       @compiler.add_resource(@scope, resource2)
 
       @compiler.resources.should == [resource1, resource2]
     end
 
     it "should add resources that do not conflict with existing resources" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_vertex(resource)
     end
 
     it "should fail to add resources that conflict with existing resources" do
       path = make_absolute("/foo")
       file1 = resource(:file, path)
       file2 = resource(:file, path)
 
       @compiler.add_resource(@scope, file1)
       lambda { @compiler.add_resource(@scope, file2) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should add an edge from the scope resource to the added resource" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_edge(@scope.resource, resource)
     end
 
     it "should not add non-class resources that don't specify a stage to the 'main' stage" do
       main = @compiler.catalog.resource(:stage, :main)
       resource = resource(:file, "foo")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should_not be_edge(main, resource)
     end
 
     it "should not add any parent-edges to stages" do
       stage = resource(:stage, "other")
       @compiler.add_resource(@scope, stage)
 
       @scope.resource = resource(:class, "foo")
 
       @compiler.catalog.edge?(@scope.resource, stage).should be_false
     end
 
     it "should not attempt to add stages to other stages" do
       other_stage = resource(:stage, "other")
       second_stage = resource(:stage, "second")
       @compiler.add_resource(@scope, other_stage)
       @compiler.add_resource(@scope, second_stage)
 
       second_stage[:stage] = "other"
 
       @compiler.catalog.edge?(other_stage, second_stage).should be_false
     end
 
     it "should have a method for looking up resources" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay[foo]").should equal(resource)
     end
 
     it "should be able to look resources up by type and title" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay", "foo").should equal(resource)
     end
 
     it "should not evaluate virtual defined resources" do
       resource = resource(:file, "testing")
       resource.virtual = true
       @compiler.add_resource(@scope, resource)
 
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
   end
 
   describe "when evaluating collections" do
 
     it "should evaluate each collection" do
       2.times { |i|
         coll = mock 'coll%s' % i
         @compiler.add_collection(coll)
 
         # This is the hard part -- we have to emulate the fact that
         # collections delete themselves if they are done evaluating.
         coll.expects(:evaluate).with do
           @compiler.delete_collection(coll)
         end
       }
 
       @compiler.compile
     end
 
     it "should not fail when there are unevaluated resource collections that do not refer to specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns(nil)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should_not raise_error
     end
 
     it "should fail when there are unevaluated resource collections that refer to a specific resource" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns(:something)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, 'Failed to realize virtual resources something')
     end
 
     it "should fail when there are unevaluated resource collections that refer to multiple specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns([:one, :two])
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, 'Failed to realize virtual resources one, two')
     end
   end
 
   describe "when evaluating relationships" do
     it "should evaluate each relationship with its catalog" do
       dep = stub 'dep'
       dep.expects(:evaluate).with(@compiler.catalog)
       @compiler.add_relationship dep
       @compiler.evaluate_relationships
     end
   end
 
   describe "when told to evaluate missing classes" do
 
     it "should fail if there's no source listed for the scope" do
       scope = stub 'scope', :source => nil
       proc { @compiler.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should raise an error if a class is not found" do
       @scope.expects(:find_hostclass).with("notfound", {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.evaluate_classes(%w{notfound}, @scope) }.should 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', {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.compile }.should raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
 
   describe "when evaluating found classes" do
 
     before do
       Puppet.settings[:data_binding_terminus] = "none"
       @class = stub 'class', :name => "my::class"
       @scope.stubs(:find_hostclass).with("myclass", {:assume_fqname => false}).returns(@class)
 
       @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
     end
 
+    around do |example|
+      Puppet.override(
+        :environments => Puppet::Environments::Static.new(environment),
+        :description => "Static loader for specs"
+      ) do
+        example.run
+      end
+    end
+
     it "should evaluate each class" do
       @compiler.catalog.stubs(:tag)
 
       @class.expects(:ensure_in_catalog).with(@scope)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     describe "and the classes are specified as a hash with parameters" do
       before do
         @node.classes = {}
         @ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
       end
 
       # Define the given class with default parameters
       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
       end
 
       def compile
         @catalog = @compiler.compile
       end
 
       it "should record which classes are evaluated" do
         classes = {'foo'=>{}, 'bar::foo'=>{}, 'bar'=>{}}
         classes.each { |c, params| define_class(c, params) }
         compile()
         classes.each { |name, p| @catalog.classes.should include(name) }
       end
 
       it "should provide default values for parameters that have no values specified" do
         define_class('foo', {})
         compile()
         @catalog.resource(:class, 'foo')['p1'].should == "foo"
       end
 
       it "should use any provided values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'foo')['p1'].should == "real_value"
       end
 
       it "should support providing some but not all values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'Foo')['p1'].should == "real_value"
         @catalog.resource(:class, 'Foo')['p2'].should == "foo"
       end
 
       it "should ensure each node class is in catalog and has appropriate tags" do
         klasses = ['bar::foo']
         @node.classes = klasses
         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
         end
         catalog = @compiler.compile
 
         r2 = catalog.resources.detect {|r| r.title == 'Bar::Foo' }
         r2.tags.should == Puppet::Util::TagSet.new(['bar::foo', 'class', 'bar', 'foo'])
       end
     end
 
     it "should fail if required parameters are missing" 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
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Must pass b to Class[Foo]")
     end
 
     it "should fail if invalid parameters are passed" do
       klass = {'foo'=>{'3'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Invalid parameter 3 on Class[Foo]")
     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
       catalog = @compiler.compile
       catalog.classes.should include 'foo'
     end
 
     it "should not evaluate the resources created for found classes unless asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate).never
 
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should immediately evaluate the resources created for found classes when asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate)
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes that have already been evaluated" do
       @compiler.catalog.stubs(:tag)
 
       @scope.stubs(:class_scope).with(@class).returns(@scope)
 
       @compiler.expects(:add_resource).never
 
       @resource.expects(:evaluate).never
 
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes previously evaluated with different capitalization" do
       @compiler.catalog.stubs(:tag)
       @scope.stubs(:find_hostclass).with("MyClass",{:assume_fqname => false}).returns(@class)
       @scope.stubs(:class_scope).with(@class).returns(@scope)
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{MyClass}, @scope, false)
     end
   end
 
   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
       Puppet::Parser::Resource.expects(:new).never
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating AST nodes with AST nodes present" do
 
     before do
       @compiler.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)
 
       # It should check this last, of course.
       @compiler.known_resource_types.stubs(:node).with("default").returns(nil)
     end
 
     it "should fail if the named node cannot be found" do
       proc { @compiler.send(:evaluate_ast_node) }.should raise_error(Puppet::ParseError)
     end
 
     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)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     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)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     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)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       node_resource.expects(:evaluate)
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating node classes" do
     include PuppetSpec::Compiler
 
     describe "when provided classes in array format" do
       let(:node) { Puppet::Node.new('someone', :classes => ['something']) }
 
       describe "when the class exists" do
         it "should succeed if the class is already included" do
           manifest = <<-MANIFEST
           class something {}
           include something
           MANIFEST
 
           catalog = compile_to_catalog(manifest, node)
 
           catalog.resource('Class', 'Something').should_not be_nil
         end
 
         it "should evaluate the class without parameters if it's not already included" do
           manifest = "class something {}"
 
           catalog = compile_to_catalog(manifest, node)
 
           catalog.resource('Class', 'Something').should_not be_nil
         end
       end
 
       it "should fail if the class doesn't exist" do
         expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
       end
     end
 
     describe "when provided classes in hash format" do
       describe "for classes without parameters" do
         let(:node) { Puppet::Node.new('someone', :classes => {'something' => {}}) }
 
         describe "when the class exists" do
           it "should succeed if the class is already included" do
             manifest = <<-MANIFEST
             class something {}
             include something
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             catalog.resource('Class', 'Something').should_not be_nil
           end
 
           it "should evaluate the class if it's not already included" do
             manifest = <<-MANIFEST
             class something {}
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             catalog.resource('Class', 'Something').should_not be_nil
           end
         end
 
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
       end
 
       describe "for classes with parameters" do
         let(:node) { Puppet::Node.new('someone', :classes => {'something' => {'configuron' => 'defrabulated'}}) }
 
         describe "when the class exists" do
           it "should fail if the class is already included" do
             manifest = <<-MANIFEST
             class something($configuron=frabulated) {}
             include something
             MANIFEST
 
             expect { compile_to_catalog(manifest, node) }.to raise_error(Puppet::Error, /Class\[Something\] is already declared/)
           end
 
           it "should evaluate the class if it's not already included" do
             manifest = <<-MANIFEST
             class something($configuron=frabulated) {}
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             resource = catalog.resource('Class', 'Something')
             resource['configuron'].should == 'defrabulated'
           end
         end
 
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
 
         it 'evaluates classes declared with parameters before unparameterized classes' do
           node = Puppet::Node.new('someone', :classes => { 'app::web' => {}, 'app' => { 'port' => 8080 } })
           manifest = <<-MANIFEST
           class app($port = 80) { }
 
           class app::web($port = $app::port) inherits app {
             notify { expected: message => "$port" }
           }
           MANIFEST
 
           catalog = compile_to_catalog(manifest, node)
 
           expect(catalog).to have_resource("Class[App]").with_parameter(:port, 8080)
           expect(catalog).to have_resource("Class[App::Web]")
           expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, "8080")
         end
       end
     end
   end
 
   describe "when managing resource overrides" do
 
     before do
       @override = stub 'override', :ref => "File[/foo]", :type => "my"
       @resource = resource(:file, "/foo")
     end
 
     it "should be able to store overrides" do
       lambda { @compiler.add_override(@override) }.should_not raise_error
     end
 
     it "should apply overrides to the appropriate resources" do
       @compiler.add_resource(@scope, @resource)
       @resource.expects(:merge).with(@override)
 
       @compiler.add_override(@override)
 
       @compiler.compile
     end
 
     it "should accept overrides before the related resource has been created" do
       @resource.expects(:merge).with(@override)
 
       # First store the override
       @compiler.add_override(@override)
 
       # Then the resource
       @compiler.add_resource(@scope, @resource)
 
       # And compile, so they get resolved
       @compiler.compile
     end
 
     it "should fail if the compile is finished and resource overrides have not been applied" do
       @compiler.add_override(@override)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Could not find resource(s) File[/foo] for overriding'
     end
   end
 end
diff --git a/spec/unit/parser/type_loader_spec.rb b/spec/unit/parser/type_loader_spec.rb
index 759ade0f8..4ddd9c247 100755
--- a/spec/unit/parser/type_loader_spec.rb
+++ b/spec/unit/parser/type_loader_spec.rb
@@ -1,202 +1,210 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parser/type_loader'
 require 'puppet/parser/parser_factory'
 require 'puppet_spec/modules'
 require 'puppet_spec/files'
 
 describe Puppet::Parser::TypeLoader do
   include PuppetSpec::Modules
   include PuppetSpec::Files
 
   let(:empty_hostclass) { Puppet::Parser::AST::Hostclass.new('') }
   let(:loader) { Puppet::Parser::TypeLoader.new(:myenv) }
+  let(:my_env) { Puppet::Node::Environment.create(:myenv, []) }
+
+  around do |example|
+    envs = Puppet::Environments::Static.new(my_env)
+
+    Puppet.override(:environments => envs) do
+      example.run
+    end
+  end
 
   it "should support an environment" do
     loader = Puppet::Parser::TypeLoader.new(:myenv)
     loader.environment.name.should == :myenv
   end
 
   it "should delegate its known resource types to its environment" do
     loader.known_resource_types.should be_instance_of(Puppet::Resource::TypeCollection)
   end
 
   describe "when loading names from namespaces" do
     it "should do nothing if the name to import is an empty string" do
       loader.try_load_fqname(:hostclass, "").should be_nil
     end
 
     it "should attempt to import each generated name" do
       loader.expects(:import_from_modules).with("foo/bar").returns([])
       loader.expects(:import_from_modules).with("foo").returns([])
       loader.try_load_fqname(:hostclass, "foo::bar")
     end
 
     it "should attempt to load each possible name going from most to least specific" do
       path_order = sequence('path')
       ['foo/bar/baz', 'foo/bar', 'foo'].each do |path|
         Puppet::Parser::Files.expects(:find_manifests_in_modules).with(path, anything).returns([nil, []]).in_sequence(path_order)
       end
 
       loader.try_load_fqname(:hostclass, 'foo::bar::baz')
     end
   end
 
   describe "when importing" do
     let(:stub_parser) { stub 'Parser', :file= => nil, :parse => empty_hostclass }
 
     before(:each) do
       Puppet::Parser::ParserFactory.stubs(:parser).with(anything).returns(stub_parser)
     end
 
     it "should return immediately when imports are being ignored" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).never
       Puppet[:ignoreimport] = true
       loader.import("foo", "/path").should be_nil
     end
 
     it "should find all manifests matching the file or pattern" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).with("myfile", anything).returns ["modname", %w{one}]
       loader.import("myfile", "/path")
     end
 
     it "should pass the environment when looking for files" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).with(anything, loader.environment).returns ["modname", %w{one}]
       loader.import("myfile", "/path")
     end
 
     it "should fail if no files are found" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).returns [nil, []]
       lambda { loader.import("myfile", "/path") }.should raise_error(Puppet::ImportError)
     end
 
     it "should parse each found file" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", [make_absolute("/one")]]
       loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
       loader.import("myfile", "/path")
     end
 
     it "should not attempt to import files that have already been imported" do
       loader = Puppet::Parser::TypeLoader.new(:myenv)
 
       Puppet::Parser::Files.expects(:find_manifests_in_modules).twice.returns ["modname", %w{/one}]
       loader.import("myfile", "/path").should_not be_empty
 
       loader.import("myfile", "/path").should be_empty
     end
   end
 
   describe "when importing all" do
-    before do
-      @base = tmpdir("base")
+    let(:base) { tmpdir("base") }
+    let(:modulebase1) { File.join(base, "first") }
+    let(:modulebase2) { File.join(base, "second") }
+    let(:my_env) { Puppet::Node::Environment.create(:myenv, [modulebase1, modulebase2]) }
 
+    before do
       # Create two module path directories
-      @modulebase1 = File.join(@base, "first")
-      FileUtils.mkdir_p(@modulebase1)
-      @modulebase2 = File.join(@base, "second")
-      FileUtils.mkdir_p(@modulebase2)
-
-      Puppet[:modulepath] = "#{@modulebase1}#{File::PATH_SEPARATOR}#{@modulebase2}"
+      FileUtils.mkdir_p(modulebase1)
+      FileUtils.mkdir_p(modulebase2)
     end
 
     def mk_module(basedir, name)
       PuppetSpec::Modules.create(name, basedir)
     end
 
     # We have to pass the base path so that we can
     # write to modules that are in the second search path
     def mk_manifests(base, mod, files)
       files.collect do |file|
         name = mod.name + "::" + file.gsub("/", "::")
         path = File.join(base, mod.name, "manifests", file + ".pp")
         FileUtils.mkdir_p(File.split(path)[0])
 
         # write out the class
         File.open(path, "w") { |f| f.print "class #{name} {}" }
         name
       end
     end
 
     it "should load all puppet manifests from all modules in the specified environment" do
-      @module1 = mk_module(@modulebase1, "one")
-      @module2 = mk_module(@modulebase2, "two")
+      module1 = mk_module(modulebase1, "one")
+      module2 = mk_module(modulebase2, "two")
 
-      mk_manifests(@modulebase1, @module1, %w{a b})
-      mk_manifests(@modulebase2, @module2, %w{c d})
+      mk_manifests(modulebase1, module1, %w{a b})
+      mk_manifests(modulebase2, module2, %w{c d})
 
       loader.import_all
 
       loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should not load manifests from duplicate modules later in the module path" do
-      @module1 = mk_module(@modulebase1, "one")
+      module1 = mk_module(modulebase1, "one")
 
       # duplicate
-      @module2 = mk_module(@modulebase2, "one")
+      module2 = mk_module(modulebase2, "one")
 
-      mk_manifests(@modulebase1, @module1, %w{a})
-      mk_manifests(@modulebase2, @module2, %w{c})
+      mk_manifests(modulebase1, module1, %w{a})
+      mk_manifests(modulebase2, module2, %w{c})
 
       loader.import_all
 
       loader.environment.known_resource_types.hostclass("one::c").should be_nil
     end
 
     it "should load manifests from subdirectories" do
-      @module1 = mk_module(@modulebase1, "one")
+      module1 = mk_module(modulebase1, "one")
 
-      mk_manifests(@modulebase1, @module1, %w{a a/b a/b/c})
+      mk_manifests(modulebase1, module1, %w{a a/b a/b/c})
 
       loader.import_all
 
       loader.environment.known_resource_types.hostclass("one::a::b").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("one::a::b::c").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should skip modules that don't have manifests" do
-      @module1 = mk_module(@modulebase1, "one")
-      @module2 = mk_module(@modulebase2, "two")
-      mk_manifests(@modulebase2, @module2, %w{c d})
+      module1 = mk_module(modulebase1, "one")
+      module2 = mk_module(modulebase2, "two")
+      mk_manifests(modulebase2, module2, %w{c d})
 
       loader.import_all
 
       loader.environment.known_resource_types.hostclass("one::a").should be_nil
       loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
     end
   end
 
   describe "when parsing a file" do
     it "should create a new parser instance for each file using the current environment" do
       parser = stub 'Parser', :file= => nil, :parse => empty_hostclass
 
       Puppet::Parser::ParserFactory.expects(:parser).twice.with(loader.environment).returns(parser)
 
       loader.parse_file("/my/file")
       loader.parse_file("/my/other_file")
     end
 
     it "should assign the parser its file and parse" do
       parser = mock 'parser'
 
       Puppet::Parser::ParserFactory.expects(:parser).with(loader.environment).returns(parser)
       parser.expects(:file=).with("/my/file")
       parser.expects(:parse).returns(empty_hostclass)
 
       loader.parse_file("/my/file")
     end
   end
 
   it "should be able to add classes to the current resource type collection" do
     file = tmpfile("simple_file.pp")
     File.open(file, "w") { |f| f.puts "class foo {}" }
     loader.import(File.basename(file), File.dirname(file))
 
     loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
   end
 end
diff --git a/spec/unit/pops/evaluator/evaluating_parser_spec.rb b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
index ce95ca71d..48558f930 100644
--- a/spec/unit/pops/evaluator/evaluating_parser_spec.rb
+++ b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
@@ -1,1320 +1,1323 @@
 require 'spec_helper'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet/loaders'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 require 'puppet/parser/e4_parser_adapter'
 
 
 # relative to this spec file (./) does not work as this file is loaded by rspec
 #require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
 
 describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   include PuppetSpec::Pops
   include PuppetSpec::Scope
   before(:each) do
     Puppet[:strict_variables] = true
 
     # Tests needs a known configuration of node/scope/compiler since it parses and evaluates
     # snippets as the compiler will evaluate them, butwithout the overhead of compiling a complete
     # catalog for each tested expression.
     #
     @parser  = Puppet::Pops::Parser::EvaluatingParser.new
     @node = Puppet::Node.new('node.example.com')
-    @node.environment = Puppet::Node::Environment.create(:testing, [])
+    @node.environment = environment
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler)
     @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
     @scope.parent = @compiler.topscope
   end
 
-  let(:parser) {  @parser }
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:parser) { @parser }
   let(:scope) { @scope }
   types = Puppet::Pops::Types::TypeFactory
 
   context "When evaluator evaluates literals" do
     {
       "1"             => 1,
       "010"           => 8,
       "0x10"          => 16,
       "3.14"          => 3.14,
       "0.314e1"       => 3.14,
       "31.4e-1"       => 3.14,
       "'1'"           => '1',
       "'banana'"      => 'banana',
       '"banana"'      => 'banana',
       "banana"        => 'banana',
       "banana::split" => 'banana::split',
       "false"         => false,
       "true"          => true,
       "Array"         => types.array_of_data(),
       "/.*/"          => /.*/
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
   end
 
   context "When the evaluator evaluates Lists and Hashes" do
     {
       "[]"                                              => [],
       "[1,2,3]"                                         => [1,2,3],
       "[1,[2.0, 2.1, [2.2]],[3.0, 3.1]]"                => [1,[2.0, 2.1, [2.2]],[3.0, 3.1]],
       "[2 + 2]"                                         => [4],
       "[1,2,3] == [1,2,3]"                              => true,
       "[1,2,3] != [2,3,4]"                              => true,
       "[1,2,3] == [2,2,3]"                              => false,
       "[1,2,3] != [1,2,3]"                              => false,
       "[1,2,3][2]"                                      => 3,
       "[1,2,3] + [4,5]"                                 => [1,2,3,4,5],
       "[1,2,3] + [[4,5]]"                               => [1,2,3,[4,5]],
       "[1,2,3] + 4"                                     => [1,2,3,4],
       "[1,2,3] << [4,5]"                                => [1,2,3,[4,5]],
       "[1,2,3] << {'a' => 1, 'b'=>2}"                   => [1,2,3,{'a' => 1, 'b'=>2}],
       "[1,2,3] << 4"                                    => [1,2,3,4],
       "[1,2,3,4] - [2,3]"                               => [1,4],
       "[1,2,3,4] - [2,5]"                               => [1,3,4],
       "[1,2,3,4] - 2"                                   => [1,3,4],
       "[1,2,3,[2],4] - 2"                               => [1,3,[2],4],
       "[1,2,3,[2,3],4] - [[2,3]]"                       => [1,2,3,4],
       "[1,2,3,3,2,4,2,3] - [2,3]"                       => [1,4],
       "[1,2,3,['a',1],['b',2]] - {'a' => 1, 'b'=>2}"    => [1,2,3],
       "[1,2,3,{'a'=>1,'b'=>2}] - [{'a' => 1, 'b'=>2}]"  => [1,2,3],
       "[1,2,3] + {'a' => 1, 'b'=>2}"                    => [1,2,3,['a',1],['b',2]],
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "[1,2,3][a]" => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
 
     {
       "{}"                                       => {},
       "{'a'=>1,'b'=>2}"                          => {'a'=>1,'b'=>2},
       "{'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}}"        => {'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}},
       "{'a'=> 2 + 2}"                            => {'a'=> 4},
       "{'a'=> 1, 'b'=>2} == {'a'=> 1, 'b'=>2}"   => true,
       "{'a'=> 1, 'b'=>2} != {'x'=> 1, 'b'=>2}"   => true,
       "{'a'=> 1, 'b'=>2} == {'a'=> 2, 'b'=>3}"   => false,
       "{'a'=> 1, 'b'=>2} != {'a'=> 1, 'b'=>2}"   => false,
       "{a => 1, b => 2}[b]"                      => 2,
       "{2+2 => sum, b => 2}[4]"                  => 'sum',
       "{'a'=>1, 'b'=>2} + {'c'=>3}"              => {'a'=>1,'b'=>2,'c'=>3},
       "{'a'=>1, 'b'=>2} + {'b'=>3}"              => {'a'=>1,'b'=>3},
       "{'a'=>1, 'b'=>2} + ['c', 3, 'b', 3]"      => {'a'=>1,'b'=>3, 'c'=>3},
       "{'a'=>1, 'b'=>2} + [['c', 3], ['b', 3]]"  => {'a'=>1,'b'=>3, 'c'=>3},
       "{'a'=>1, 'b'=>2} - {'b' => 3}"            => {'a'=>1},
       "{'a'=>1, 'b'=>2, 'c'=>3} - ['b', 'c']"    => {'a'=>1},
       "{'a'=>1, 'b'=>2, 'c'=>3} - 'c'"           => {'a'=>1, 'b'=>2},
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "{'a' => 1, 'b'=>2} << 1" => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When the evaluator perform comparisons" do
     {
       "'a' == 'a'"     => true,
       "'a' == 'b'"     => false,
       "'a' != 'a'"     => false,
       "'a' != 'b'"     => true,
       "'a' < 'b' "     => true,
       "'a' < 'a' "     => false,
       "'b' < 'a' "     => false,
       "'a' <= 'b'"     => true,
       "'a' <= 'a'"     => true,
       "'b' <= 'a'"     => false,
       "'a' > 'b' "     => false,
       "'a' > 'a' "     => false,
       "'b' > 'a' "     => true,
       "'a' >= 'b'"     => false,
       "'a' >= 'a'"     => true,
       "'b' >= 'a'"     => true,
       "'a' == 'A'"     => true,
       "'a' != 'A'"     => false,
       "'a' >  'A'"     => false,
       "'a' >= 'A'"     => true,
       "'A' <  'a'"     => false,
       "'A' <= 'a'"     => true,
       "1 == 1"         => true,
       "1 == 2"         => false,
       "1 != 1"         => false,
       "1 != 2"         => true,
       "1 < 2 "         => true,
       "1 < 1 "         => false,
       "2 < 1 "         => false,
       "1 <= 2"         => true,
       "1 <= 1"         => true,
       "2 <= 1"         => false,
       "1 > 2 "         => false,
       "1 > 1 "         => false,
       "2 > 1 "         => true,
       "1 >= 2"         => false,
       "1 >= 1"         => true,
       "2 >= 1"         => true,
       "1 == 1.0 "      => true,
       "1 < 1.1  "      => true,
       "1.0 == 1 "      => true,
       "1.0 < 2  "      => true,
       "'1.0' < 'a'"    => true,
       "'1.0' < '' "    => false,
       "'1.0' < ' '"    => false,
       "'a' > '1.0'"    => true,
       "/.*/ == /.*/ "  => true,
       "/.*/ != /a.*/"  => true,
       "true  == true " => true,
       "false == false" => true,
       "true == false"  => false,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
    {
      "a > 1" => /String > Integer/,
      "a >= 1" => /String >= Integer/,
      "a < 1" => /String < Integer/,
      "a <= 1" => /String <= Integer/,
      "1 > a" => /Integer > String/,
      "1 >= a" => /Integer >= String/,
      "1 < a" => /Integer < String/,
      "1 <= a" => /Integer <= String/,
    }.each do | source, error|
      it "should not allow comparison of String and Number '#{source}'" do
        expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(error)
      end
    end
 
    {
       "'a' =~ /.*/"                     => true,
       "'a' =~ '.*'"                     => true,
       "/.*/ != /a.*/"                   => true,
       "'a' !~ /b.*/"                    => true,
       "'a' !~ 'b.*'"                    => true,
       '$x = a; a =~ "$x.*"'             => true,
       "a =~ Pattern['a.*']"             => true,
       "a =~ Regexp['a.*']"              => false, # String is not subtype of Regexp. PUP-957
       "$x = /a.*/ a =~ $x"              => true,
       "$x = Pattern['a.*'] a =~ $x"     => true,
       "1 =~ Integer"                    => true,
       "1 !~ Integer"                    => false,
       "[1,2,3] =~ Array[Integer[1,10]]" => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "666 =~ /6/"    => :error,
       "[a] =~ /a/"    => :error,
       "{a=>1} =~ /a/" => :error,
        "/a/ =~ /a/"    => :error,
       "Array =~ /A/"  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
 
     {
       "1 in [1,2,3]"                  => true,
       "4 in [1,2,3]"                  => false,
       "a in {x=>1, a=>2}"             => true,
       "z in {x=>1, a=>2}"             => false,
       "ana in bananas"                => true,
       "xxx in bananas"                => false,
       "/ana/ in bananas"              => true,
       "/xxx/ in bananas"              => false,
       "ANA in bananas"                => false, # ANA is a type, not a String
       "String[1] in bananas"          => false, # Philosophically true though :-)
       "'ANA' in bananas"              => true,
       "ana in 'BANANAS'"              => true,
       "/ana/ in 'BANANAS'"            => false,
       "/ANA/ in 'BANANAS'"            => true,
       "xxx in 'BANANAS'"              => false,
       "[2,3] in [1,[2,3],4]"          => true,
       "[2,4] in [1,[2,3],4]"          => false,
       "[a,b] in ['A',['A','B'],'C']"  => true,
       "[x,y] in ['A',['A','B'],'C']"  => false,
       "a in {a=>1}"                   => true,
       "x in {a=>1}"                   => false,
       "'A' in {a=>1}"                 => true,
       "'X' in {a=>1}"                 => false,
       "a in {'A'=>1}"                 => true,
       "x in {'A'=>1}"                 => false,
       "/xxx/ in {'aaaxxxbbb'=>1}"     => true,
       "/yyy/ in {'aaaxxxbbb'=>1}"     => false,
       "15 in [1, 0xf]"                => true,
       "15 in [1, '0xf']"              => false,
       "'15' in [1, 0xf]"              => false,
       "15 in [1, 115]"                => false,
       "1 in [11, '111']"              => false,
       "'1' in [11, '111']"            => false,
       "Array[Integer] in [2, 3]"      => false,
       "Array[Integer] in [2, [3, 4]]" => true,
       "Array[Integer] in [2, [a, 4]]" => false,
       "Integer in { 2 =>'a'}"         => true,
       "Integer[5,10] in [1,5,3]"      => true,
       "Integer[5,10] in [1,2,3]"      => false,
       "Integer in {'a'=>'a'}"         => false,
       "Integer in {'a'=>1}"           => false,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       "if /(ana)/ in bananas {$1}" => 'ana',
       "if /(xyz)/ in bananas {$1} else {$1}" => nil,
       "$a = bananas =~ /(ana)/; $b = /(xyz)/ in bananas; $1" => 'ana',
       "$a = xyz =~ /(xyz)/; $b = /(ana)/ in bananas; $1" => 'ana',
       "if /p/ in [pineapple, bananas] {$0}" => 'p',
       "if /b/ in [pineapple, bananas] {$0}" => 'b',
     }.each do |source, result|
       it "sets match variables for a regexp search using in such that '#{source}' produces '#{result}'" do
           parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       'Any'  => ['Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
                     'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
 
       # Note, Data > Collection is false (so not included)
       'Data'    => ['Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array', 'Hash',],
       'Scalar' => ['Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern'],
       'Numeric' => ['Integer', 'Float'],
       'CatalogEntry' => ['Class', 'Resource', 'File', 'NotYetKnownResourceType'],
       'Integer[1,10]' => ['Integer[2,3]'],
     }.each do |general, specials|
       specials.each do |special |
         it "should compute that #{general} > #{special}" do
           parser.evaluate_string(scope, "#{general} > #{special}", __FILE__).should == true
         end
         it "should compute that  #{special} < #{general}" do
           parser.evaluate_string(scope, "#{special} < #{general}", __FILE__).should == true
         end
         it "should compute that #{general} != #{special}" do
           parser.evaluate_string(scope, "#{special} != #{general}", __FILE__).should == true
         end
       end
     end
 
     {
       'Integer[1,10] > Integer[2,3]'   => true,
       'Integer[1,10] == Integer[2,3]'  => false,
       'Integer[1,10] > Integer[0,5]'   => false,
       'Integer[1,10] > Integer[1,10]'  => false,
       'Integer[1,10] >= Integer[1,10]' => true,
       'Integer[1,10] == Integer[1,10]' => true,
     }.each do |source, result|
         it "should parse and evaluate the integer range comparison expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
   end
 
   context "When the evaluator performs arithmetic" do
     context "on Integers" do
       {  "2+2"    => 4,
          "2 + 2"  => 4,
          "7 - 3"  => 4,
          "6 * 3"  => 18,
          "6 / 3"  => 2,
          "6 % 3"  => 0,
          "10 % 3" =>  1,
          "-(6/3)" => -2,
          "-6/3  " => -2,
          "8 >> 1" => 4,
          "8 << 1" => 16,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
     context "on Floats" do
       {
         "2.2 + 2.2"  => 4.4,
         "7.7 - 3.3"  => 4.4,
         "6.1 * 3.1"  => 18.91,
         "6.6 / 3.3"  => 2.0,
         "-(6.0/3.0)" => -2.0,
         "-6.0/3.0 "  => -2.0,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
       {
         "3.14 << 2" => :error,
         "3.14 >> 2" => :error,
         "6.6 % 3.3"  => 0.0,
         "10.0 % 3.0" =>  1.0,
       }.each do |source, result|
           it "should parse and raise error for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
           end
         end
     end
 
     context "on strings requiring boxing to Numeric" do
       {
         "'2' + '2'"       => 4,
         "'-2' + '2'"      => 0,
         "'- 2' + '2'"     => 0,
         '"-\t 2" + "2"'   => 0,
         "'+2' + '2'"      => 4,
         "'+ 2' + '2'"     => 4,
         "'2.2' + '2.2'"   => 4.4,
         "'-2.2' + '2.2'"  => 0.0,
         "'0xF7' + '010'"  => 0xFF,
         "'0xF7' + '0x8'"  => 0xFF,
         "'0367' + '010'"  => 0xFF,
         "'012.3' + '010'" => 20.3,
         "'-0x2' + '0x4'"  => 2,
         "'+0x2' + '0x4'"  => 6,
         "'-02' + '04'"    => 2,
         "'+02' + '04'"    => 6,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
       {
         "'0888' + '010'"   => :error,
         "'0xWTF' + '010'"  => :error,
         "'0x12.3' + '010'" => :error,
         "'0x12.3' + '010'" => :error,
         '"-\n 2" + "2"'    => :error,
         '"-\v 2" + "2"'    => :error,
         '"-2\n" + "2"'     => :error,
         '"-2\n " + "2"'    => :error,
       }.each do |source, result|
           it "should parse and raise error for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
           end
         end
       end
     end
   end # arithmetic
 
   context "When the evaluator evaluates assignment" do
     {
       "$a = 5"                     => 5,
       "$a = 5; $a"                 => 5,
       "$a = 5; $b = 6; $a"         => 5,
       "$a = $b = 5; $a == $b"      => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "[a,b,c] = [1,2,3]"               => /attempt to assign to 'an Array Expression'/,
       "[a,b,c] = {b=>2,c=>3,a=>1}"      => /attempt to assign to 'an Array Expression'/,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to error with #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Puppet::ParseError, result)
         end
       end
   end
 
   context "When the evaluator evaluates conditionals" do
     {
       "if true {5}"                     => 5,
       "if false {5}"                    => nil,
       "if false {2} else {5}"           => 5,
       "if false {2} elsif true {5}"     => 5,
       "if false {2} elsif false {5}"    => nil,
       "unless false {5}"                => 5,
       "unless true {5}"                 => nil,
       "unless true {2} else {5}"        => 5,
       "$a = if true {5} $a"                     => 5,
       "$a = if false {5} $a"                    => nil,
       "$a = if false {2} else {5} $a"           => 5,
       "$a = if false {2} elsif true {5} $a"     => 5,
       "$a = if false {2} elsif false {5} $a"    => nil,
       "$a = unless false {5} $a"                => 5,
       "$a = unless true {5} $a"                 => nil,
       "$a = unless true {2} else {5} $a"        => 5,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "case 1 { 1 : { yes } }"                               => 'yes',
       "case 2 { 1,2,3 : { yes} }"                            => 'yes',
       "case 2 { 1,3 : { no } 2: { yes} }"                    => 'yes',
       "case 2 { 1,3 : { no } 5: { no } default: { yes }}"    => 'yes',
       "case 2 { 1,3 : { no } 5: { no } }"                    => nil,
       "case 'banana' { 1,3 : { no } /.*ana.*/: { yes } }"    => 'yes',
       "case 'banana' { /.*(ana).*/: { $1 } }"                => 'ana',
       "case [1] { Array : { yes } }"                         => 'yes',
       "case [1] {
          Array[String] : { no }
          Array[Integer]: { yes }
       }"                                                     => 'yes',
       "case 1 {
          Integer : { yes }
          Type[Integer] : { no } }"                           => 'yes',
       "case Integer {
          Integer : { no }
          Type[Integer] : { yes } }"                          => 'yes',
       # supports unfold
       "case ringo {
          *[paul, john, ringo, george] : { 'beatle' } }"       => 'beatle',
 
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "2 ? { 1 => no, 2 => yes}"                          => 'yes',
       "3 ? { 1 => no, 2 => no, default => yes }"          => 'yes',
       "3 ? { 1 => no, default => yes, 3 => no }"          => 'no',
       "3 ? { 1 => no, 3 => no, default => yes }"          => 'no',
       "4 ? { 1 => no, default => yes, 3 => no }"          => 'yes',
       "4 ? { 1 => no, 3 => no, default => yes }"          => 'yes',
       "'banana' ? { /.*(ana).*/  => $1 }"                 => 'ana',
       "[2] ? { Array[String] => yes, Array => yes}"       => 'yes',
       "ringo ? *[paul, john, ringo, george] => 'beatle'"  => 'beatle',
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     it 'fails if a selector does not match' do
       expect{parser.evaluate_string(scope, "2 ? 3 => 4")}.to raise_error(/No matching entry for selector parameter with value '2'/)
     end
   end
 
   context "When evaluator evaluated unfold" do
     {
       "*[1,2,3]"             => [1,2,3],
       "*1"                   => [1],
       "*'a'"                 => ['a']
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     it "should parse and evaluate the expression '*{a=>10, b=>20} to [['a',10],['b',20]]" do
       result = parser.evaluate_string(scope, '*{a=>10, b=>20}', __FILE__)
       expect(result).to include(['a', 10])
       expect(result).to include(['b', 20])
     end
 
   end
 
   context "When evaluator performs [] operations" do
     {
       "[1,2,3][0]"      => 1,
       "[1,2,3][2]"      => 3,
       "[1,2,3][3]"      => nil,
       "[1,2,3][-1]"     => 3,
       "[1,2,3][-2]"     => 2,
       "[1,2,3][-4]"     => nil,
       "[1,2,3,4][0,2]"  => [1,2],
       "[1,2,3,4][1,3]"  => [2,3,4],
       "[1,2,3,4][-2,2]"  => [3,4],
       "[1,2,3,4][-3,2]"  => [2,3],
       "[1,2,3,4][3,5]"   => [4],
       "[1,2,3,4][5,2]"   => [],
       "[1,2,3,4][0,-1]"  => [1,2,3,4],
       "[1,2,3,4][0,-2]"  => [1,2,3],
       "[1,2,3,4][0,-4]"  => [1],
       "[1,2,3,4][0,-5]"  => [],
       "[1,2,3,4][-5,2]"  => [1],
       "[1,2,3,4][-5,-3]" => [1,2],
       "[1,2,3,4][-6,-3]" => [1,2],
       "[1,2,3,4][2,-3]"  => [],
       "[1,*[2,3],4]"     => [1,2,3,4],
       "[1,*[2,3],4][1]"  => 2,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       "{a=>1, b=>2, c=>3}[a]"                => 1,
       "{a=>1, b=>2, c=>3}[c]"                => 3,
       "{a=>1, b=>2, c=>3}[x]"                => nil,
       "{a=>1, b=>2, c=>3}[c,b]"              => [3,2],
       "{a=>1, b=>2, c=>3}[a,b,c]"            => [1,2,3],
       "{a=>{b=>{c=>'it works'}}}[a][b][c]"   => 'it works',
       "$a = {undef => 10} $a[free_lunch]"     => nil,
       "$a = {undef => 10} $a[undef]"          => 10,
       "$a = {undef => 10} $a[$a[free_lunch]]" => 10,
       "$a = {} $a[free_lunch] == undef"       => true,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       "'abc'[0]"      => 'a',
       "'abc'[2]"      => 'c',
       "'abc'[-1]"     => 'c',
       "'abc'[-2]"     => 'b',
       "'abc'[-3]"     => 'a',
       "'abc'[-4]"     => '',
       "'abc'[3]"      => '',
       "abc[0]"        => 'a',
       "abc[2]"        => 'c',
       "abc[-1]"       => 'c',
       "abc[-2]"       => 'b',
       "abc[-3]"       => 'a',
       "abc[-4]"       => '',
       "abc[3]"        => '',
       "'abcd'[0,2]"   => 'ab',
       "'abcd'[1,3]"   => 'bcd',
       "'abcd'[-2,2]"  => 'cd',
       "'abcd'[-3,2]"  => 'bc',
       "'abcd'[3,5]"   => 'd',
       "'abcd'[5,2]"   => '',
       "'abcd'[0,-1]"  => 'abcd',
       "'abcd'[0,-2]"  => 'abc',
       "'abcd'[0,-4]"  => 'a',
       "'abcd'[0,-5]"  => '',
       "'abcd'[-5,2]"  => 'a',
       "'abcd'[-5,-3]" => 'ab',
       "'abcd'[-6,-3]" => 'ab',
       "'abcd'[2,-3]"  => '',
    }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     # Type operations (full set tested by tests covering type calculator)
     {
       "Array[Integer]"                  => types.array_of(types.integer),
       "Array[Integer,1]"                => types.constrain_size(types.array_of(types.integer),1, :default),
       "Array[Integer,1,2]"              => types.constrain_size(types.array_of(types.integer),1, 2),
       "Array[Integer,Integer[1,2]]"     => types.constrain_size(types.array_of(types.integer),1, 2),
       "Array[Integer,Integer[1]]"       => types.constrain_size(types.array_of(types.integer),1, :default),
       "Hash[Integer,Integer]"           => types.hash_of(types.integer, types.integer),
       "Hash[Integer,Integer,1]"         => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
       "Hash[Integer,Integer,1,2]"       => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
       "Hash[Integer,Integer,Integer[1,2]]" => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
       "Hash[Integer,Integer,Integer[1]]"   => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
       "Resource[File]"                  => types.resource('File'),
       "Resource['File']"                => types.resource(types.resource('File')),
       "File[foo]"                       => types.resource('file', 'foo'),
       "File[foo, bar]"                  => [types.resource('file', 'foo'), types.resource('file', 'bar')],
       "Pattern[a, /b/, Pattern[c], Regexp[d]]"  => types.pattern('a', 'b', 'c', 'd'),
       "String[1,2]"                     => types.constrain_size(types.string,1, 2),
       "String[Integer[1,2]]"            => types.constrain_size(types.string,1, 2),
       "String[Integer[1]]"              => types.constrain_size(types.string,1, :default),
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     # LHS where [] not supported, and missing key(s)
     {
       "Array[]"                    => :error,
       "'abc'[]"                    => :error,
       "Resource[]"                 => :error,
       "File[]"                     => :error,
       "String[]"                   => :error,
       "1[]"                        => :error,
       "3.14[]"                     => :error,
       "/.*/[]"                     => :error,
       "$a=[1] $a[]"                => :error,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(/Syntax error/)
       end
     end
 
     # Errors when wrong number/type of keys are used
     {
       "Array[0]"                    => 'Array-Type[] arguments must be types. Got Fixnum',
       "Hash[0]"                     => 'Hash-Type[] arguments must be types. Got Fixnum',
       "Hash[Integer, 0]"            => 'Hash-Type[] arguments must be types. Got Fixnum',
       "Array[Integer,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
       "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 1 to 4 arguments. Got 5',
       "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
       "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
       "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Integer where a resource title String is expected',
       "String[a]"                   => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String",
       "Pattern[0]"                  => 'Error creating type specialization of a Pattern-Type, Cannot use Integer where String or Regexp or Pattern-Type or Regexp-Type is expected',
       "Regexp[0]"                   => 'Error creating type specialization of a Regexp-Type, Cannot use Integer where String or Regexp is expected',
       "Regexp[a,b]"                 => 'A Regexp-Type[] accepts 1 argument. Got 2',
       "true[0]"                     => "Operator '[]' is not applicable to a Boolean",
       "1[0]"                        => "Operator '[]' is not applicable to an Integer",
       "3.14[0]"                     => "Operator '[]' is not applicable to a Float",
       "/.*/[0]"                     => "Operator '[]' is not applicable to a Regexp",
       "[1][a]"                      => "The value 'a' cannot be converted to Numeric",
       "[1][0.0]"                    => "An Array[] cannot use Float where Integer is expected",
       "[1]['0.0']"                  => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1, 0.0]"               => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1.0, -1]"              => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1, -1.0]"              => "An Array[] cannot use Float where Integer is expected",
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Regexp.new(Regexp.quote(result)))
       end
     end
 
     context "on catalog types" do
       it "[n] gets resource parameter [n]" do
         source = "notify { 'hello': message=>'yo'} Notify[hello][message]"
         parser.evaluate_string(scope, source, __FILE__).should == 'yo'
       end
 
       it "[n] gets class parameter [n]" do
         source = "class wonka($produces='chocolate'){ }
            include wonka
            Class[wonka][produces]"
 
         # This is more complicated since it needs to run like 3.x and do an import_ast
         adapted_parser = Puppet::Parser::E4ParserAdapter.new
         adapted_parser.file = __FILE__
         ast = adapted_parser.parse(source)
-        Puppet.override({:global_scope => scope}, "test") do
+        Puppet.override({:global_scope => scope,
+                         :environments => Puppet::Environments::Static.new(@node.environment)
+        }, "gets class parameter test") do
           scope.known_resource_types.import_ast(ast, '')
           ast.code.safeevaluate(scope).should == 'chocolate'
         end
       end
 
       # Resource default and override expressions and resource parameter access with []
       {
         # Properties
         "notify { id: message=>explicit} Notify[id][message]"                   => "explicit",
         "Notify { message=>by_default} notify {foo:} Notify[foo][message]"      => "by_default",
         "notify {foo:} Notify[foo]{message =>by_override} Notify[foo][message]" => "by_override",
         # Parameters
         "notify { id: withpath=>explicit} Notify[id][withpath]"                 => "explicit",
         "Notify { withpath=>by_default } notify { foo: } Notify[foo][withpath]" => "by_default",
         "notify {foo:}
          Notify[foo]{withpath=>by_override}
          Notify[foo][withpath]"                                                 => "by_override",
         # Metaparameters
         "notify { foo: tag => evoe} Notify[foo][tag]"                           => "evoe",
         # Does not produce the defaults for tag parameter (title, type or names of scopes)
         "notify { foo: } Notify[foo][tag]"                                      => nil,
         # But a default may be specified on the type
         "Notify { tag=>by_default } notify { foo: } Notify[foo][tag]"           => "by_default",
         "Notify { tag=>by_default }
          notify { foo: }
          Notify[foo]{ tag=>by_override }
          Notify[foo][tag]"                                                      => "by_override",
       }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
       # Virtual and realized resource default and overridden resource parameter access with []
       {
         # Properties
         "@notify { id: message=>explicit } Notify[id][message]"                 => "explicit",
         "@notify { id: message=>explicit }
          realize Notify[id]
          Notify[id][message]"                                                   => "explicit",
         "Notify { message=>by_default } @notify { id: } Notify[id][message]"    => "by_default",
         "Notify { message=>by_default }
          @notify { id: tag=>thisone }
          Notify <| tag == thisone |>;
          Notify[id][message]"                                                   => "by_default",
         "@notify { id: } Notify[id]{message=>by_override} Notify[id][message]"  => "by_override",
         # Parameters
         "@notify { id: withpath=>explicit } Notify[id][withpath]"               => "explicit",
         "Notify { withpath=>by_default }
          @notify { id: }
          Notify[id][withpath]"                                                  => "by_default",
         "@notify { id: }
          realize Notify[id]
          Notify[id]{withpath=>by_override}
          Notify[id][withpath]"                                                  => "by_override",
         # Metaparameters
         "@notify { id: tag=>explicit } Notify[id][tag]"                         => "explicit",
       }.each do |source, result|
         it "parses and evaluates virtual and realized resources in the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
       # Exported resource attributes
       {
         "@@notify { id: message=>explicit } Notify[id][message]"                => "explicit",
         "@@notify { id: message=>explicit, tag=>thisone }
          Notify <<| tag == thisone |>>
          Notify[id][message]"                                                   => "explicit",
       }.each do |source, result|
         it "parses and evaluates exported resources in the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
       # Resource default and override expressions and resource parameter access error conditions
       {
         "notify { xid: message=>explicit} Notify[id][message]"  => /Resource not found/,
         "notify { id: message=>explicit} Notify[id][mustard]"   => /does not have a parameter called 'mustard'/,
         # NOTE: these meta-esque parameters are not recognized as such
         "notify { id: message=>explicit} Notify[id][title]"   => /does not have a parameter called 'title'/,
         "notify { id: message=>explicit} Notify[id]['type']"   => /does not have a parameter called 'type'/,
         "notify { id: message=>explicit } Notify[id]{message=>override}" => /'message' is already set on Notify\[id\]/
       }.each do |source, result|
         it "should parse '#{source}' and raise error matching #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(result)
         end
       end
 
       context 'with errors' do
         { "Class['fail-whale']" => /Illegal name/,
           "Class[0]"            => /An Integer cannot be used where a String is expected/,
           "Class[/.*/]"         => /A Regexp cannot be used where a String is expected/,
           "Class[4.1415]"       => /A Float cannot be used where a String is expected/,
           "Class[Integer]"      => /An Integer-Type cannot be used where a String is expected/,
           "Class[File['tmp']]"   => /A File\['tmp'\] Resource-Reference cannot be used where a String is expected/,
         }.each do | source, error_pattern|
           it "an error is flagged for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(error_pattern)
           end
         end
       end
     end
   # end [] operations
   end
 
   context "When the evaluator performs boolean operations" do
     {
       "true and true"   => true,
       "false and true"  => false,
       "true and false"  => false,
       "false and false" => false,
       "true or true"    => true,
       "false or true"   => true,
       "true or false"   => true,
       "false or false"  => false,
       "! true"          => false,
       "!! true"         => true,
       "!! false"        => false,
       "! 'x'"           => false,
       "! ''"            => false,
       "! undef"         => true,
       "! [a]"           => false,
       "! []"            => false,
       "! {a=>1}"        => false,
       "! {}"            => false,
       "true and false and '0xwtf' + 1"  => false,
       "false or true  or '0xwtf' + 1"  => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "false || false || '0xwtf' + 1"   => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When evaluator performs operations on literal undef" do
     it "computes non existing hash lookup as undef" do
       parser.evaluate_string(scope, "{a => 1}[b] == undef", __FILE__).should == true
       parser.evaluate_string(scope, "undef == {a => 1}[b]", __FILE__).should == true
     end
   end
 
   context "When evaluator performs calls" do
 
     let(:populate) do
       parser.evaluate_string(scope, "$a = 10 $b = [1,2,3]")
     end
 
     {
       'sprintf( "x%iy", $a )'                 => "x10y",
       # unfolds
       'sprintf( *["x%iy", $a] )'              => "x10y",
       '"x%iy".sprintf( $a )'                  => "x10y",
       '$b.reduce |$memo,$x| { $memo + $x }'   => 6,
       'reduce($b) |$memo,$x| { $memo + $x }'  => 6,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           populate
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
 
     it "provides location information on error in unparenthesized call logic" do
     expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /line 1\:1/)
     end
 
     it 'defaults can be given in a lambda and used only when arg is missing' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:test) do
         dispatch :test do
           param 'Integer', 'count'
           required_block_param
         end
         def test(count, block)
           block.call(*[].fill(10, 0, count))
         end
       end
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'test', the_func, __FILE__)
       expect(parser.evaluate_string(scope, "test(1) |$x, $y=20| { $x + $y}")).to eql(30)
       expect(parser.evaluate_string(scope, "test(2) |$x, $y=20| { $x + $y}")).to eql(20)
     end
 
     it 'a given undef does not select the default value' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:test) do
         dispatch :test do
           param 'Any', 'lambda_arg'
           required_block_param
         end
         def test(lambda_arg, block)
           block.call(lambda_arg)
         end
       end
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'test', the_func, __FILE__)
 
       expect(parser.evaluate_string(scope, "test(undef) |$x=20| { $x == undef}")).to eql(true)
     end
 
     it 'a given undef is given as nil' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:assert_no_undef) do
         dispatch :assert_no_undef do
           param 'Any', 'x'
         end
 
         def assert_no_undef(x)
           case x
           when Array
             return unless x.include?(:undef)
           when Hash
             return unless x.keys.include?(:undef) || x.values.include?(:undef)
           else
             return unless x == :undef
           end
           raise "contains :undef"
         end
       end
 
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'assert_no_undef', the_func, __FILE__)
 
       expect{parser.evaluate_string(scope, "assert_no_undef(undef)")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef([undef])")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef({undef => 1})")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef({1 => undef})")}.to_not raise_error()
     end
 
     context 'using the 3x function api' do
       it 'can call a 3x function' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
         parser.evaluate_string(scope, "bazinga(42)", __FILE__).should == 42
       end
 
       it 'maps :undef to empty string' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
         parser.evaluate_string(scope, "$a = {} bazinga($a[nope])", __FILE__).should == ''
         parser.evaluate_string(scope, "bazinga(undef)", __FILE__).should == ''
       end
 
       it 'does not map :undef to empty string in arrays' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] }
         parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__).should == :undef
         parser.evaluate_string(scope, "bazinga([undef])", __FILE__).should == :undef
       end
 
       it 'does not map :undef to empty string in hashes' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] }
         parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__).should == :undef
         parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__).should == :undef
       end
     end
   end
 
   context "When evaluator performs string interpolation" do
     let(:populate) do
       parser.evaluate_string(scope, "$a = 10 $b = [1,2,3]")
     end
 
     {
       '"value is $a yo"'                      => "value is 10 yo",
       '"value is \$a yo"'                     => "value is $a yo",
       '"value is ${a} yo"'                    => "value is 10 yo",
       '"value is \${a} yo"'                   => "value is ${a} yo",
       '"value is ${$a} yo"'                   => "value is 10 yo",
       '"value is ${$a*2} yo"'                 => "value is 20 yo",
       '"value is ${sprintf("x%iy",$a)} yo"'   => "value is x10y yo",
       '"value is ${"x%iy".sprintf($a)} yo"'   => "value is x10y yo",
       '"value is ${[1,2,3]} yo"'              => "value is [1, 2, 3] yo",
       '"value is ${/.*/} yo"'                 => "value is /.*/ yo",
       '$x = undef "value is $x yo"'           => "value is  yo",
       '$x = default "value is $x yo"'         => "value is default yo",
       '$x = Array[Integer] "value is $x yo"'  => "value is Array[Integer] yo",
       '"value is ${Array[Integer]} yo"'       => "value is Array[Integer] yo",
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           populate
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     it "should parse and evaluate an interpolation of a hash" do
       source = '"value is ${{a=>1,b=>2}} yo"'
       # This test requires testing against two options because a hash to string
       # produces a result that is unordered
       hashstr = {'a' => 1, 'b' => 2}.to_s
       alt_results = ["value is {a => 1, b => 2} yo", "value is {b => 2, a => 1} yo" ]
       populate
       parse_result = parser.evaluate_string(scope, source, __FILE__)
       alt_results.include?(parse_result).should == true
     end
 
     it 'should accept a variable with leading underscore when used directly' do
       source = '$_x = 10; "$_x"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
     end
 
     it 'should accept a variable with leading underscore when used as an expression' do
       source = '$_x = 10; "${_x}"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
     end
 
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When evaluating variables" do
     context "that are non existing an error is raised for" do
       it "unqualified variable" do
         expect { parser.evaluate_string(scope, "$quantum_gravity", __FILE__) }.to raise_error(/Unknown variable/)
       end
 
       it "qualified variable" do
         expect { parser.evaluate_string(scope, "$quantum_gravity::graviton", __FILE__) }.to raise_error(/Unknown variable/)
       end
     end
 
     it "a lex error should be raised for '$foo::::bar'" do
       expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::LexError, /Illegal fully qualified name at line 1:7/)
     end
 
     { '$a = $0'   => nil,
       '$a = $1'   => nil,
     }.each do |source, value|
       it "it is ok to reference numeric unassigned variables '#{source}'" do
         parser.evaluate_string(scope, source, __FILE__).should == value
       end
     end
 
     { '$00 = 0'   => /must be a decimal value/,
       '$0xf = 0'  => /must be a decimal value/,
       '$0777 = 0' => /must be a decimal value/,
       '$123a = 0' => /must be a decimal value/,
     }.each do |source, error_pattern|
       it "should raise an error for '#{source}'" do
         expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(error_pattern)
       end
     end
 
     context "an initial underscore in the last segment of a var name is allowed" do
       { '$_a  = 1'   => 1,
         '$__a = 1'   => 1,
       }.each do |source, value|
         it "as in this example '#{source}'" do
           parser.evaluate_string(scope, source, __FILE__).should == value
         end
       end
     end
   end
 
   context "When evaluating relationships" do
     it 'should form a relation with File[a] -> File[b]' do
       source = "File[a] -> File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'b'])
     end
 
     it 'should form a relation with resource -> resource' do
       source = "notify{a:} -> notify{b:}"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['Notify', 'a', '->', 'Notify', 'b'])
     end
 
     it 'should form a relation with [File[a], File[b]] -> [File[x], File[y]]' do
       source = "[File[a], File[b]] -> [File[x], File[y]]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'x'])
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'x'])
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'y'])
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'y'])
     end
 
     it 'should tolerate (eliminate) duplicates in operands' do
       source = "[File[a], File[a]] -> File[x]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'x'])
       scope.compiler.relationships.size.should == 1
     end
 
     it 'should form a relation with <-' do
       source = "File[a] <- File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'a'])
     end
 
     it 'should form a relation with <-' do
       source = "File[a] <~ File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'b', '~>', 'File', 'a'])
     end
   end
 
   context "When evaluating heredoc" do
     it "evaluates plain heredoc" do
       src = "@(END)\nThis is\nheredoc text\nEND\n"
       parser.evaluate_string(scope, src).should == "This is\nheredoc text\n"
     end
 
     it "parses heredoc with margin" do
       src = [
       "@(END)",
       "   This is",
       "   heredoc text",
       "   | END",
       ""
       ].join("\n")
       parser.evaluate_string(scope, src).should == "This is\nheredoc text\n"
     end
 
     it "parses heredoc with margin and right newline trim" do
       src = [
       "@(END)",
       "   This is",
       "   heredoc text",
       "   |- END",
       ""
       ].join("\n")
       parser.evaluate_string(scope, src).should == "This is\nheredoc text"
     end
 
     it "parses escape specification" do
       src = <<-CODE
       @(END/t)
       Tex\\tt\\n
       |- END
       CODE
       parser.evaluate_string(scope, src).should == "Tex\tt\\n"
     end
 
     it "parses syntax checked specification" do
       src = <<-CODE
       @(END:json)
       ["foo", "bar"]
       |- END
       CODE
       parser.evaluate_string(scope, src).should == '["foo", "bar"]'
     end
 
     it "parses syntax checked specification with error and reports it" do
       src = <<-CODE
       @(END:json)
       ['foo', "bar"]
       |- END
       CODE
       expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid JSON string/)
     end
 
     it "parses interpolated heredoc expression" do
       src = <<-CODE
       $name = 'Fjodor'
       @("END")
       Hello $name
       |- END
       CODE
       parser.evaluate_string(scope, src).should == "Hello Fjodor"
     end
 
   end
   context "Handles Deprecations and Discontinuations" do
     it 'of import statements' do
       source = "\nimport foo"
       # Error references position 5 at the opening '{'
       # Set file to nil to make it easier to match with line number (no file name in output)
       expect { parser.evaluate_string(scope, source) }.to raise_error(/'import' has been discontinued.*line 2:1/)
     end
   end
 
   context "Detailed Error messages are reported" do
     it 'for illegal type references' do
       source = '1+1 { "title": }'
       # Error references position 5 at the opening '{'
       # Set file to nil to make it easier to match with line number (no file name in output)
       expect { parser.evaluate_string(scope, source) }.to raise_error(
         /Illegal Resource Type expression, expected result to be a type name, or untitled Resource.*line 1:2/)
     end
 
     it 'for non r-value producing <| |>' do
       expect { parser.parse_string("$a = File <| |>", nil) }.to raise_error(/A Virtual Query does not produce a value at line 1:6/)
     end
 
     it 'for non r-value producing <<| |>>' do
       expect { parser.parse_string("$a = File <<| |>>", nil) }.to raise_error(/An Exported Query does not produce a value at line 1:6/)
     end
 
     it 'for non r-value producing define' do
       Puppet.expects(:err).with("Invalid use of expression. A 'define' expression does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = define foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for non r-value producing class' do
       Puppet.expects(:err).with("Invalid use of expression. A Host Class Definition does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = class foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for unclosed quote with indication of start position of string' do
       source = <<-SOURCE.gsub(/^ {6}/,'')
       $a = "xx
       yyy
       SOURCE
       # first char after opening " reported as being in error.
       expect { parser.parse_string(source) }.to raise_error(/Unclosed quote after '"' followed by 'xx\\nyy\.\.\.' at line 1:7/)
     end
 
     it 'for multiple errors with a summary exception' do
       Puppet.expects(:err).with("Invalid use of expression. A Node Definition does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = node x { }",nil) }.to raise_error(/2 errors/)
     end
 
     it 'for a bad hostname' do
       expect {
         parser.parse_string("node 'macbook+owned+by+name' { }", nil)
       }.to raise_error(/The hostname 'macbook\+owned\+by\+name' contains illegal characters.*at line 1:6/)
     end
 
     it 'for a hostname with interpolation' do
       source = <<-SOURCE.gsub(/^ {6}/,'')
       $name = 'fred'
       node "macbook-owned-by$name" { }
       SOURCE
       expect {
         parser.parse_string(source, nil)
       }.to raise_error(/An interpolated expression is not allowed in a hostname of a node at line 2:23/)
     end
 
   end
 
   context 'does not leak variables' do
     it 'local variables are gone when lambda ends' do
       source = <<-SOURCE
       [1,2,3].each |$x| { $y = $x}
       $a = $y
       SOURCE
       expect do
         parser.evaluate_string(scope, source)
       end.to raise_error(/Unknown variable: 'y'/)
     end
 
     it 'lambda parameters are gone when lambda ends' do
       source = <<-SOURCE
       [1,2,3].each |$x| { $y = $x}
       $a = $x
       SOURCE
       expect do
         parser.evaluate_string(scope, source)
       end.to raise_error(/Unknown variable: 'x'/)
     end
 
     it 'does not leak match variables' do
       source = <<-SOURCE
       if 'xyz' =~ /(x)(y)(z)/ { notice $2 }
       case 'abc' {
         /(a)(b)(c)/ : { $x = $2 }
       }
       "-$x-$2-"
       SOURCE
       expect(parser.evaluate_string(scope, source)).to eq('-b--')
     end
   end
 
   matcher :have_relationship do |expected|
     calc = Puppet::Pops::Types::TypeCalculator.new
 
     match do |compiler|
       op_name = {'->' => :relationship, '~>' => :subscription}
       compiler.relationships.any? do | relation |
         relation.source.type == expected[0] &&
         relation.source.title == expected[1] &&
         relation.type == op_name[expected[2]] &&
         relation.target.type == expected[3] &&
         relation.target.title == expected[4]
       end
     end
 
     failure_message_for_should do |actual|
       "Relationship #{expected[0]}[#{expected[1]}] #{expected[2]} #{expected[3]}[#{expected[4]}] but was unknown to compiler"
     end
   end
 
 end
diff --git a/spec/unit/resource/type_spec.rb b/spec/unit/resource/type_spec.rb
index fbe96da6d..b1ddf847b 100755
--- a/spec/unit/resource/type_spec.rb
+++ b/spec/unit/resource/type_spec.rb
@@ -1,773 +1,772 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource/type'
 require 'puppet/pops'
 require 'matchers/json'
 
 describe Puppet::Resource::Type do
   include JSONMatchers
 
   it "should have a 'name' attribute" do
     Puppet::Resource::Type.new(:hostclass, "foo").name.should == "foo"
   end
 
   [:code, :doc, :line, :file, :resource_type_collection].each do |attr|
     it "should have a '#{attr}' attribute" do
       type = Puppet::Resource::Type.new(:hostclass, "foo")
       type.send(attr.to_s + "=", "yay")
       type.send(attr).should == "yay"
     end
   end
 
   [:hostclass, :node, :definition].each do |type|
     it "should know when it is a #{type}" do
       Puppet::Resource::Type.new(type, "foo").send("#{type}?").should be_true
     end
   end
 
   it "should indirect 'resource_type'" do
     Puppet::Resource::Type.indirection.name.should == :resource_type
   end
 
   it "should default to 'parser' for its terminus class" do
     Puppet::Resource::Type.indirection.terminus_class.should == :parser
   end
 
   describe "when converting to json" do
     before do
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
     end
 
     def from_json(json)
       Puppet::Resource::Type.from_data_hash(json)
     end
 
     def double_convert
       Puppet::Resource::Type.from_data_hash(PSON.parse(@type.to_pson))
     end
 
     it "should include the name and type" do
       double_convert.name.should == @type.name
       double_convert.type.should == @type.type
     end
 
     it "should validate with only name and kind" do
       expect(@type.to_pson).to validate_against('api/schemas/resource_type.json')
     end
 
     it "should validate with all fields set" do
       @type.set_arguments("one" => nil, "two" => "foo")
       @type.line = 100
       @type.doc = "A weird type"
       @type.file = "/etc/manifests/thing.pp"
       @type.parent = "one::two"
 
       expect(@type.to_pson).to validate_against('api/schemas/resource_type.json')
     end
 
     it "should include any arguments" do
       @type.set_arguments("one" => nil, "two" => "foo")
 
       double_convert.arguments.should == {"one" => nil, "two" => "foo"}
     end
 
     it "should not include arguments if none are present" do
       @type.to_pson["arguments"].should be_nil
     end
 
     [:line, :doc, :file, :parent].each do |attr|
       it "should include #{attr} when set" do
         @type.send(attr.to_s + "=", "value")
         double_convert.send(attr).should == "value"
       end
 
       it "should not include #{attr} when not set" do
         @type.to_pson[attr.to_s].should be_nil
       end
     end
 
     it "should not include docs if they are empty" do
       @type.doc = ""
       @type.to_pson["doc"].should be_nil
     end
   end
 
   describe "when a node"  do
     it "should allow a regex as its name" do
       lambda { Puppet::Resource::Type.new(:node, /foo/) }.should_not raise_error
     end
 
     it "should allow an AST::HostName instance as its name" do
       regex = Puppet::Parser::AST::Regex.new(:value => /foo/)
       name = Puppet::Parser::AST::HostName.new(:value => regex)
       lambda { Puppet::Resource::Type.new(:node, name) }.should_not raise_error
     end
 
     it "should match against the regexp in the AST::HostName when a HostName instance is provided" do
       regex = Puppet::Parser::AST::Regex.new(:value => /\w/)
       name = Puppet::Parser::AST::HostName.new(:value => regex)
       node = Puppet::Resource::Type.new(:node, name)
 
       node.match("foo").should be_true
     end
 
     it "should return the value of the hostname if provided a string-form AST::HostName instance as the name" do
       name = Puppet::Parser::AST::HostName.new(:value => "foo")
       node = Puppet::Resource::Type.new(:node, name)
 
       node.name.should == "foo"
     end
 
     describe "and the name is a regex" do
       it "should have a method that indicates that this is the case" do
         Puppet::Resource::Type.new(:node, /w/).should be_name_is_regex
       end
 
       it "should set its namespace to ''" do
         Puppet::Resource::Type.new(:node, /w/).namespace.should == ""
       end
 
       it "should return the regex converted to a string when asked for its name" do
         Puppet::Resource::Type.new(:node, /ww/).name.should == "ww"
       end
 
       it "should downcase the regex when returning the name as a string" do
         Puppet::Resource::Type.new(:node, /W/).name.should == "w"
       end
 
       it "should remove non-alpha characters when returning the name as a string" do
         Puppet::Resource::Type.new(:node, /w*w/).name.should_not include("*")
       end
 
       it "should remove leading dots when returning the name as a string" do
         Puppet::Resource::Type.new(:node, /.ww/).name.should_not =~ /^\./
       end
 
       it "should have a method for matching its regex name against a provided name" do
         Puppet::Resource::Type.new(:node, /.ww/).should respond_to(:match)
       end
 
       it "should return true when its regex matches the provided name" do
         Puppet::Resource::Type.new(:node, /\w/).match("foo").should be_true
       end
 
       it "should return true when its regex matches the provided name" do
         Puppet::Resource::Type.new(:node, /\w/).match("foo").should be_true
       end
 
       it "should return false when its regex does not match the provided name" do
         (!!Puppet::Resource::Type.new(:node, /\d/).match("foo")).should be_false
       end
 
       it "should return true when its name, as a string, is matched against an equal string" do
         Puppet::Resource::Type.new(:node, "foo").match("foo").should be_true
       end
 
       it "should return false when its name is matched against an unequal string" do
         Puppet::Resource::Type.new(:node, "foo").match("bar").should be_false
       end
 
       it "should match names insensitive to case" do
         Puppet::Resource::Type.new(:node, "fOo").match("foO").should be_true
       end
     end
   end
 
   describe "when initializing" do
     it "should require a resource super type" do
       Puppet::Resource::Type.new(:hostclass, "foo").type.should == :hostclass
     end
 
     it "should fail if provided an invalid resource super type" do
       lambda { Puppet::Resource::Type.new(:nope, "foo") }.should raise_error(ArgumentError)
     end
 
     it "should set its name to the downcased, stringified provided name" do
       Puppet::Resource::Type.new(:hostclass, "Foo::Bar".intern).name.should == "foo::bar"
     end
 
     it "should set its namespace to the downcased, stringified qualified name for classes" do
       Puppet::Resource::Type.new(:hostclass, "Foo::Bar::Baz".intern).namespace.should == "foo::bar::baz"
     end
 
     [:definition, :node].each do |type|
       it "should set its namespace to the downcased, stringified qualified portion of the name for #{type}s" do
         Puppet::Resource::Type.new(type, "Foo::Bar::Baz".intern).namespace.should == "foo::bar"
       end
     end
 
     %w{code line file doc}.each do |arg|
       it "should set #{arg} if provided" do
         type = Puppet::Resource::Type.new(:hostclass, "foo", arg.to_sym => "something")
         type.send(arg).should == "something"
       end
     end
 
     it "should set any provided arguments with the keys as symbols" do
       type = Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {:foo => "bar", :baz => "biz"})
       type.should be_valid_parameter("foo")
       type.should be_valid_parameter("baz")
     end
 
     it "should set any provided arguments with they keys as strings" do
       type = Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {"foo" => "bar", "baz" => "biz"})
       type.should be_valid_parameter(:foo)
       type.should be_valid_parameter(:baz)
     end
 
     it "should function if provided no arguments" do
       type = Puppet::Resource::Type.new(:hostclass, "foo")
       type.should_not be_valid_parameter(:foo)
     end
   end
 
   describe "when testing the validity of an attribute" do
     it "should return true if the parameter was typed at initialization" do
       Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {"foo" => "bar"}).should be_valid_parameter("foo")
     end
 
     it "should return true if it is a metaparam" do
       Puppet::Resource::Type.new(:hostclass, "foo").should be_valid_parameter("require")
     end
 
     it "should return true if the parameter is named 'name'" do
       Puppet::Resource::Type.new(:hostclass, "foo").should be_valid_parameter("name")
     end
 
     it "should return false if it is not a metaparam and was not provided at initialization" do
       Puppet::Resource::Type.new(:hostclass, "foo").should_not be_valid_parameter("yayness")
     end
   end
 
   describe "when setting its parameters in the scope" do
     def variable_expression(name)
       varexpr = Puppet::Pops::Model::Factory.QNAME(name).var().current
       Puppet::Parser::AST::PopsBridge::Expression.new(:value => varexpr)
     end
 
     before do
       @scope = Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo")), :source => stub("source"))
       @resource = Puppet::Parser::Resource.new(:foo, "bar", :scope => @scope)
       @type = Puppet::Resource::Type.new(:definition, "foo")
       @resource.environment.known_resource_types.add @type
     end
 
     ['module_name', 'name', 'title'].each do |variable|
       it "should allow #{variable} to be evaluated as param default" do
         @type.instance_eval { @module_name = "bar" }
         @type.set_arguments :foo => variable_expression(variable)
         @type.set_resource_parameters(@resource, @scope)
         @scope['foo'].should == 'bar'
       end
     end
 
     # this test is to clarify a crazy edge case
     # if you specify these special names as params, the resource
     # will override the special variables
     it "should allow the resource to override defaults" do
       @type.set_arguments :name => nil
       @resource[:name] = 'foobar'
       @type.set_arguments :foo => variable_expression('name')
       @type.set_resource_parameters(@resource, @scope)
       @scope['foo'].should == 'foobar'
     end
 
     it "should set each of the resource's parameters as variables in the scope" do
       @type.set_arguments :foo => nil, :boo => nil
       @resource[:foo] = "bar"
       @resource[:boo] = "baz"
 
       @type.set_resource_parameters(@resource, @scope)
 
       @scope['foo'].should == "bar"
       @scope['boo'].should == "baz"
     end
 
     it "should set the variables as strings" do
       @type.set_arguments :foo => nil
       @resource[:foo] = "bar"
 
       @type.set_resource_parameters(@resource, @scope)
 
       @scope['foo'].should == "bar"
     end
 
     it "should fail if any of the resource's parameters are not valid attributes" do
       @type.set_arguments :foo => nil
       @resource[:boo] = "baz"
 
       lambda { @type.set_resource_parameters(@resource, @scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should evaluate and set its default values as variables for parameters not provided by the resource" do
       @type.set_arguments :foo => Puppet::Parser::AST::Leaf.new(:value => "something")
       @type.set_resource_parameters(@resource, @scope)
       @scope['foo'].should == "something"
     end
 
     it "should set all default values as parameters in the resource" do
       @type.set_arguments :foo => Puppet::Parser::AST::Leaf.new(:value => "something")
 
       @type.set_resource_parameters(@resource, @scope)
 
       @resource[:foo].should == "something"
     end
 
     it "should fail if the resource does not provide a value for a required argument" do
       @type.set_arguments :foo => nil
 
       lambda { @type.set_resource_parameters(@resource, @scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should set the resource's title as a variable if not otherwise provided" do
       @type.set_resource_parameters(@resource, @scope)
 
       @scope['title'].should == "bar"
     end
 
     it "should set the resource's name as a variable if not otherwise provided" do
       @type.set_resource_parameters(@resource, @scope)
 
       @scope['name'].should == "bar"
     end
 
     it "should set its module name in the scope if available" do
       @type.instance_eval { @module_name = "mymod" }
 
       @type.set_resource_parameters(@resource, @scope)
 
       @scope["module_name"].should == "mymod"
     end
 
     it "should set its caller module name in the scope if available" do
       @scope.expects(:parent_module_name).returns "mycaller"
 
       @type.set_resource_parameters(@resource, @scope)
 
       @scope["caller_module_name"].should == "mycaller"
     end
   end
 
   describe "when describing and managing parent classes" do
     before do
       environment = Puppet::Node::Environment.create(:testing, [])
       @krt = environment.known_resource_types
       @parent = Puppet::Resource::Type.new(:hostclass, "bar")
       @krt.add @parent
 
       @child = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
       @krt.add @child
 
       @scope = Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo", :environment => environment)))
     end
 
     it "should be able to define a parent" do
       Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
     end
 
     it "should use the code collection to find the parent resource type" do
       @child.parent_type(@scope).should equal(@parent)
     end
 
     it "should be able to find parent nodes" do
       parent = Puppet::Resource::Type.new(:node, "bar")
       @krt.add parent
       child = Puppet::Resource::Type.new(:node, "foo", :parent => "bar")
       @krt.add child
 
       child.parent_type(@scope).should equal(parent)
     end
 
     it "should cache a reference to the parent type" do
       @krt.stubs(:hostclass).with("foo::bar").returns nil
       @krt.expects(:hostclass).with("bar").once.returns @parent
       @child.parent_type(@scope)
       @child.parent_type
     end
 
     it "should correctly state when it is another type's child" do
       @child.parent_type(@scope)
       @child.should be_child_of(@parent)
     end
 
     it "should be considered the child of a parent's parent" do
       @grandchild = Puppet::Resource::Type.new(:hostclass, "baz", :parent => "foo")
       @krt.add @grandchild
 
       @child.parent_type(@scope)
       @grandchild.parent_type(@scope)
 
       @grandchild.should be_child_of(@parent)
     end
 
     it "should correctly state when it is not another type's child" do
       @notchild = Puppet::Resource::Type.new(:hostclass, "baz")
       @krt.add @notchild
 
       @notchild.should_not be_child_of(@parent)
     end
   end
 
   describe "when evaluating its code" do
     before do
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @scope = Puppet::Parser::Scope.new @compiler
       @resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope)
 
       # This is so the internal resource lookup works, yo.
       @compiler.catalog.add_resource @resource
 
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
       @resource.environment.known_resource_types.add @type
     end
 
     it "should add node regex captures to its scope" do
       @type = Puppet::Resource::Type.new(:node, /f(\w)o(.*)$/)
       match = @type.match('foo')
 
       code = stub 'code'
       @type.stubs(:code).returns code
 
       subscope = stub 'subscope', :compiler => @compiler
       @scope.expects(:newscope).with(:source => @type, :namespace => '', :resource => @resource).returns subscope
 
       elevel = 876
       subscope.expects(:ephemeral_level).returns elevel
       subscope.expects(:ephemeral_from).with(match, nil, nil).returns subscope
       code.expects(:safeevaluate).with(subscope)
       subscope.expects(:unset_ephemeral_var).with(elevel)
 
       # Just to keep the stub quiet about intermediate calls
       @type.expects(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
     end
 
     it "should add hostclass names to the classes list" do
       @type.evaluate_code(@resource)
       @compiler.catalog.classes.should be_include("foo")
     end
 
     it "should not add defined resource names to the classes list" do
       @type = Puppet::Resource::Type.new(:definition, "foo")
       @type.evaluate_code(@resource)
       @compiler.catalog.classes.should_not be_include("foo")
     end
 
     it "should set all of its parameters in a subscope" do
       subscope = stub 'subscope', :compiler => @compiler
       @scope.expects(:newscope).with(:source => @type, :namespace => 'foo', :resource => @resource).returns subscope
       @type.expects(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
     end
 
     it "should not create a subscope for the :main class" do
       @resource.stubs(:title).returns(:main)
       @type.expects(:subscope).never
       @type.expects(:set_resource_parameters).with(@resource, @scope)
 
       @type.evaluate_code(@resource)
     end
 
     it "should store the class scope" do
       @type.evaluate_code(@resource)
       @scope.class_scope(@type).should be_instance_of(@scope.class)
     end
 
     it "should still create a scope but not store it if the type is a definition" do
       @type = Puppet::Resource::Type.new(:definition, "foo")
       @type.evaluate_code(@resource)
       @scope.class_scope(@type).should be_nil
     end
 
     it "should evaluate the AST code if any is provided" do
       code = stub 'code'
       @type.stubs(:code).returns code
       subscope = stub_everything("subscope", :compiler => @compiler)
       @scope.stubs(:newscope).returns subscope
       code.expects(:safeevaluate).with subscope
 
       @type.evaluate_code(@resource)
     end
 
     it "should noop if there is no code" do
       @type.expects(:code).returns nil
 
       @type.evaluate_code(@resource)
     end
 
     describe "and it has a parent class" do
       before do
         @parent_type = Puppet::Resource::Type.new(:hostclass, "parent")
         @type.parent = "parent"
         @parent_resource = Puppet::Parser::Resource.new(:class, "parent", :scope => @scope)
 
         @compiler.add_resource @scope, @parent_resource
 
         @type.resource_type_collection = @scope.known_resource_types
         @type.resource_type_collection.add @parent_type
       end
 
       it "should evaluate the parent's resource" do
         @type.parent_type(@scope)
 
         @type.evaluate_code(@resource)
 
         @scope.class_scope(@parent_type).should_not be_nil
       end
 
       it "should not evaluate the parent's resource if it has already been evaluated" do
         @parent_resource.evaluate
 
         @type.parent_type(@scope)
 
         @parent_resource.expects(:evaluate).never
 
         @type.evaluate_code(@resource)
       end
 
       it "should use the parent's scope as its base scope" do
         @type.parent_type(@scope)
 
         @type.evaluate_code(@resource)
 
         @scope.class_scope(@type).parent.object_id.should == @scope.class_scope(@parent_type).object_id
       end
     end
 
     describe "and it has a parent node" do
       before do
         @type = Puppet::Resource::Type.new(:node, "foo")
         @parent_type = Puppet::Resource::Type.new(:node, "parent")
         @type.parent = "parent"
         @parent_resource = Puppet::Parser::Resource.new(:node, "parent", :scope => @scope)
 
         @compiler.add_resource @scope, @parent_resource
 
         @type.resource_type_collection = @scope.known_resource_types
         @type.resource_type_collection.add(@parent_type)
       end
 
       it "should evaluate the parent's resource" do
         @type.parent_type(@scope)
 
         @type.evaluate_code(@resource)
 
         @scope.class_scope(@parent_type).should_not be_nil
       end
 
       it "should not evaluate the parent's resource if it has already been evaluated" do
         @parent_resource.evaluate
 
         @type.parent_type(@scope)
 
         @parent_resource.expects(:evaluate).never
 
         @type.evaluate_code(@resource)
       end
 
       it "should use the parent's scope as its base scope" do
         @type.parent_type(@scope)
 
         @type.evaluate_code(@resource)
 
         @scope.class_scope(@type).parent.object_id.should == @scope.class_scope(@parent_type).object_id
       end
     end
   end
 
   describe "when creating a resource" do
     before do
-      @node = Puppet::Node.new("foo", :environment => 'env')
+      env = Puppet::Node::Environment.create('env', [])
+      @node = Puppet::Node.new("foo", :environment => env)
       @compiler = Puppet::Parser::Compiler.new(@node)
       @scope = Puppet::Parser::Scope.new(@compiler)
 
       @top = Puppet::Resource::Type.new :hostclass, "top"
       @middle = Puppet::Resource::Type.new :hostclass, "middle", :parent => "top"
 
-      @code = Puppet::Resource::TypeCollection.new("env")
+      @code = env.known_resource_types
       @code.add @top
       @code.add @middle
-
-      @node.environment.stubs(:known_resource_types).returns(@code)
     end
 
     it "should create a resource instance" do
       @top.ensure_in_catalog(@scope).should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should set its resource type to 'class' when it is a hostclass" do
       Puppet::Resource::Type.new(:hostclass, "top").ensure_in_catalog(@scope).type.should == "Class"
     end
 
     it "should set its resource type to 'node' when it is a node" do
       Puppet::Resource::Type.new(:node, "top").ensure_in_catalog(@scope).type.should == "Node"
     end
 
     it "should fail when it is a definition" do
       lambda { Puppet::Resource::Type.new(:definition, "top").ensure_in_catalog(@scope) }.should raise_error(ArgumentError)
     end
 
     it "should add the created resource to the scope's catalog" do
       @top.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should add specified parameters to the resource" do
       @top.ensure_in_catalog(@scope, {'one'=>'1', 'two'=>'2'})
       @compiler.catalog.resource(:class, "top")['one'].should == '1'
       @compiler.catalog.resource(:class, "top")['two'].should == '2'
     end
 
     it "should not require params for a param class" do
       @top.ensure_in_catalog(@scope, {})
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should evaluate the parent class if one exists" do
       @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should evaluate the parent class if one exists" do
       @middle.ensure_in_catalog(@scope, {})
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should fail if you try to create duplicate class resources" do
       othertop = Puppet::Parser::Resource.new(:class, 'top',:source => @source, :scope => @scope )
       # add the same class resource to the catalog
       @compiler.catalog.add_resource(othertop)
       lambda { @top.ensure_in_catalog(@scope, {}) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should fail to evaluate if a parent class is defined but cannot be found" do
       othertop = Puppet::Resource::Type.new :hostclass, "something", :parent => "yay"
       @code.add othertop
       lambda { othertop.ensure_in_catalog(@scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should not create a new resource if one already exists" do
       @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
       @compiler.catalog.expects(:add_resource).never
       @top.ensure_in_catalog(@scope)
     end
 
     it "should return the existing resource when not creating a new one" do
       @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
       @compiler.catalog.expects(:add_resource).never
       @top.ensure_in_catalog(@scope).should == "something"
     end
 
     it "should not create a new parent resource if one already exists and it has a parent class" do
       @top.ensure_in_catalog(@scope)
 
       top_resource = @compiler.catalog.resource(:class, "top")
 
       @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should equal(top_resource)
     end
 
     # #795 - tag before evaluation.
     it "should tag the catalog with the resource tags when it is evaluated" do
       @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.should be_tagged("middle")
     end
 
     it "should tag the catalog with the parent class tags when it is evaluated" do
       @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.should be_tagged("top")
     end
   end
 
   describe "when merging code from another instance" do
     def code(str)
       factory = Puppet::Pops::Model::Factory.literal(str)
     end
 
     it "should fail unless it is a class" do
       lambda { Puppet::Resource::Type.new(:node, "bar").merge("foo") }.should raise_error(Puppet::Error)
     end
 
     it "should fail unless the source instance is a class" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
       source = Puppet::Resource::Type.new(:node, "foo")
       lambda { dest.merge(source) }.should raise_error(Puppet::Error)
     end
 
     it "should fail if both classes have different parent classes" do
       code = Puppet::Resource::TypeCollection.new("env")
       {"a" => "b", "c" => "d"}.each do |parent, child|
         code.add Puppet::Resource::Type.new(:hostclass, parent)
         code.add Puppet::Resource::Type.new(:hostclass, child, :parent => parent)
       end
       lambda { code.hostclass("b").merge(code.hostclass("d")) }.should raise_error(Puppet::Error)
     end
 
     it "should fail if it's named 'main' and 'freeze_main' is enabled" do
       Puppet.settings[:freeze_main] = true
       code = Puppet::Resource::TypeCollection.new("env")
       code.add Puppet::Resource::Type.new(:hostclass, "")
       other = Puppet::Resource::Type.new(:hostclass, "")
       lambda { code.hostclass("").merge(other) }.should raise_error(Puppet::Error)
     end
 
     it "should copy the other class's parent if it has not parent" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
 
       parent = Puppet::Resource::Type.new(:hostclass, "parent")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "parent")
       dest.merge(source)
 
       dest.parent.should == "parent"
     end
 
     it "should copy the other class's documentation as its docs if it has no docs" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "yayness")
       dest.merge(source)
 
       dest.doc.should == "yayness"
     end
 
     it "should append the other class's docs to its docs if it has any" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar", :doc => "fooness")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "yayness")
       dest.merge(source)
 
       dest.doc.should == "foonessyayness"
     end
 
     it "should set the other class's code as its code if it has none" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
 
       dest.merge(source)
 
       dest.code.value.should == "bar"
     end
 
     it "should append the other class's code to its code if it has any" do
       # PUP-3274, the code merging at the top still uses AST::BlockExpression
       # But does not do mutating changes to code blocks, instead a new block is created
       # with references to the two original blocks.
       # TODO: fix this when the code merging is changed at the very top in 4x.
       #
       dcode = Puppet::Parser::AST::BlockExpression.new(:children => [code("dest")])
       dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => dcode)
 
       scode = Puppet::Parser::AST::BlockExpression.new(:children => [code("source")])
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
 
       dest.merge(source)
       dest.code.children.collect { |l| l.children[0].value }.should == %w{dest source}
     end
   end
 end
diff --git a/spec/unit/type/file/content_spec.rb b/spec/unit/type/file/content_spec.rb
index bf438d680..d5a06246a 100755
--- a/spec/unit/type/file/content_spec.rb
+++ b/spec/unit/type/file/content_spec.rb
@@ -1,516 +1,521 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http_pool'
 
 require 'puppet/network/resolver'
 
 describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true do
   include PuppetSpec::Files
 
   let(:filename) { tmpfile('testfile') }
-
-  let(:catalog) { Puppet::Resource::Catalog.new }
-
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:catalog) { Puppet::Resource::Catalog.new(:test, environment) }
   let(:resource) { Puppet::Type.type(:file).new :path => filename, :catalog => catalog }
 
   before do
     File.open(filename, 'w') {|f| f.write "initial file content"}
     described_class.stubs(:standalone?).returns(false)
   end
 
+  around do |example|
+    Puppet.override(:environments => Puppet::Environments::Static.new(environment)) do
+      example.run
+    end
+  end
+
   describe "when determining the checksum type" do
     let(:content) { described_class.new(:resource => resource) }
 
     it "should use the type specified in the source checksum if a source is set" do
       resource[:source] = File.expand_path("/foo")
       resource.parameter(:source).expects(:checksum).returns "{md5lite}eh"
 
       content.checksum_type.should == :md5lite
     end
 
     it "should use the type specified by the checksum parameter if no source is set" do
       resource[:checksum] = :md5lite
 
       content.checksum_type.should == :md5lite
     end
 
     with_digest_algorithms do
       it "should use the type specified by digest_algorithm by default" do
         content.checksum_type.should == digest_algorithm.intern
       end
     end
   end
 
   describe "when determining the actual content to write" do
     let(:content) { described_class.new(:resource => resource) }
 
     it "should use the set content if available" do
       content.should = "ehness"
       content.actual_content.should == "ehness"
     end
 
     it "should not use the content from the source if the source is set" do
       source = mock 'source'
 
       resource.expects(:parameter).never.with(:source).returns source
 
       content.actual_content.should be_nil
     end
   end
 
   describe "when setting the desired content" do
     let(:content) { described_class.new(:resource => resource) }
 
     it "should make the actual content available via an attribute" do
       content.stubs(:checksum_type).returns "md5"
       content.should = "this is some content"
 
       content.actual_content.should == "this is some content"
     end
 
     with_digest_algorithms do
       it "should store the checksum as the desired content" do
         d = digest("this is some content")
 
         content.stubs(:checksum_type).returns digest_algorithm
         content.should = "this is some content"
 
         content.should.must == "{#{digest_algorithm}}#{d}"
       end
 
       it "should not checksum 'absent'" do
         content.should = :absent
 
         content.should.must == :absent
       end
 
       it "should accept a checksum as the desired content" do
         d = digest("this is some content")
 
         string = "{#{digest_algorithm}}#{d}"
         content.should = string
 
         content.should.must == string
       end
     end
 
     it "should convert the value to ASCII-8BIT", :if => "".respond_to?(:encode) do
       content.should= "Let's make a \u{2603}"
 
       content.actual_content.should == "Let's make a \xE2\x98\x83".force_encoding(Encoding::ASCII_8BIT)
     end
   end
 
   describe "when retrieving the current content" do
     let(:content) { described_class.new(:resource => resource) }
 
     it "should return :absent if the file does not exist" do
       resource.expects(:stat).returns nil
 
       content.retrieve.should == :absent
     end
 
     it "should not manage content on directories" do
       stat = mock 'stat', :ftype => "directory"
       resource.expects(:stat).returns stat
 
       content.retrieve.should be_nil
     end
 
     it "should not manage content on links" do
       stat = mock 'stat', :ftype => "link"
       resource.expects(:stat).returns stat
 
       content.retrieve.should be_nil
     end
 
     it "should always return the checksum as a string" do
       resource[:checksum] = :mtime
 
       stat = mock 'stat', :ftype => "file"
       resource.expects(:stat).returns stat
 
       time = Time.now
       resource.parameter(:checksum).expects(:mtime_file).with(resource[:path]).returns time
 
       content.retrieve.should == "{mtime}#{time}"
     end
 
     with_digest_algorithms do
       it "should return the checksum of the file if it exists and is a normal file" do
         stat = mock 'stat', :ftype => "file"
         resource.expects(:stat).returns stat
         resource.parameter(:checksum).expects("#{digest_algorithm}_file".intern).with(resource[:path]).returns "mysum"
 
         content.retrieve.should == "{#{digest_algorithm}}mysum"
       end
     end
   end
 
   describe "when testing whether the content is in sync" do
     let(:content) { described_class.new(:resource => resource) }
 
     before do
       resource[:ensure] = :file
     end
 
     it "should return true if the resource shouldn't be a regular file" do
       resource.expects(:should_be_file?).returns false
       content.should = "foo"
       content.must be_safe_insync("whatever")
     end
 
     it "should warn that no content will be synced to links when ensure is :present" do
       resource[:ensure] = :present
       resource[:content] = 'foo'
       resource.stubs(:should_be_file?).returns false
       resource.stubs(:stat).returns mock("stat", :ftype => "link")
 
       resource.expects(:warning).with {|msg| msg =~ /Ensure set to :present but file type is/}
 
       content.insync? :present
     end
 
     it "should return false if the current content is :absent" do
       content.should = "foo"
       content.should_not be_safe_insync(:absent)
     end
 
     it "should return false if the file should be a file but is not present" do
       resource.expects(:should_be_file?).returns true
       content.should = "foo"
 
       content.should_not be_safe_insync(:absent)
     end
 
     describe "and the file exists" do
       with_digest_algorithms do
         before do
           resource.stubs(:stat).returns mock("stat")
           resource[:checksum] = digest_algorithm
           content.should = "some content"
         end
 
         it "should return false if the current contents are different from the desired content" do
           content.should_not be_safe_insync("other content")
         end
 
         it "should return true if the sum for the current contents is the same as the sum for the desired content" do
           content.must be_safe_insync("{#{digest_algorithm}}" + digest("some content"))
         end
 
         [true, false].product([true, false]).each do |cfg, param|
           describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
             before do
               Puppet[:show_diff] = cfg
               resource.stubs(:show_diff?).returns param
               resource[:loglevel] = "debug"
             end
 
             if cfg and param
               it "should display a diff" do
                 content.expects(:diff).returns("my diff").once
                 content.expects(:debug).with("\nmy diff").once
                 content.should_not be_safe_insync("other content")
               end
             else
               it "should not display a diff" do
                 content.expects(:diff).never
                 content.should_not be_safe_insync("other content")
               end
             end
           end
         end
       end
     end
 
     describe "and :replace is false" do
       before do
         resource.stubs(:replace?).returns false
       end
 
       it "should be insync if the file exists and the content is different" do
         resource.stubs(:stat).returns mock('stat')
 
         content.must be_safe_insync("whatever")
       end
 
       it "should be insync if the file exists and the content is right" do
         resource.stubs(:stat).returns mock('stat')
 
         content.must be_safe_insync("something")
       end
 
       it "should not be insync if the file does not exist" do
         content.should = "foo"
         content.should_not be_safe_insync(:absent)
       end
     end
   end
 
  describe "when changing the content" do
     let(:content) { described_class.new(:resource => resource) }
 
     before do
       resource.stubs(:[]).with(:path).returns "/boo"
       resource.stubs(:stat).returns "eh"
     end
 
     it "should use the file's :write method to write the content" do
       resource.expects(:write).with(:content)
 
       content.sync
     end
 
     it "should return :file_changed if the file already existed" do
       resource.expects(:stat).returns "something"
       resource.stubs(:write)
       content.sync.should == :file_changed
     end
 
     it "should return :file_created if the file did not exist" do
       resource.expects(:stat).returns nil
       resource.stubs(:write)
       content.sync.should == :file_created
     end
   end
 
   describe "when writing" do
     let(:content) { described_class.new(:resource => resource) }
 
     let(:fh) { File.open(filename, 'wb') }
 
     it "should attempt to read from the filebucket if no actual content nor source exists" do
       content.should = "{md5}foo"
       content.resource.bucket.class.any_instance.stubs(:getfile).returns "foo"
       content.write(fh)
       fh.close
     end
 
     describe "from actual content" do
       before(:each) do
         content.stubs(:actual_content).returns("this is content")
       end
 
       it "should write to the given file handle" do
         fh = mock 'filehandle'
         fh.expects(:print).with("this is content")
         content.write(fh)
       end
 
       it "should return the current checksum value" do
         resource.parameter(:checksum).expects(:sum_stream).returns "checksum"
         content.write(fh).should == "checksum"
       end
     end
 
     describe "from a file bucket" do
       it "should fail if a file bucket cannot be retrieved" do
         content.should = "{md5}foo"
         content.resource.expects(:bucket).returns nil
         expect { content.write(fh) }.to raise_error(Puppet::Error)
       end
 
       it "should fail if the file bucket cannot find any content" do
         content.should = "{md5}foo"
         bucket = stub 'bucket'
         content.resource.expects(:bucket).returns bucket
         bucket.expects(:getfile).with("foo").raises "foobar"
         expect { content.write(fh) }.to raise_error(Puppet::Error)
       end
 
       it "should write the returned content to the file" do
         content.should = "{md5}foo"
         bucket = stub 'bucket'
         content.resource.expects(:bucket).returns bucket
         bucket.expects(:getfile).with("foo").returns "mycontent"
 
         fh = mock 'filehandle'
         fh.expects(:print).with("mycontent")
         content.write(fh)
       end
     end
 
     describe "from local source" do
       let(:source_content) { "source file content\r\n"*10 }
       before(:each) do
         sourcename = tmpfile('source')
         resource[:backup] = false
         resource[:source] = sourcename
 
         File.open(sourcename, 'wb') {|f| f.write source_content}
 
         # This needs to be invoked to properly initialize the content property,
         # or attempting to write a file will fail.
         resource.newattr(:content)
       end
 
       it "should copy content from the source to the file" do
         source = resource.parameter(:source)
         resource.write(source)
 
         Puppet::FileSystem.binread(filename).should == source_content
       end
 
       with_digest_algorithms do
         it "should return the checksum computed" do
           File.open(filename, 'wb') do |file|
             resource[:checksum] = digest_algorithm
             content.write(file).should == "{#{digest_algorithm}}#{digest(source_content)}"
           end
         end
       end
     end
 
     describe 'from remote source' do
       let(:source_content) { "source file content\n"*10 }
       let(:source) { resource.newattr(:source) }
       let(:response) { stub_everything('response') }
       let(:conn) { mock('connection') }
 
       before(:each) do
         resource[:backup] = false
         # This needs to be invoked to properly initialize the content property,
         # or attempting to write a file will fail.
         resource.newattr(:content)
 
         response.stubs(:read_body).multiple_yields(*source_content.lines)
         conn.stubs(:request_get).yields(response)
       end
 
       it 'should use an explicit fileserver if source starts with puppet://' do
         response.stubs(:code).returns('200')
         source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet://somehostname/test/foo', :ftype => 'file')
         Puppet::Network::HttpPool.expects(:http_instance).with('somehostname', anything).returns(conn)
 
         resource.write(source)
       end
 
       it 'should use the default fileserver if source starts with puppet:///' do
         response.stubs(:code).returns('200')
         source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo', :ftype => 'file')
         Puppet::Network::HttpPool.expects(:http_instance).with(Puppet.settings[:server], anything).returns(conn)
 
         resource.write(source)
       end
 
       it 'should percent encode reserved characters' do
         response.stubs(:code).returns('200')
         Puppet::Network::HttpPool.stubs(:http_instance).returns(conn)
         source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo bar', :ftype => 'file')
 
         conn.unstub(:request_get)
-        conn.expects(:request_get).with('/none/file_content/test/foo%20bar', anything).yields(response)
+        conn.expects(:request_get).with('/testing/file_content/test/foo%20bar', anything).yields(response)
 
         resource.write(source)
       end
 
       describe 'when handling file_content responses' do
         before(:each) do
           Puppet::Network::HttpPool.stubs(:http_instance).returns(conn)
           source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo', :ftype => 'file')
         end
 
         it 'should not write anything if source is not found' do
           response.stubs(:code).returns('404')
 
           expect { resource.write(source) }.to raise_error(Net::HTTPError, /404/)
           expect(File.read(filename)).to eq('initial file content')
         end
 
         it 'should raise an HTTP error in case of server error' do
           response.stubs(:code).returns('500')
 
           expect { resource.write(source) }.to raise_error(Net::HTTPError, /500/)
         end
 
         context 'and the request was successful' do
           before(:each) { response.stubs(:code).returns '200' }
 
           it 'should write the contents to the file' do
             resource.write(source)
             expect(Puppet::FileSystem.binread(filename)).to eq(source_content)
           end
 
           with_digest_algorithms do
             it 'should return the checksum computed' do
               File.open(filename, 'w') do |file|
                 resource[:checksum] = digest_algorithm
                 expect(content.write(file)).to eq("{#{digest_algorithm}}#{digest(source_content)}")
               end
             end
           end
 
         end
 
       end
     end
 
     # These are testing the implementation rather than the desired behaviour; while that bites, there are a whole
     # pile of other methods in the File type that depend on intimate details of this implementation and vice-versa.
     # If these blow up, you are gonna have to review the callers to make sure they don't explode! --daniel 2011-02-01
     describe "each_chunk_from should work" do
 
       it "when content is a string" do
         content.each_chunk_from('i_am_a_string') { |chunk| chunk.should == 'i_am_a_string' }
       end
 
       # The following manifest is a case where source and content.should are both set
       # file { "/tmp/mydir" :
       #   source  => '/tmp/sourcedir',
       #   recurse => true,
       # }
       it "when content checksum comes from source" do
         source_param = Puppet::Type.type(:file).attrclass(:source)
         source = source_param.new(:resource => resource)
         content.should = "{md5}123abcd"
 
         content.expects(:chunk_file_from_source).returns('from_source')
         content.each_chunk_from(source) { |chunk| chunk.should == 'from_source' }
       end
 
       it "when no content, source, but ensure present" do
         resource[:ensure] = :present
         content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       # you might do this if you were just auditing
       it "when no content, source, but ensure file" do
         resource[:ensure] = :file
         content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       it "when source_or_content is nil and content not a checksum" do
         content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
       # the content is munged so that if it's a checksum nil gets passed in
       it "when content is a checksum it should try to read from filebucket" do
         content.should = "{md5}123abcd"
         content.expects(:read_file_from_filebucket).once.returns('im_a_filebucket')
         content.each_chunk_from(nil) { |chunk| chunk.should == 'im_a_filebucket' }
       end
 
       it "when running as puppet apply" do
         Puppet[:default_file_terminus] = "file_server"
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:content).once.returns :whoo
         content.each_chunk_from(source_or_content) { |chunk| chunk.should == :whoo }
       end
 
       it "when running from source with a local file" do
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:local?).returns true
         content.expects(:chunk_file_from_disk).with(source_or_content).once.yields 'woot'
         content.each_chunk_from(source_or_content) { |chunk| chunk.should == 'woot' }
       end
 
       it "when running from source with a remote file" do
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:local?).returns false
         content.expects(:chunk_file_from_source).with(source_or_content).once.yields 'woot'
         content.each_chunk_from(source_or_content) { |chunk| chunk.should == 'woot' }
       end
     end
   end
 end