diff --git a/lib/puppet/node/environment.rb b/lib/puppet/node/environment.rb
index 70417449e..d1a126aaa 100644
--- a/lib/puppet/node/environment.rb
+++ b/lib/puppet/node/environment.rb
@@ -1,118 +1,119 @@
 require 'puppet/util/cacher'
 
 # Just define it, so this class has fewer load dependencies.
 class Puppet::Node
 end
 
 # Model the environment that a node can operate in.  This class just
 # provides a simple wrapper for the functionality around environments.
 class Puppet::Node::Environment
     module Helper
         def environment
             Puppet::Node::Environment.new(@environment)
         end
 
         def environment=(env)
             if env.is_a?(String) or env.is_a?(Symbol)
                 @environment = env
             else
                 @environment = env.name
             end
         end
     end
 
     include Puppet::Util::Cacher
 
     @seen = {}
 
     # Return an existing environment instance, or create a new one.
     def self.new(name = nil)
+        return name if name.is_a?(self)
         name ||= Puppet.settings.value(:environment)
 
         raise ArgumentError, "Environment name must be specified" unless name
 
         symbol = name.to_sym
 
         return @seen[symbol] if @seen[symbol]
 
         obj = self.allocate
         obj.send :initialize, symbol
         @seen[symbol] = obj
     end
 
     # This is only used for testing.
     def self.clear
         @seen.clear
     end
 
     attr_reader :name
 
     # Return an environment-specific setting.
     def [](param)
         Puppet.settings.value(param, self.name)
     end
 
     def initialize(name)
         @name = name
     end
 
     def known_resource_types
         if @known_resource_types.nil? or @known_resource_types.stale?
             @known_resource_types = Puppet::Resource::TypeCollection.new(self)
             @known_resource_types.perform_initial_import
         end
         @known_resource_types
     end
 
     def module(name)
         mod = Puppet::Module.new(name, self)
         return nil unless mod.exist?
         return mod
     end
 
     # Cache the modulepath, so that we aren't searching through
     # all known directories all the time.
     cached_attr(:modulepath, :ttl => Puppet[:filetimeout]) do
         dirs = self[:modulepath].split(File::PATH_SEPARATOR)
         if ENV["PUPPETLIB"]
             dirs = ENV["PUPPETLIB"].split(File::PATH_SEPARATOR) + dirs
         end
         validate_dirs(dirs)
     end
 
     # Return all modules from this environment.
     # Cache the list, because it can be expensive to create.
     cached_attr(:modules, :ttl => Puppet[:filetimeout]) do
         module_names = modulepath.collect { |path| Dir.entries(path) }.flatten.uniq
         module_names.collect do |path|
             begin
                 Puppet::Module.new(path, self)
             rescue Puppet::Module::Error => e
                 nil
             end
         end.compact
     end
 
     # Cache the manifestdir, so that we aren't searching through
     # all known directories all the time.
     cached_attr(:manifestdir, :ttl => Puppet[:filetimeout]) do
         validate_dirs(self[:manifestdir].split(File::PATH_SEPARATOR))
     end
 
     def to_s
         name.to_s
     end
 
     def validate_dirs(dirs)
         dirs.collect do |dir|
             if dir !~ /^#{File::SEPARATOR}/
                 File.join(Dir.getwd, dir)
             else
                 dir
             end
         end.find_all do |p|
             p =~ /^#{File::SEPARATOR}/ && FileTest.directory?(p)
         end
     end
 
 end
diff --git a/spec/unit/node/environment.rb b/spec/unit/node/environment.rb
index ac542d01b..d0db2504c 100755
--- a/spec/unit/node/environment.rb
+++ b/spec/unit/node/environment.rb
@@ -1,243 +1,248 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/node/environment'
 require 'puppet/util/execution'
 
 describe Puppet::Node::Environment do
     after do
         Puppet::Node::Environment.clear
     end
 
     it "should include the Cacher module" do
         Puppet::Node::Environment.ancestors.should be_include(Puppet::Util::Cacher)
     end
 
     it "should use the filetimeout for the ttl for the modulepath" do
         Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout])
     end
 
     it "should use the filetimeout for the ttl for the module list" do
         Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
     end
 
     it "should use the filetimeout for the ttl for the manifestdir" do
         Puppet::Node::Environment.attr_ttl(:manifestdir).should == Integer(Puppet[:filetimeout])
     end
 
     it "should use the default environment if no name is provided while initializing an environment" do
         Puppet.settings.expects(:value).with(:environment).returns("one")
         Puppet::Node::Environment.new().name.should == :one
     end
 
     it "should treat environment instances as singletons" do
         Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one"))
     end
 
     it "should treat an environment specified as names or strings as equivalent" do
         Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one"))
     end
 
     it "should return its name when converted to a string" do
         Puppet::Node::Environment.new(:one).to_s.should == "one"
     end
 
