diff --git a/lib/puppet/indirector/request.rb b/lib/puppet/indirector/request.rb
index 7fe029597..450b43bd2 100644
--- a/lib/puppet/indirector/request.rb
+++ b/lib/puppet/indirector/request.rb
@@ -1,140 +1,155 @@
 require 'uri'
 require 'puppet/indirector'
 
 # This class encapsulates all of the information you need to make an
 # Indirection call, and as a a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
-    attr_accessor :indirection_name, :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
+    attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
 
     attr_accessor :server, :port, :uri, :protocol
 
+    attr_reader :environment, :indirection_name
+
     # Is this an authenticated request?
     def authenticated?
         # Double negative, so we just get true or false
         ! ! authenticated
     end
 
+    def environment=(env)
+        @environment = if env.is_a?(Puppet::Node::Environment)
+            env
+        else
+            Puppet::Node::Environment.new(env)
+        end
+    end
+
     def escaped_key
         URI.escape(key)
     end
 
+    def indirection_name=(name)
+        @indirection_name = name.to_sym
+    end
+
     # LAK:NOTE This is a messy interface to the cache, and it's only
     # used by the Configurer class.  I decided it was better to implement
     # it now and refactor later, when we have a better design, than
     # to spend another month coming up with a design now that might
     # not be any better.
     def ignore_cache?
         ignore_cache
     end
 
     def ignore_terminus?
         ignore_terminus
     end
 
     def initialize(indirection_name, method, key, options = {})
         options ||= {}
         raise ArgumentError, "Request options must be a hash, not %s" % options.class unless options.is_a?(Hash)
 
