diff --git a/lib/puppet/node.rb b/lib/puppet/node.rb
index 1fc615410..2453cd1d5 100644
--- a/lib/puppet/node.rb
+++ b/lib/puppet/node.rb
@@ -1,119 +1,119 @@
 require 'puppet/indirector'
 
 # A class for managing nodes, including their facts and environment.
 class Puppet::Node
   require 'puppet/node/facts'
   require 'puppet/node/environment'
 
   # Set up indirection, so that nodes can be looked for in
   # the node sources.
   extend Puppet::Indirector
 
   # Adds the environment getter and setter, with some instance/string conversion
   include Puppet::Node::Environment::Helper
 
   # Use the node source as the indirection terminus.
   indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
     A node is composed of its name, its facts, and its environment."
 
-  attr_accessor :name, :classes, :source, :ipaddress
-  attr_reader :time, :parameters
+  attr_accessor :name, :classes, :source, :ipaddress, :parameters
+  attr_reader :time
 
   def environment
     return super if @environment
 
     if env = parameters["environment"]
       self.environment = env
       return super
     end
 
     # Else, return the default
     Puppet::Node::Environment.new
   end
 
   def initialize(name, options = {})
     raise ArgumentError, "Node names cannot be nil" unless name
     @name = name
 
     if classes = options[:classes]
       if classes.is_a?(String)
         @classes = [classes]
       else
         @classes = classes
       end
     else
       @classes = []
     end
 
     @parameters = options[:parameters] || {}
 
     if env = options[:environment]
       self.environment = env
     end
 
     @time = Time.now
   end
 
   # Merge the node facts with parameters from the node source.
   def fact_merge
       if facts = Puppet::Node::Facts.find(name)
         merge(facts.values)
       end
   rescue => detail
       error = Puppet::Error.new("Could not retrieve facts for #{name}: #{detail}")
       error.set_backtrace(detail.backtrace)
       raise error
   end
 
   # Merge any random parameters into our parameter list.
   def merge(params)
     params.each do |name, value|
       @parameters[name] = value unless @parameters.include?(name)
     end
 
     @parameters["environment"] ||= self.environment.name.to_s if self.environment
   end
 
   # Calculate the list of names we might use for looking
   # up our node.  This is only used for AST nodes.
   def names
     return [name] if Puppet.settings[:strict_hostname_checking]
 
     names = []
 
     names += split_name(name) if name.include?(".")
 
     # First, get the fqdn
     unless fqdn = parameters["fqdn"]
       if parameters["hostname"] and parameters["domain"]
         fqdn = parameters["hostname"] + "." + parameters["domain"]
       else
         Puppet.warning "Host is missing hostname and/or domain: #{name}"
       end
     end
 
     # Now that we (might) have the fqdn, add each piece to the name
     # list to search, in order of longest to shortest.
     names += split_name(fqdn) if fqdn
 
     # And make sure the node name is first, since that's the most
     # likely usage.
     #   The name is usually the Certificate CN, but it can be
     # set to the 'facter' hostname instead.
     if Puppet[:node_name] == 'cert'
       names.unshift name
     else
       names.unshift parameters["hostname"]
     end
     names.uniq
   end
 
   def split_name(name)
     list = name.split(".")
     tmp = []
     list.each_with_index do |short, i|
       tmp << list[0..i].join(".")
     end
     tmp.reverse
   end
 end
diff --git a/spec/unit/indirector/node/exec_spec.rb b/spec/unit/indirector/node/exec_spec.rb
index d5299ad16..d214a5ef6 100755
--- a/spec/unit/indirector/node/exec_spec.rb
+++ b/spec/unit/indirector/node/exec_spec.rb
@@ -1,69 +1,70 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/indirector/node/exec'
 
 describe Puppet::Node::Exec do
   before do
     @indirection = mock 'indirection'
     Puppet.settings.stubs(:value).with(:external_nodes).returns("/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.expects(:[]).with(:external_nodes).returns("/bin/echo")
       @searcher.command.should == %w{/bin/echo}
     end
 
     it "should throw an exception if no external node command is set" do
       Puppet.expects(:[]).with(:external_nodes).returns("none")
       proc { @searcher.find(stub('request', :key => "foo")) }.should raise_error(ArgumentError)
     end
   end
 
   describe "when handling the results of the command" do
     before do
-      @node = stub 'node', :fact_merge => nil
       @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|
         return YAML.dump(result)
       end
 
       @request = stub 'request', :key => @name
     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"}
-      @node.expects(:parameters=).with "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}
-      @node.expects(:classes=).with %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"
-      @node.expects(:environment=).with "yay"
       @searcher.find(@request)
+      @node.environment.to_s.should == 'yay'
     end
   end
 end