+    it "should just return any provided environment if an environment is provided as the name" do
+        one = Puppet::Node::Environment.new(:one)
+        Puppet::Node::Environment.new(one).should equal(one)
+    end
+
     describe "when managing known resource types" do
         before do
             @env = Puppet::Node::Environment.new("dev")
             @collection = Puppet::Resource::TypeCollection.new(@env)
             @collection.stubs(:perform_initial_import)
         end
 
         it "should create a resource type collection if none exists" do
             Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection
             @env.known_resource_types.should equal(@collection)
         end
 
         it "should reuse any existing resource type collection" do
             @env.known_resource_types.should equal(@env.known_resource_types)
         end
         
         it "should perform the initial import when creating a new collection" do
             @collection.expects(:perform_initial_import)
             Puppet::Resource::TypeCollection.expects(:new).returns @collection
 
             @env.known_resource_types
         end
 
         it "should create and return a new collection rather than returning a stale collection" do
             @env.known_resource_types.expects(:stale?).returns true
 
             Puppet::Resource::TypeCollection.expects(:new).returns @collection
 
             @env.known_resource_types.should equal(@collection)
         end
     end
 
     [:modulepath, :manifestdir].each do |setting|
         it "should validate the #{setting} directories" do
             path = %w{/one /two}.join(File::PATH_SEPARATOR)
 
             env = Puppet::Node::Environment.new("testing")
             env.stubs(:[]).with(setting).returns path
 
             env.expects(:validate_dirs).with(%w{/one /two})
 
             env.send(setting)
         end
 
         it "should return the validated dirs for #{setting}" do
             path = %w{/one /two}.join(File::PATH_SEPARATOR)
 
             env = Puppet::Node::Environment.new("testing")
             env.stubs(:[]).with(setting).returns path
             env.stubs(:validate_dirs).returns %w{/one /two}
 
             env.send(setting).should == %w{/one /two}
         end
     end
 
     it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
         Puppet::Util::Execution.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do
             env = Puppet::Node::Environment.new("testing")
             module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
             env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two}
             env.expects(:[]).with(:modulepath).returns module_path
 
             env.modulepath.should == %w{/l1 /l2 /one /two}
         end
     end
 
     describe "when validating modulepath or manifestdir directories" do
         it "should not return non-directories" do
             env = Puppet::Node::Environment.new("testing")
 
             FileTest.expects(:directory?).with("/one").returns true
             FileTest.expects(:directory?).with("/two").returns false
 
             env.validate_dirs(%w{/one /two}).should == %w{/one}
         end
 
         it "should use the current working directory to fully-qualify unqualified paths" do
             FileTest.stubs(:directory?).returns true
             env = Puppet::Node::Environment.new("testing")
 
             two = File.join(Dir.getwd, "two")
             env.validate_dirs(%w{/one two}).should == ["/one", two]
         end
     end
 
     describe "when modeling a specific environment" do
         it "should have a method for returning the environment name" do
             Puppet::Node::Environment.new("testing").name.should == :testing
         end
 
         it "should provide an array-like accessor method for returning any environment-specific setting" do
             env = Puppet::Node::Environment.new("testing")
             env.should respond_to(:[])
         end
 
         it "should ask the Puppet settings instance for the setting qualified with the environment name" do
             Puppet.settings.expects(:value).with("myvar", :testing).returns("myval")
             env = Puppet::Node::Environment.new("testing")
             env["myvar"].should == "myval"
         end
 
         it "should be able to return an individual module that exists in its module path" do
             env = Puppet::Node::Environment.new("testing")
 
             mod = mock 'module'
             Puppet::Module.expects(:new).with("one", env).returns mod
             mod.expects(:exist?).returns true
 
             env.module("one").should equal(mod)
         end
 
         it "should return nil if asked for a module that does not exist in its path" do
             env = Puppet::Node::Environment.new("testing")
 
             mod = mock 'module'
             Puppet::Module.expects(:new).with("one", env).returns mod
             mod.expects(:exist?).returns false
 
             env.module("one").should be_nil
         end
 
         it "should be able to return its modules" do
             Puppet::Node::Environment.new("testing").should respond_to(:modules)
         end
 
         describe ".modules" do
             it "should return a module named for every directory in each module path" do
                 env = Puppet::Node::Environment.new("testing")
                 env.expects(:modulepath).at_least_once.returns %w{/a /b}
                 Dir.expects(:entries).with("/a").returns %w{foo bar}
                 Dir.expects(:entries).with("/b").returns %w{bee baz}
 
                 env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
             end
 
             it "should remove duplicates" do
                 env = Puppet::Node::Environment.new("testing")
                 env.expects(:modulepath).returns( %w{/a /b} ).at_least_once
                 Dir.expects(:entries).with("/a").returns %w{foo}
                 Dir.expects(:entries).with("/b").returns %w{foo}
 
                 env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
             end
 
             it "should ignore invalid modules" do
                 env = Puppet::Node::Environment.new("testing")
                 env.stubs(:modulepath).returns %w{/a}
                 Dir.expects(:entries).with("/a").returns %w{foo bar}
 
                 Puppet::Module.expects(:new).with { |name, env| name == "foo" }.returns mock("foomod", :name => "foo")
                 Puppet::Module.expects(:new).with { |name, env| name == "bar" }.raises( Puppet::Module::InvalidName, "name is invalid" )
 
                 env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
             end
 
             it "should create modules with the correct environment" do
                 env = Puppet::Node::Environment.new("testing")
                 env.expects(:modulepath).at_least_once.returns %w{/a}
                 Dir.expects(:entries).with("/a").returns %w{foo}
 
                 env.modules.each {|mod| mod.environment.should == env }
             end
 
             it "should cache the module list" do
                 env = Puppet::Node::Environment.new("testing")
                 env.expects(:modulepath).at_least_once.returns %w{/a}
                 Dir.expects(:entries).once.with("/a").returns %w{foo}
 
                 env.modules
                 env.modules
             end
         end
     end
 
     describe Puppet::Node::Environment::Helper do
         before do
             @helper = Object.new
             @helper.extend(Puppet::Node::Environment::Helper)
         end
 
         it "should be able to set and retrieve the environment" do
             @helper.environment = :foo
             @helper.environment.name.should == :foo
         end
 
         it "should accept an environment directly" do
             env = Puppet::Node::Environment.new :foo
             @helper.environment = env
             @helper.environment.name.should == :foo
         end
 
         it "should accept an environment as a string" do
             env = Puppet::Node::Environment.new "foo"
             @helper.environment = env
             @helper.environment.name.should == :foo
         end
     end
 end