-        @indirection_name, @method = indirection_name, method
+        self.indirection_name = indirection_name
+        self.method = method
 
         @options = options.inject({}) do |result, ary|
             param, value = ary
             if respond_to?(param.to_s + "=")
                 send(param.to_s + "=", value)
             else
                 result[param] = value
             end
             result
         end
 
         if key.is_a?(String) or key.is_a?(Symbol)
             # If the request key is a URI, then we need to treat it specially,
             # because it rewrites the key.  We could otherwise strip server/port/etc
             # info out in the REST class, but it seemed bad design for the REST
             # class to rewrite the key.
             if key.to_s =~ /^\w+:\/\// # it's a URI
                 set_uri_key(key)
             else
                 @key = key
             end
         else
             @instance = key
             @key = @instance.name
         end
     end
 
     # Look up the indirection based on the name provided.
     def indirection
         Puppet::Indirector::Indirection.instance(indirection_name)
     end
 
     # Should we allow use of the cached object?
     def use_cache?
         if defined?(@use_cache)
             ! ! use_cache
         else
             true
         end
     end
 
     # Are we trying to interact with multiple resources, or just one?
     def plural?
         method == :search
     end
 
     # Create the query string, if options are present.
     def query_string
         return "" unless options and ! options.empty?
         "?" + options.collect do |key, value|
             case value
             when nil; next
             when true, false; value = value.to_s
             when Fixnum, Bignum, Float; value = value # nothing
             when String; value = URI.escape(value)
             when Symbol; value = URI.escape(value.to_s)
             when Array; value = URI.escape(YAML.dump(value))
             else
                 raise ArgumentError, "HTTP REST queries cannot handle values of type '%s'" % value.class
             end
 
             "%s=%s" % [key, value]
         end.join("&")
     end
 
     def to_s
         return uri if uri
         return "/%s/%s" % [indirection_name, key]
     end
 
     private
 
     # Parse the key as a URI, setting attributes appropriately.
     def set_uri_key(key)
         @uri = key
         begin
             uri = URI.parse(URI.escape(key))
         rescue => detail
             raise ArgumentError, "Could not understand URL %s: %s" % [source, detail.to_s]
         end
 
         # Just short-circuit these to full paths
         if uri.scheme == "file"
             @key = URI.unescape(uri.path)
             return
         end
 
         @server = uri.host if uri.host
 
         # If the URI class can look up the scheme, it will provide a port,
         # otherwise it will default to '0'.
         if uri.port.to_i == 0 and uri.scheme == "puppet"
             @port = Puppet.settings[:masterport].to_i
         else
             @port = uri.port.to_i
         end
 
         @protocol = uri.scheme
         @key = URI.unescape(uri.path.sub(/^\//, ''))
     end
 end
diff --git a/lib/puppet/indirector/rest.rb b/lib/puppet/indirector/rest.rb
index e5efb3aa3..6429b22b7 100644
--- a/lib/puppet/indirector/rest.rb
+++ b/lib/puppet/indirector/rest.rb
@@ -1,89 +1,95 @@
 require 'net/http'
 require 'uri'
 
 require 'puppet/network/http_pool'
 
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
 
     class << self
         attr_reader :server_setting, :port_setting
     end
 
     # Specify the setting that we should use to get the server name.
     def self.use_server_setting(setting)
         @server_setting = setting
     end
 
     def self.server
         return Puppet.settings[server_setting || :server]
     end
 
     # Specify the setting that we should use to get the port.
     def self.use_port_setting(setting)
         @port_setting = setting
     end
 
     def self.port
         return Puppet.settings[port_setting || :masterport].to_i
     end
 
     # Figure out the content type, turn that into a format, and use the format
     # to extract the body of the response.
     def deserialize(response, multiple = false)
         case response.code
         when "404"
             return nil
         when /^2/
             unless response['content-type']
                 raise "No content type in http response; cannot parse"
             end
 
             # Convert the response to a deserialized object.
             if multiple
                 model.convert_from_multiple(response['content-type'], response.body)
             else
                 model.convert_from(response['content-type'], response.body)
             end
         else
             # Raise the http error if we didn't get a 'success' of some kind.
             message = "Server returned %s: %s" % [response.code, response.message]
             raise Net::HTTPError.new(message, response)
         end
     end
 
     # Provide appropriate headers.
     def headers
         {"Accept" => model.supported_formats.join(", ")}
     end
   
     def network(request)
         Puppet::Network::HttpPool.http_instance(request.server || self.class.server, request.port || self.class.port)
     end
 
     def find(request)
-        deserialize network(request).get("/#{indirection.name}/#{request.escaped_key}#{request.query_string}", headers)
+        deserialize network(request).get("/#{environment}/#{indirection.name}/#{request.escaped_key}#{request.query_string}", headers)
     end
     
     def search(request)
         if request.key
-            path = "/#{indirection.name}s/#{request.escaped_key}#{request.query_string}"
+            path = "/#{environment}/#{indirection.name}s/#{request.escaped_key}#{request.query_string}"
         else
-            path = "/#{indirection.name}s#{request.query_string}"
+            path = "/#{environment}/#{indirection.name}s#{request.query_string}"
         end
         unless result = deserialize(network(request).get(path, headers), true)
             return []
         end
         return result
     end
     
     def destroy(request)
         raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
-        deserialize network(request).delete("/#{indirection.name}/#{request.escaped_key}", headers)
+        deserialize network(request).delete("/#{environment}/#{indirection.name}/#{request.escaped_key}", headers)
     end
     
     def save(request)
         raise ArgumentError, "PUT does not accept options" unless request.options.empty?
-        deserialize network(request).put("/#{indirection.name}/", request.instance.render, headers)
+        deserialize network(request).put("/#{environment}/#{indirection.name}/", request.instance.render, headers)
+    end
+
+    private
+
+    def environment
+        Puppet::Node::Environment.new
     end
 end
diff --git a/spec/unit/indirector/request.rb b/spec/unit/indirector/request.rb
index 98ecf2fd3..e2edc2641 100755
--- a/spec/unit/indirector/request.rb
+++ b/spec/unit/indirector/request.rb
@@ -1,254 +1,271 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/indirector/request'
 
 describe Puppet::Indirector::Request do
     describe "when initializing" do
         it "should require an indirection name, a key, and a method" do
             lambda { Puppet::Indirector::Request.new }.should raise_error(ArgumentError)
         end
 
+        it "should always convert the indirection name to a symbol" do
+            Puppet::Indirector::Request.new("ind", :method, "mykey").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").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).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, instance)
             request.key.should == "mykey"
             request.instance.should equal(instance)
         end
 
         it "should support options specified as a hash" do
             lambda { Puppet::Indirector::Request.new(:ind, :method, :key, :one => :two) }.should_not raise_error(ArgumentError)
         end
 
         it "should support nil options" do
             lambda { Puppet::Indirector::Request.new(:ind, :method, :key, nil) }.should_not raise_error(ArgumentError)
         end
 
         it "should support unspecified options" do
             lambda { Puppet::Indirector::Request.new(:ind, :method, :key) }.should_not raise_error(ArgumentError)
         end
 
         it "should fail if options are specified as anything other than nil or a hash" do
             lambda { Puppet::Indirector::Request.new(:ind, :method, :key, [:one, :two]) }.should raise_error(ArgumentError)
         end
 
         it "should use an empty options hash if nil was provided" do
             Puppet::Indirector::Request.new(:ind, :method, :key, 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, :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, :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, :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, :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, :foo => "bar").options.should be_instance_of(Hash)
         end
 
         describe "and the request key is a URI" do
             describe "and the URI is a 'file' URI" do
                 before do
                     @request = Puppet::Indirector::Request.new(:ind, :method, "file:///my/file with spaces")
                 end
 
                 it "should set the request key to the unescaped full file path" do
                     @request.key.should == "/my/file with spaces"
                 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").protocol.should == "http"
             end
 
             it "should set the server if a server is provided" do
                 Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff").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").port.should == 543
             end
 
             it "should default to the masterport if the URI scheme is 'puppet'" do
                 Puppet.settings.expects(:value).with(:masterport).returns "321"
                 Puppet::Indirector::Request.new(:ind, :method, "puppet://host/stuff").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").port.should == 80
             end
 
             it "should set the request key to the unescaped unqualified path from the URI" do
                 Puppet::Indirector::Request.new(:ind, :method, "http:///stuff with spaces").key.should == "stuff with spaces"
             end
 
             it "should set the :uri attribute to the full URI" do
                 Puppet::Indirector::Request.new(:ind, :method, "http:///stuff").uri.should == "http:///stuff"
             end
         end
 
         it "should allow indication that it should not read a cached instance" do
             Puppet::Indirector::Request.new(:ind, :method, :key, :ignore_cache => true).should be_ignore_cache
         end
 
         it "should default to not ignoring the cache" do
             Puppet::Indirector::Request.new(:ind, :method, :key).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, :ignore_terminus => true).should be_ignore_terminus
         end
 
         it "should default to not ignoring the terminus" do
             Puppet::Indirector::Request.new(:ind, :method, :key).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)
 
         request.indirection.should equal(ind)
     end
 
     it "should have a method for determining if the request is plural or singular" do
         Puppet::Indirector::Request.new(:myind, :method, :key).should respond_to(:plural?)
     end
 
     it "should be considered plural if the method is 'search'" do
         Puppet::Indirector::Request.new(:myind, :search, :key).should be_plural
     end
 
     it "should not be considered plural if the method is not 'search'" do
         Puppet::Indirector::Request.new(:myind, :find, :key).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").to_s.should == "foo://bar/baz"
     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") == "/myind/key"
     end
 
     it "should be able to return the URI-escaped key" do
         Puppet::Indirector::Request.new(:myind, :find, "my key").escaped_key.should == URI.escape("my key")
     end
 
