Another intermediate commit. The node and fact classes are now functional and are used instead of the network handlers, which have been removed. There are some failing tests as a result, but I want to get this code committed before I massage the rest of the system to make it work again.

10 files changed, 530 insertions, 159 deletions

diff --git a/spec/unit/indirector/facts/yaml.rb b/spec/unit/indirector/facts/yaml.rb
index 45c079a69..176a47f04 100755
--- a/spec/unit/indirector/facts/yaml.rb
+++ b/spec/unit/indirector/facts/yaml.rb
@@ -23,7 +23,7 @@ describe Puppet::Indirector.terminus(:facts, :yaml), " when managing facts" do
     it "should store facts in YAML in the yamlfactdir" do
         values = {"one" => "two", "three" => "four"}
         facts = Puppet::Node::Facts.new("node", values)
-        @store.put(facts)
+        @store.post(facts)
 
         # Make sure the file exists
         path = File.join(Puppet[:yamlfactdir], facts.name) + ".yaml"
diff --git a/spec/unit/indirector/indirection.rb b/spec/unit/indirector/indirection.rb
new file mode 100755
index 000000000..e9b10c8c7
--- /dev/null
+++ b/spec/unit/indirector/indirection.rb
@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/indirector'
+
+describe Puppet::Indirector::Indirection, " when initializing" do
+    it "should set the name" do
+        @indirection = Puppet::Indirector::Indirection.new(:myind)
+        @indirection.name.should == :myind
+    end
+
+    it "should set any passed options" do
+        @indirection = Puppet::Indirector::Indirection.new(:myind, :to => :node_source)
+        @indirection.to.should == :node_source
+    end
+
+    it "should only allow valid configuration parameters to be specified as :to targets" do
+        proc { Puppet::Indirector::Indirection.new(:myind, :to => :no_such_variable) }.should raise_error(ArgumentError)
+    end
+
+    after do
+        if defined? @indirection
+            @indirection.delete
+        end
+    end
+end
+
+describe Puppet::Indirector, " when managing termini" do
+    before do
+        @indirection = Puppet::Indirector::Indirection.new(:node, :to => :node_source)
+    end
+
+    it "should allow the clearance of cached termini" do
+        terminus1 = mock 'terminus1'
+        terminus2 = mock 'terminus2'
+        Puppet::Indirector.terminus(:node, Puppet[:node_source]).stubs(:new).returns(terminus1, terminus2, ArgumentError)
+        @indirection.terminus.should equal(terminus1)
+        @indirection.class.clear_cache
+        @indirection.terminus.should equal(terminus2)
+    end
+
+    # Make sure it caches the terminus.
+    it "should return the same terminus each time" do
+        @indirection = Puppet::Indirector::Indirection.new(:node, :to => :node_source)
+        @terminus = mock 'new'
+        Puppet::Indirector.terminus(:node, Puppet[:node_source]).expects(:new).returns(@terminus)
+
+        @indirection.terminus.should equal(@terminus)
+        @indirection.terminus.should equal(@terminus)
+    end
+
+    after do
+        @indirection.delete
+        Puppet::Indirector::Indirection.clear_cache
+    end
+end
diff --git a/spec/unit/indirector/indirector.rb b/spec/unit/indirector/indirector.rb
index c4221febb..312c60951 100755
--- a/spec/unit/indirector/indirector.rb
+++ b/spec/unit/indirector/indirector.rb
@@ -11,15 +11,10 @@ describe Puppet::Indirector, " when managing indirections" do
         @indirector.send(:extend, Puppet::Indirector)
     end
 
-    # LAK:FIXME This seems like multiple tests, but I don't really know how to test one at a time.
-    it "should accept specification of an indirection terminus via a configuration parameter" do
-        @indirector.indirects :test, :to => :node_source
-        Puppet[:node_source] = "test_source"
-        klass = mock 'terminus_class'
-        terminus = mock 'terminus'
-        klass.expects(:new).returns terminus
-        Puppet::Indirector.expects(:terminus).with(:test, :test_source).returns(klass)
-        @indirector.send(:terminus).should equal(terminus)
+    it "should create an indirection" do
+        indirection = @indirector.indirects :test, :to => :node_source
+        indirection.name.should == :test
+        indirection.to.should == :node_source
     end
 
     it "should not allow more than one indirection in the same object" do