+    it "should have an environment accessor" do
+        Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").should respond_to(:environment)
+    end
+
+    it "should set its environment to an environment instance when a string is specified as its environment" do
+        Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => "foo").environment.should == Puppet::Node::Environment.new("foo")
+    end
+
+    it "should use any passed in environment instances as its environment" do
+        env = Puppet::Node::Environment.new("foo")
+        Puppet::Indirector::Request.new(:myind, :find, "my key", :environment => env).environment.should equal(env)
+    end
+
     describe "when building a query string from its options" do
         before do
             @request = Puppet::Indirector::Request.new(:myind, :find, "my key")
         end
 
         it "should return an empty query string if there are no options" do
             @request.stubs(:options).returns nil
             @request.query_string.should == ""
         end
 
         it "should return an empty query string if the options are empty" do
             @request.stubs(:options).returns({})
             @request.query_string.should == ""
         end
 
         it "should prefix the query string with '?'" do
             @request.stubs(:options).returns(:one => "two")
             @request.query_string.should =~ /^\?/
         end
 
         it "should include all options in the query string, separated by '&'" do
             @request.stubs(:options).returns(:one => "two", :three => "four")
             @request.query_string.sub(/^\?/, '').split("&").sort.should == %w{one=two three=four}.sort
         end
 
         it "should ignore nil options" do
             @request.stubs(:options).returns(:one => "two", :three => nil)
             @request.query_string.should_not be_include("three")
         end
 
         it "should convert 'true' option values into strings" do
             @request.stubs(:options).returns(:one => true)
             @request.query_string.should == "?one=true"
         end
 
         it "should convert 'false' option values into strings" do
             @request.stubs(:options).returns(:one => false)
             @request.query_string.should == "?one=false"
         end
 
         it "should convert to a string all option values that are integers" do
             @request.stubs(:options).returns(:one => 50)
             @request.query_string.should == "?one=50"
         end
 
         it "should convert to a string all option values that are floating point numbers" do
             @request.stubs(:options).returns(:one => 1.2)
             @request.query_string.should == "?one=1.2"
         end
 
         it "should URI-escape all option values that are strings" do
             escaping = URI.escape("one two")
             @request.stubs(:options).returns(:one => "one two")
             @request.query_string.should == "?one=#{escaping}"
         end
 
         it "should YAML-dump and URI-escape arrays" do
             escaping = URI.escape(YAML.dump(%w{one two}))
             @request.stubs(:options).returns(:one => %w{one two})
             @request.query_string.should == "?one=#{escaping}"
         end
 
         it "should convert to a string and URI-escape all option values that are symbols" do
             escaping = URI.escape("sym bol")
             @request.stubs(:options).returns(:one => :"sym bol")
             @request.query_string.should == "?one=#{escaping}"
         end
 
         it "should fail if options other than booleans or strings are provided" do
             @request.stubs(:options).returns(:one => {:one => :two})
             lambda { @request.query_string }.should raise_error(ArgumentError)
         end
     end
 end
diff --git a/spec/unit/indirector/rest.rb b/spec/unit/indirector/rest.rb
index 25b3bfcb2..361412a54 100755
--- a/spec/unit/indirector/rest.rb
+++ b/spec/unit/indirector/rest.rb
@@ -1,383 +1,384 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/indirector/rest'
 
 describe "a REST http call", :shared => true do
     it "should accept a path" do
         lambda { @search.send(@method, *@arguments) }.should_not raise_error(ArgumentError)
     end
 
     it "should require a path" do
         lambda { @searcher.send(@method) }.should raise_error(ArgumentError)
     end
 
     it "should return the results of deserializing the response to the request" do
         conn = mock 'connection'
         conn.stubs(:put).returns @response
         conn.stubs(:delete).returns @response
         conn.stubs(:get).returns @response
         Puppet::Network::HttpPool.stubs(:http_instance).returns conn
 
         @searcher.expects(:deserialize).with(@response).returns "myobject"
 
         @searcher.send(@method, *@arguments).should == 'myobject'
     end        
 end
 
 describe Puppet::Indirector::REST do
     before do
         Puppet::Indirector::Terminus.stubs(:register_terminus_class)
         @model = stub('model', :supported_formats => %w{}, :convert_from => nil)
         @instance = stub('model instance')
         @indirection = stub('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
         Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
 
         @rest_class = Class.new(Puppet::Indirector::REST) do
             def self.to_s
                 "This::Is::A::Test::Class"
             end
         end
 
         @response = stub('mock response', :body => 'result', :code => "200")
         @response.stubs(:[]).with('content-type').returns "text/plain"
 
         @searcher = @rest_class.new
     end
 
     it "should have a method for specifying what setting a subclass should use to retrieve its server" do
         @rest_class.should respond_to(:use_server_setting)
     end
 
     it "should use any specified setting to pick the server" do
         @rest_class.expects(:server_setting).returns :servset
         Puppet.settings.expects(:value).with(:servset).returns "myserver"
         @rest_class.server.should == "myserver"
     end
 
     it "should default to :server for the server setting" do
         @rest_class.expects(:server_setting).returns nil
         Puppet.settings.expects(:value).with(:server).returns "myserver"
         @rest_class.server.should == "myserver"
     end
 
     it "should have a method for specifying what setting a subclass should use to retrieve its port" do
         @rest_class.should respond_to(:use_port_setting)
     end
 
     it "should use any specified setting to pick the port" do
         @rest_class.expects(:port_setting).returns :servset
         Puppet.settings.expects(:value).with(:servset).returns "321"
         @rest_class.port.should == 321
     end
 
     it "should default to :port for the port setting" do
         @rest_class.expects(:port_setting).returns nil
         Puppet.settings.expects(:value).with(:masterport).returns "543"
         @rest_class.port.should == 543
     end
 
     describe "when deserializing responses" do
         it "should return nil if the response code is 404" do
             response = mock 'response'
             response.expects(:code).returns "404"
 
             @searcher.deserialize(response).should be_nil
         end
 
         it "should fail if the response code is not in the 200s" do
             @model.expects(:convert_from).never
 
             response = mock 'response'
             response.stubs(:code).returns "300"
             response.stubs(:message).returns "There was a problem"
 
             lambda { @searcher.deserialize(response) }.should raise_error(Net::HTTPError)
         end
 
         it "should return the results of converting from the format specified by the content-type header if the response code is in the 200s" do
             @model.expects(:convert_from).with("myformat", "mydata").returns "myobject"
 
             response = mock 'response'
             response.stubs(:[]).with("content-type").returns "myformat"
             response.stubs(:body).returns "mydata"
             response.stubs(:code).returns "200"
 
             @searcher.deserialize(response).should == "myobject"
         end
 
         it "should convert and return multiple instances if the return code is in the 200s and 'multiple' is specified" do
             @model.expects(:convert_from_multiple).with("myformat", "mydata").returns "myobjects"
 
             response = mock 'response'
             response.stubs(:[]).with("content-type").returns "myformat"
             response.stubs(:body).returns "mydata"
             response.stubs(:code).returns "200"
 
             @searcher.deserialize(response, true).should == "myobjects"
         end
     end
 
     describe "when creating an HTTP client" do
         before do
             Puppet.settings.stubs(:value).returns("rest_testing")
         end
 
         it "should use the class's server and port if the indirection request provides neither" do
             @request = stub 'request', :key => "foo", :server => nil, :port => nil
             @searcher.class.expects(:port).returns 321
             @searcher.class.expects(:server).returns "myserver"
             Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
             @searcher.network(@request).should == "myconn"
         end
 
         it "should use the server from the indirection request if one is present" do
             @request = stub 'request', :key => "foo", :server => "myserver", :port => nil
             @searcher.class.stubs(:port).returns 321
             Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
             @searcher.network(@request).should == "myconn"
         end
 
         it "should use the port from the indirection request if one is present" do
             @request = stub 'request', :key => "foo", :server => nil, :port => 321
             @searcher.class.stubs(:server).returns "myserver"
             Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
             @searcher.network(@request).should == "myconn"
         end
     end
 
     describe "when doing a find" do
         before :each do
             @connection = stub('mock http connection', :get => @response)
             @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
             # Use a key with spaces, so we can test escaping
             @request = stub 'request', :escaped_key => 'foo', :query_string => ""
         end
 
         it "should call the GET http method on a network connection" do
             @searcher.expects(:network).returns @connection
             @connection.expects(:get).returns @response
             @searcher.find(@request)
         end
 
         it "should deserialize and return the http response" do
             @connection.expects(:get).returns @response
             @searcher.expects(:deserialize).with(@response).returns "myobject"
 
             @searcher.find(@request).should == 'myobject'
         end        
 
-        it "should use the indirection name and escaped request key to create the path" do
-            should_path = "/%s/%s" % [@indirection.name.to_s, "foo"]
+        it "should use the environment, indirection name, and escaped request key to create the path" do
+            should_path = "/%s/%s/%s" % [Puppet::Node::Environment.new, @indirection.name.to_s, "foo"]
             @connection.expects(:get).with { |path, args| path == should_path }.returns(@response)
             @searcher.find(@request)
         end
 
         it "should include the query string" do
             @request.expects(:query_string).with().returns "?my_string"
             @connection.expects(:get).with { |path, args| path.include?("?my_string") }.returns(@response)
             @searcher.find(@request)
         end
 
         it "should provide an Accept header containing the list of supported formats joined with commas" do
             @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
             @searcher.model.expects(:supported_formats).returns %w{supported formats}
             @searcher.find(@request)
         end
 
         it "should deserialize and return the network response" do
             @searcher.expects(:deserialize).with(@response).returns @instance
             @searcher.find(@request).should equal(@instance)
         end
 
         it "should generate an error when result data deserializes fails" do
             @searcher.expects(:deserialize).raises(ArgumentError)
             lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
         end
     end
 
     describe "when doing a search" do
         before :each do
             @connection = stub('mock http connection', :get => @response)
             @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
             @model.stubs(:convert_from_multiple)
 
             @request = stub 'request', :escaped_key => 'foo', :query_string => "", :key => "bar"
         end
 
         it "should call the GET http method on a network connection" do
             @searcher.expects(:network).returns @connection
             @connection.expects(:get).returns @response
             @searcher.search(@request)
         end
 
         it "should deserialize as multiple instances and return the http response" do
             @connection.expects(:get).returns @response
             @searcher.expects(:deserialize).with(@response, true).returns "myobject"
 
             @searcher.search(@request).should == 'myobject'
         end        
 
-        it "should use the plural indirection name as the path if there is no request key" do
-            should_path = "/%ss" % [@indirection.name.to_s]
+        it "should use the environment and the plural indirection name as the path if there is no request key" do
+            should_path = "/%s/%ss" % [Puppet::Node::Environment.new, @indirection.name.to_s]
             @request.stubs(:key).returns nil
             @connection.expects(:get).with { |path, args| path == should_path }.returns(@response)
             @searcher.search(@request)
         end
 
-        it "should use the plural indirection name and escaped request key to create the path if the request key is set" do
-            should_path = "/%ss/%s" % [@indirection.name.to_s, "foo"]
+        it "should use the envrironment, the plural indirection name, and the escaped request key to create the path if the request key is set" do
+            should_path = "/%s/%ss/%s" % [Puppet::Node::Environment.new, @indirection.name.to_s, "foo"]
             @connection.expects(:get).with { |path, args| path == should_path }.returns(@response)
             @searcher.search(@request)
         end
 
         it "should include the query string" do
             @request.expects(:query_string).with().returns "?my_string"
             @connection.expects(:get).with { |path, args| path.include?("?my_string") }.returns(@response)
             @searcher.search(@request)
         end
 
         it "should provide an Accept header containing the list of supported formats joined with commas" do
             @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
             @searcher.model.expects(:supported_formats).returns %w{supported formats}
             @searcher.search(@request)
         end
 
         it "should return an empty array if serialization returns nil" do
             @model.stubs(:convert_from_multiple).returns nil
 
             @searcher.search(@request).should == []
         end
 
         it "should generate an error when result data deserializes fails" do
             @searcher.expects(:deserialize).raises(ArgumentError)
             lambda { @searcher.search(@request) }.should raise_error(ArgumentError)
         end
     end        
 
     describe "when doing a destroy" do
         before :each do
             @connection = stub('mock http connection', :delete => @response)
             @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
             @request = stub 'request', :escaped_key => 'foo', :query_string => "", :options => {}
         end
 
         it "should call the DELETE http method on a network connection" do
             @searcher.expects(:network).returns @connection
             @connection.expects(:delete).returns @response
             @searcher.destroy(@request)
         end
 
         it "should fail if any options are provided, since DELETE apparently does not support query options" do
             @request.stubs(:options).returns(:one => "two", :three => "four")
 
             lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
         end
 
         it "should deserialize and return the http response" do
             @connection.expects(:delete).returns @response
             @searcher.expects(:deserialize).with(@response).returns "myobject"
 
             @searcher.destroy(@request).should == 'myobject'
         end        
 
-        it "should use the indirection name and escaped request key to create the path" do
-            should_path = "/%s/%s" % [@indirection.name.to_s, "foo"]
+        it "should use the environment, the indirection name, and the escaped request key to create the path" do
+            should_path = "/%s/%s/%s" % [Puppet::Node::Environment.new, @indirection.name.to_s, "foo"]
             @connection.expects(:delete).with { |path, args| path == should_path }.returns(@response)
             @searcher.destroy(@request)
         end
 
         it "should not include the query string" do
             @request.expects(:query_string).never
             @connection.stubs(:delete).returns @response
             @searcher.destroy(@request)
         end
 
         it "should provide an Accept header containing the list of supported formats joined with commas" do
             @connection.expects(:delete).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
 
             @searcher.model.expects(:supported_formats).returns %w{supported formats}
             @searcher.destroy(@request)
         end
 
         it "should deserialize and return the network response" do
             @searcher.expects(:deserialize).with(@response).returns @instance
             @searcher.destroy(@request).should equal(@instance)
         end
 
         it "should generate an error when result data deserializes fails" do
             @searcher.expects(:deserialize).raises(ArgumentError)
             lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
         end
     end
 
     describe "when doing a save" do
         before :each do
             @connection = stub('mock http connection', :put => @response)
             @searcher.stubs(:network).returns(@connection)    # neuter the network connection
 
             @instance = stub 'instance', :render => "mydata"
             @request = stub 'request', :instance => @instance, :query_string => "", :options => {}
         end
 
         it "should call the PUT http method on a network connection" do
             @searcher.expects(:network).returns @connection
             @connection.expects(:put).returns @response
             @searcher.save(@request)
         end
 
         it "should fail if any options are provided, since DELETE apparently does not support query options" do
             @request.stubs(:options).returns(:one => "two", :three => "four")
 
             lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
         end
 
-        it "should use the indirection name as the path for the request" do
-            @connection.expects(:put).with { |path, data, args| path == "/#{@indirection.name.to_s}/" }.returns @response
+        it "should use the environment and the indirection name as the path for the request" do
+            path = "/%s/%s/" % [Puppet::Node::Environment.new, @indirection.name]
+            @connection.expects(:put).with { |path, data, args| path == path }.returns @response
 
             @searcher.save(@request)
         end
 
         it "should not include the query string" do
             @request.expects(:query_string).never
             @connection.stubs(:put).returns @response
             @searcher.save(@request)
         end
 
         it "should serialize the instance using the default format and pass the result as the body of the request" do
             @instance.expects(:render).returns "serial_instance"
             @connection.expects(:put).with { |path, data, args| data == "serial_instance" }.returns @response
 
             @searcher.save(@request)
         end
 
         it "should deserialize and return the http response" do
             @connection.expects(:put).returns @response
             @searcher.expects(:deserialize).with(@response).returns "myobject"
 
             @searcher.save(@request).should == 'myobject'
         end        
 
         it "should provide an Accept header containing the list of supported formats joined with commas" do
             @connection.expects(:put).with { |path, data, args| args["Accept"] == "supported, formats" }.returns(@response)
 
             @searcher.model.expects(:supported_formats).returns %w{supported formats}
             @searcher.save(@request)
         end
 
         it "should deserialize and return the network response" do
             @searcher.expects(:deserialize).with(@response).returns @instance
             @searcher.save(@request).should equal(@instance)
         end
 
         it "should generate an error when result data deserializes fails" do
             @searcher.expects(:deserialize).raises(ArgumentError)
             lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
         end
     end
 end