@@ -33,18 +28,15 @@ describe Puppet::Indirector, " when managing indirections" do
         other.send(:extend, Puppet::Indirector)
         proc { other.indirects :test }.should_not raise_error
     end
-end
-
-describe Puppet::Indirector, " when managing termini" do
-    before do
-        @indirector = Object.new
-        @indirector.send(:extend, Puppet::Indirector)
-    end
 
     it "should should autoload termini from disk" do
         Puppet::Indirector.expects(:instance_load).with(:test, "puppet/indirector/test")
         @indirector.indirects :test
     end
+
+    after do
+        Puppet.config.clear
+    end
 end
 
 describe Puppet::Indirector, " when performing indirections" do
@@ -66,14 +58,4 @@ describe Puppet::Indirector, " when performing indirections" do
         @terminus_class.expects(:new).returns(terminus)
         @indirector.put("myargument")
     end
-
-    # Make sure it caches the terminus.
-    it "should use the same terminus for all indirections" do
-        terminus = mock 'terminus'
-        terminus.expects(:put).with("myargument")
-        terminus.expects(:get).with("other_argument")
-        @terminus_class.expects(:new).returns(terminus)
-        @indirector.put("myargument")
-        @indirector.get("other_argument")
-    end
 end
diff --git a/spec/unit/indirector/node/external.rb b/spec/unit/indirector/node/external.rb
new file mode 100755
index 000000000..30b2f74c2
--- /dev/null
+++ b/spec/unit/indirector/node/external.rb
@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'yaml'
+require 'puppet/indirector'
+
+describe Puppet::Indirector.terminus(:node, :external), " when searching for nodes" do
+    require 'puppet/node'
+
+    before do
+        Puppet.config[:external_nodes] = "/yay/ness"
+        @searcher = Puppet::Indirector.terminus(:node, :external).new
+
+        # Set the searcher up so that we do not need to actually call the
+        # external script.
+        @searcher.meta_def(:execute) do |command|
+            name = command.last.chomp
+            result = {}
+
+            if name =~ /a/
+                result[:parameters] = {'one' => command.last + '1', 'two' => command.last + '2'}
+            end
+
+            if name =~ /p/
+                result['classes'] = [1,2,3].collect { |n| command.last + n.to_s }
+            end
+
+            return YAML.dump(result)
+        end
+    end
+
+    it "should throw an exception if the node_source is external but no external node command is set" do
+        Puppet[:external_nodes] = "none"
+        proc { @searcher.get("foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should throw an exception if the external node source is not fully qualified" do
+        Puppet[:external_nodes] = "mycommand"
+        proc { @searcher.get("foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should execute the command with the node name as the only argument" do
+        command = [Puppet[:external_nodes], "yay"]
+        @searcher.expects(:execute).with(command).returns("")
+        @searcher.get("yay")
+    end
+
+    it "should return a node object" do
+        @searcher.get("apple").should be_instance_of(Puppet::Node)
+    end
+
+    it "should set the node's name" do
+        @searcher.get("apple").name.should == "apple"
+    end
+    
+    # If we use a name that has a 'p' but no 'a', then our test generator
+    # will return classes but no parameters.
+    it "should be able to configure a node's classes" do
+        node = @searcher.get("plum")
+        node.classes.should == %w{plum1 plum2 plum3}
+        node.parameters.should == {}
+    end
+    
+    # If we use a name that has an 'a' but no 'p', then our test generator
+    # will return parameters but no classes.
+    it "should be able to configure a node's parameters" do
+        node = @searcher.get("guava")
+        node.classes.should == []
+        node.parameters.should == {"one" => "guava1", "two" => "guava2"}
+    end
+    
+    it "should be able to configure a node's classes and parameters" do
+        node = @searcher.get("apple")
+        node.classes.should == %w{apple1 apple2 apple3}
+        node.parameters.should == {"one" => "apple1", "two" => "apple2"}
+    end
+
+    it "should merge node facts with returned parameters" do
+        facts = Puppet::Node::Facts.new("apple", "three" => "four")
+        Puppet::Node::Facts.expects(:get).with("apple").returns(facts)
+        node = @searcher.get("apple")
+        node.parameters["three"].should == "four"
+    end
+
+    it "should return nil when it cannot find the node" do
+        @searcher.get("honeydew").should be_nil
+    end
+    
+    # Make sure a nodesearch with arguments works
+    def test_nodesearch_external_arguments
+        mapper = mk_node_mapper
+        Puppet[:external_nodes] = "#{mapper} -s something -p somethingelse"
+        searcher = mk_searcher(:external)
+        node = nil
+        assert_nothing_raised do
+            node = searcher.nodesearch("apple")
+        end
+        assert_instance_of(SimpleNode, node, "did not create node")
+    end
+    
+    # A wrapper test, to make sure we're correctly calling the external search method.
+    def test_nodesearch_external_functional
+        mapper = mk_node_mapper
+        searcher = mk_searcher(:external)
+        
+        Puppet[:external_nodes] = mapper
+        
+        node = nil
+        assert_nothing_raised do
+            node = searcher.nodesearch("apple")
+        end
+        assert_instance_of(SimpleNode, node, "did not create node")
+    end
+
+    after do
+        Puppet.config.clear
+    end
+end
diff --git a/spec/unit/indirector/node/ldap.rb b/spec/unit/indirector/node/ldap.rb
new file mode 100755
index 000000000..c6eb45ffc
--- /dev/null
+++ b/spec/unit/indirector/node/ldap.rb
@@ -0,0 +1,243 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'yaml'
+require 'puppet/indirector'
+
+describe Puppet::Indirector.terminus(:node, :ldap), " when searching for nodes" do
+    require 'puppet/node'
+
+    def setup
+        Puppet.config[:external_nodes] = "/yay/ness"
+        @searcher = Puppet::Indirector.terminus(:node, :ldap).new
+        nodetable = {}
+        @nodetable = nodetable
+        # Override the ldapsearch definition, so we don't have to actually set it up.
+        @searcher.meta_def(:ldapsearch) do |name|
+            nodetable[name]
+        end
+    end
+
+    it "should return nil for hosts that cannot be found" do
+        @searcher.get("foo").should be_nil
+    end
+
+    it "should return Puppet::Node instances" do
+        @nodetable["foo"] = [nil, %w{}, {}]
+        @searcher.get("foo").should be_instance_of(Puppet::Node)
+    end
+
+    it "should set the node name" do
+        @nodetable["foo"] = [nil, %w{}, {}]
+        @searcher.get("foo").name.should == "foo"
+    end
+
+    it "should set the classes" do
+        @nodetable["foo"] = [nil, %w{one two}, {}]
+        @searcher.get("foo").classes.should == %w{one two}
+    end
+
+    it "should set the parameters" do
+        @nodetable["foo"] = [nil, %w{}, {"one" => "two"}]
+        @searcher.get("foo").parameters.should == {"one" => "two"}
+    end
+
+    it "should set classes and parameters from the parent node" do
+        @nodetable["foo"] = ["middle", %w{one two}, {"one" => "two"}]
+        @nodetable["middle"] = [nil, %w{three four}, {"three" => "four"}]
+        node = @searcher.get("foo")
+        node.classes.sort.should == %w{one two three four}.sort
+        node.parameters.should == {"one" => "two", "three" => "four"}
+    end
+
+    it "should prefer child parameters to parent parameters" do
+        @nodetable["foo"] = ["middle", %w{}, {"one" => "two"}]
+        @nodetable["middle"] = [nil, %w{}, {"one" => "four"}]
+        @searcher.get("foo").parameters["one"].should == "two"
+    end
+
+    it "should recurse indefinitely through parent relationships" do
+        @nodetable["foo"] = ["middle", %w{one two}, {"one" => "two"}]
+        @nodetable["middle"] = ["top", %w{three four}, {"three" => "four"}]
+        @nodetable["top"] = [nil, %w{five six}, {"five" => "six"}]
+        node = @searcher.get("foo")
+        node.parameters.should == {"one" => "two", "three" => "four", "five" => "six"}
+        node.classes.sort.should == %w{one two three four five six}.sort
+    end
+
+    # This can stay in the main test suite because it doesn't actually use ldapsearch,
+    # it just overrides the method so it behaves as though it were hitting ldap.
+    def test_ldap_nodesearch
+
+        # Make sure we get nothing for nonexistent hosts
+        node = nil
+        assert_nothing_raised do
+            node = searcher.nodesearch("nosuchhost")
+        end
+
+        assert_nil(node, "Got a node for a non-existent host")
+
+        # Now add a base node with some classes and parameters
+        nodetable["base"] = [nil, %w{one two}, {"base" => "true"}]
+
+        assert_nothing_raised do
+            node = searcher.nodesearch("base")
+        end
+
+        assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch")
+        assert_equal("base", node.name, "node name was not set")
+
+        assert_equal(%w{one two}, node.classes, "node classes were not set")
+        assert_equal({"base" => "true"}, node.parameters, "node parameters were not set")
+
+        # Now use a different with this as the base
+        nodetable["middle"] = ["base", %w{three}, {"center" => "boo"}]
+        assert_nothing_raised do
+            node = searcher.nodesearch("middle")
+        end
+
+        assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch")
+        assert_equal("middle", node.name, "node name was not set")
+
+        assert_equal(%w{one two three}.sort, node.classes.sort, "node classes were not set correctly with a parent node")
+        assert_equal({"base" => "true", "center" => "boo"}, node.parameters, "node parameters were not set correctly with a parent node")
+
+        # And one further, to make sure we fully recurse
+        nodetable["top"] = ["middle", %w{four five}, {"master" => "far"}]
+        assert_nothing_raised do
+            node = searcher.nodesearch("top")
+        end
+
+        assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch")
+        assert_equal("top", node.name, "node name was not set")
+
+        assert_equal(%w{one two three four five}.sort, node.classes.sort, "node classes were not set correctly with the top node")
+        assert_equal({"base" => "true", "center" => "boo", "master" => "far"}, node.parameters, "node parameters were not set correctly with the top node")
+    end
+end
+
+describe Puppet::Indirector.terminus(:node, :ldap), " when interacting with ldap" do
+    confine "LDAP is not available" => Puppet.features.ldap?
+    confine "No LDAP test data for networks other than Luke's" => Facter.value(:domain) == "madstop.com"
+
+    def ldapconnect
+
+        @ldap = LDAP::Conn.new("ldap", 389)
+        @ldap.set_option( LDAP::LDAP_OPT_PROTOCOL_VERSION, 3 )
+        @ldap.simple_bind("", "")
+
+        return @ldap
+    end
+
+    def ldaphost(name)
+        node = Puppet::Node.new(name)
+        parent = nil
+        found = false
+        @ldap.search( "ou=hosts, dc=madstop, dc=com", 2,
+            "(&(objectclass=puppetclient)(cn=%s))" % name
+        ) do |entry|
+            node.classes = entry.vals("puppetclass") || []
+            node.parameters = entry.to_hash.inject({}) do |hash, ary|
+                if ary[1].length == 1
+                    hash[ary[0]] = ary[1].shift
+                else
+                    hash[ary[0]] = ary[1]
+                end
+                hash
+            end
+            parent = node.parameters["parentnode"]
+            found = true
+        end
+        raise "Could not find node %s" % name unless found
+
+        return node, parent
+    end
+
+    it "should have tests" do
+        raise ArgumentError
+    end
+
+    def test_ldapsearch
+        Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com"
+        Puppet[:ldapnodes] = true
+
+        searcher = Object.new
+        searcher.extend(Node.node_source(:ldap))
+
+        ldapconnect()
+
+        # Make sure we get nil and nil back when we search for something missing
+        parent, classes, parameters = nil
+        assert_nothing_raised do
+            parent, classes, parameters = searcher.ldapsearch("nosuchhost")
+        end
+
+        assert_nil(parent, "Got a parent for a non-existent host")
+        assert_nil(classes, "Got classes for a non-existent host")
+
+        # Make sure we can find 'culain' in ldap
+        assert_nothing_raised do
+            parent, classes, parameters = searcher.ldapsearch("culain")
+        end
+
+        node, realparent = ldaphost("culain")
+        assert_equal(realparent, parent, "did not get correct parent node from ldap")
+        assert_equal(node.classes, classes, "did not get correct ldap classes from ldap")
+        assert_equal(node.parameters, parameters, "did not get correct ldap parameters from ldap")
+
+        # Now compare when we specify the attributes to get.
+        Puppet[:ldapattrs] = "cn"
+        assert_nothing_raised do
+            parent, classes, parameters = searcher.ldapsearch("culain")
+        end
+        assert_equal(realparent, parent, "did not get correct parent node from ldap")
+        assert_equal(node.classes, classes, "did not get correct ldap classes from ldap")
+
+        list = %w{cn puppetclass parentnode dn}
+        should = node.parameters.inject({}) { |h, a| h[a[0]] = a[1] if list.include?(a[0]); h }
+        assert_equal(should, parameters, "did not get correct ldap parameters from ldap")
+    end
+end
+
+describe Puppet::Indirector.terminus(:node, :ldap), " when connecting to ldap" do
+    confine "Not running on culain as root" => (Puppet::Util::SUIDManager.uid == 0 and Facter.value("hostname") == "culain")
+
+    it "should have tests" do
+        raise ArgumentError
+    end
+
+    def test_ldapreconnect
+        Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com"
+        Puppet[:ldapnodes] = true
+
+        searcher = Object.new
+        searcher.extend(Node.node_source(:ldap))
+        hostname = "culain.madstop.com"
+
+        # look for our host
+        assert_nothing_raised {
+            parent, classes = searcher.nodesearch(hostname)
+        }
+
+        # Now restart ldap
+        system("/etc/init.d/slapd restart 2>/dev/null >/dev/null")
+        sleep(1)
+
+        # and look again
+        assert_nothing_raised {
+            parent, classes = searcher.nodesearch(hostname)
+        }
+
+        # Now stop ldap
+        system("/etc/init.d/slapd stop 2>/dev/null >/dev/null")
+        cleanup do
+            system("/etc/init.d/slapd start 2>/dev/null >/dev/null")
+        end
+
+        # And make sure we actually fail here
+        assert_raise(Puppet::Error) {
+            parent, classes = searcher.nodesearch(hostname)
+        }
+    end
+end
diff --git a/spec/unit/indirector/node/none.rb b/spec/unit/indirector/node/none.rb
new file mode 100755
index 000000000..d52d7ca83
--- /dev/null
+++ b/spec/unit/indirector/node/none.rb
@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'puppet/indirector'
+require 'puppet/node/facts'
+
+describe Puppet::Indirector.terminus(:node, :none), " when searching for nodes" do
+    before do
+        Puppet.config[:node_source] = "none"
+        @searcher = Puppet::Indirector.terminus(:node, :none).new
+    end
+
+    it "should create a node instance" do
+        @searcher.get("yay").should be_instance_of(Puppet::Node)
+    end
+
+    it "should create a new node with the correct name" do
+        @searcher.get("yay").name.should == "yay"
+    end
+
+    it "should merge the node's facts" do
+        facts = Puppet::Node::Facts.new("yay", "one" => "two", "three" => "four")
+        Puppet::Node::Facts.expects(:get).with("yay").returns(facts)
+        node = @searcher.get("yay")
+        node.parameters["one"].should == "two"
+        node.parameters["three"].should == "four"
+    end
+
+    after do
+        Puppet.config.clear
+    end
+end
diff --git a/spec/unit/node/facts.rb b/spec/unit/node/facts.rb
index c7fc65f38..c677c1d2e 100755
--- a/spec/unit/node/facts.rb
+++ b/spec/unit/node/facts.rb
@@ -6,11 +6,12 @@ require 'puppet/node/facts'
 
 describe Puppet::Node::Facts, " when indirecting" do
     before do
-        Puppet[:fact_store] = "test_store"
-        @terminus_class = mock 'terminus_class'
         @terminus = mock 'terminus'
-        @terminus_class.expects(:new).returns(@terminus)
-        Puppet::Indirector.expects(:terminus).with(:facts, :test_store).returns(@terminus_class)
+        Puppet::Indirector.terminus(:facts, Puppet[:fact_store].intern).stubs(:new).returns(@terminus)
+
+        # We have to clear the cache so that the facts ask for our terminus stub,
+        # instead of anything that might be cached.
+        Puppet::Indirector::Indirection.clear_cache
     end
 
     it "should redirect to the specified fact store for retrieval" do
@@ -19,7 +20,19 @@ describe Puppet::Node::Facts, " when indirecting" do
     end
 
     it "should redirect to the specified fact store for storage" do
-        @terminus.expects(:put).with(:my_facts)
-        Puppet::Node::Facts.put(:my_facts)
+        @terminus.expects(:post).with(:my_facts)
+        Puppet::Node::Facts.post(:my_facts)
+    end
+
+    after do
+        mocha_verify
+        Puppet::Indirector::Indirection.clear_cache
+    end
+end
+
+describe Puppet::Node::Facts, " when storing and retrieving" do
+    it "should add metadata to the facts" do
+        facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four")
+        facts.values[:_timestamp].should be_instance_of(Time)
     end
 end
diff --git a/spec/unit/node/node.rb b/spec/unit/node/node.rb
index a6cc1e301..9342dc5ce 100755
--- a/spec/unit/node/node.rb
+++ b/spec/unit/node/node.rb
@@ -85,32 +85,40 @@ end
 describe Puppet::Node, " when merging facts" do
     before do
         @node = Puppet::Node.new("testnode")
+        Puppet::Node::Facts.stubs(:get).with(@node.name).returns(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
     end
 
     it "should prefer parameters already set on the node over facts from the node" do
         @node.parameters = {"one" => "a"}
-        @node.fact_merge("one" => "c")
+        @node.fact_merge
         @node.parameters["one"].should == "a"
     end
 
     it "should add passed parameters to the parameter list" do
         @node.parameters = {"one" => "a"}
-        @node.fact_merge("two" => "b")
+        @node.fact_merge
         @node.parameters["two"].should == "b"
     end
+
+    it "should accept arbitrary parameters to merge into its parameters" do
+        @node.parameters = {"one" => "a"}
+        @node.merge "two" => "three"
+        @node.parameters["two"].should == "three"
+    end
 end
 
 describe Puppet::Node, " when indirecting" do
     before do
-        Puppet[:node_source] = :test_source
-        @terminus_class = mock 'terminus_class'
         @terminus = mock 'terminus'
-        @terminus_class.expects(:new).returns(@terminus)
-        Puppet::Indirector.expects(:terminus).with(:node, :test_source).returns(@terminus_class)
+        Puppet::Indirector.terminus(:node, Puppet[:node_source]).stubs(:new).returns(@terminus)
     end
 
     it "should redirect to the specified node source" do
         @terminus.expects(:get).with(:my_node)
         Puppet::Node.get(:my_node)
     end
+
+    after do
+        Puppet::Indirector::Indirection.clear_cache
+    end
 end
diff --git a/spec/unit/other/node.rb b/spec/unit/other/node.rb
deleted file mode 100755
index 66d5ba9d7..000000000
--- a/spec/unit/other/node.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-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"
-    end
-
-    it "should default to an empty parameter hash" do
-        @node.parameters.should == {}
-    end
-
-    it "should default to an empty class array" do
-        @node.classes.should == []
-    end
-
-    it "should note its creation time" do
-        @node.time.should be_instance_of(Time)
-    end
-
-    it "should accept parameters passed in during initialization" do
-        params = {"a" => "b"}
-        @node = Puppet::Node.new("testing", :parameters => params)
-        @node.parameters.should == params
-    end
-
-    it "should accept classes passed in during initialization" do
-        classes = %w{one two}
-        @node = Puppet::Node.new("testing", :classes => classes)
-        @node.classes.should == classes
-    end
-
-    it "should always return classes as an array" do
-        @node = Puppet::Node.new("testing", :classes => "myclass")
-        @node.classes.should == ["myclass"]
-    end
-
-    it "should accept the environment during initialization" do
-        @node = Puppet::Node.new("testing", :environment => "myenv")
-        @node.environment.should == "myenv"
-    end
-
-    it "should accept names passed in" do
-        @node = Puppet::Node.new("testing", :names => ["myenv"])
-        @node.names.should == ["myenv"]
-    end
-end
-
-describe Puppet::Node, " when returning the environment" do
-    before do
-        @node = Puppet::Node.new("testnode")
-    end
-
-    it "should return the 'environment' fact if present and there is no explicit environment" do
-        @node.parameters = {"environment" => "myenv"}
-        @node.environment.should == "myenv"
-    end
-
-    it "should return the central environment if there is no environment fact nor explicit environment" do
-        Puppet.config.expects(:[]).with(:environment).returns(:centralenv)
-        @node.environment.should == :centralenv
-    end
-
-    it "should not use an explicit environment that is an empty string" do
-        @node.environment == ""
-        @node.environment.should be_nil
-    end
-
-    it "should not use an environment fact that is an empty string" do
-        @node.parameters = {"environment" => ""}
-        @node.environment.should be_nil
-    end
-
-    it "should not use an explicit environment that is an empty string" do
-        Puppet.config.expects(:[]).with(:environment).returns(nil)
-        @node.environment.should be_nil
-    end
-end
-
-describe Puppet::Node, " when merging facts" do
-    before do
-        @node = Puppet::Node.new("testnode")
-    end
-
-    it "should prefer parameters already set on the node over facts from the node" do
-        @node.parameters = {"one" => "a"}
-        @node.fact_merge("one" => "c")
-        @node.parameters["one"].should == "a"
-    end
-
-    it "should add passed parameters to the parameter list" do
-        @node.parameters = {"one" => "a"}
-        @node.fact_merge("two" => "b")
-        @node.parameters["two"].should == "b"
-    end
-end
diff --git a/spec/unit/util/config.rb b/spec/unit/util/config.rb
index 348a54893..28ccb04d7 100755
--- a/spec/unit/util/config.rb
+++ b/spec/unit/util/config.rb
@@ -387,22 +387,40 @@ describe Puppet::Util::Config, " when reparsing its configuration" do
     end
 end
 
-#describe Puppet::Util::Config, " when being used to manage the host machine" do
-#    it "should provide a method that writes files with the correct modes"
-#
-#    it "should provide a method that creates directories with the correct modes"
-#
-#    it "should provide a method to declare what directories should exist"
-#
-#    it "should provide a method to trigger enforcing of file modes on existing files and directories"
-#
-#    it "should provide a method to convert the file mode enforcement into a Puppet manifest"
-#
-#    it "should provide an option to create needed users and groups"
-#
-#    it "should provide a method to print out the current configuration"
-#
-#    it "should be able to provide all of its parameters in a format compatible with GetOpt::Long"
-#
-#    it "should not attempt to manage files within /dev"
-#end
+describe Puppet::Util::Config, " when being used to manage the host machine" do
+    it "should provide a method that writes files with the correct modes" do
+        pending "Not converted from test/unit yet"
+    end
+
+    it "should provide a method that creates directories with the correct modes" do
+        pending "Not converted from test/unit yet"
+    end
+
+    it "should provide a method to declare what directories should exist" do
+        pending "Not converted from test/unit yet"
+    end
+
+    it "should provide a method to trigger enforcing of file modes on existing files and directories" do
+        pending "Not converted from test/unit yet"
+    end
+
+    it "should provide a method to convert the file mode enforcement into a Puppet manifest" do
+        pending "Not converted from test/unit yet"
+    end
+
+    it "should provide an option to create needed users and groups" do
+        pending "Not converted from test/unit yet"
+    end
+
+    it "should provide a method to print out the current configuration" do
+        pending "Not converted from test/unit yet"
+    end
+
+    it "should be able to provide all of its parameters in a format compatible with GetOpt::Long" do
+        pending "Not converted from test/unit yet"
+    end
+
+    it "should not attempt to manage files within /dev" do
+        pending "Not converted from test/unit yet"
+    end
+end