15 files changed, 236 insertions, 236 deletions

diff --git a/spec/unit/indirector/configuration/compiler.rb b/spec/unit/indirector/catalog/compiler.rb
index d949a28a5..77638a410 100755
--- a/spec/unit/indirector/configuration/compiler.rb
+++ b/spec/unit/indirector/catalog/compiler.rb
@@ -5,9 +5,9 @@
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
-require 'puppet/indirector/configuration/compiler'
+require 'puppet/indirector/catalog/compiler'
 
-describe Puppet::Node::Configuration::Compiler do
+describe Puppet::Node::Catalog::Compiler do
     before do
         Puppet.expects(:version).returns(1)
         Facter.expects(:value).with('fqdn').returns("my.server.com")
@@ -15,11 +15,11 @@ describe Puppet::Node::Configuration::Compiler do
     end
 
     it "should gather data about itself" do
-        Puppet::Node::Configuration::Compiler.new
+        Puppet::Node::Catalog::Compiler.new
     end
 
     it "should cache the server metadata and reuse it" do
-        compiler = Puppet::Node::Configuration::Compiler.new
+        compiler = Puppet::Node::Catalog::Compiler.new
         node1 = stub 'node1', :merge => nil
         node2 = stub 'node2', :merge => nil
         compiler.stubs(:compile)
@@ -30,17 +30,17 @@ describe Puppet::Node::Configuration::Compiler do
         compiler.find('node2')
     end
 
-    it "should provide a method for determining if the configuration is networked" do
-        compiler = Puppet::Node::Configuration::Compiler.new
+    it "should provide a method for determining if the catalog is networked" do
+        compiler = Puppet::Node::Catalog::Compiler.new
         compiler.should respond_to(:networked?)
     end
 end
 
-describe Puppet::Node::Configuration::Compiler, " when creating the interpreter" do
+describe Puppet::Node::Catalog::Compiler, " when creating the interpreter" do
     before do
         # This gets pretty annoying on a plane where we have no IP address
         Facter.stubs(:value).returns("whatever")
-        @compiler = Puppet::Node::Configuration::Compiler.new
+        @compiler = Puppet::Node::Catalog::Compiler.new
     end
 
     it "should not create the interpreter until it is asked for the first time" do
@@ -57,10 +57,10 @@ describe Puppet::Node::Configuration::Compiler, " when creating the interpreter"
     end
 end
 
-describe Puppet::Node::Configuration::Compiler, " when finding nodes" do
+describe Puppet::Node::Catalog::Compiler, " when finding nodes" do
     before do
         Facter.stubs(:value).returns("whatever")
-        @compiler = Puppet::Node::Configuration::Compiler.new
+        @compiler = Puppet::Node::Catalog::Compiler.new
         @name = "me"
         @node = mock 'node'
         @compiler.stubs(:compile)
@@ -79,13 +79,13 @@ describe Puppet::Node::Configuration::Compiler, " when finding nodes" do
     end
 end
 
-describe Puppet::Node::Configuration::Compiler, " after finding nodes" do
+describe Puppet::Node::Catalog::Compiler, " after finding nodes" do
     before do
         Puppet.expects(:version).returns(1)
         Puppet.settings.stubs(:value).with(:node_name).returns("cert")
         Facter.expects(:value).with('fqdn').returns("my.server.com")
         Facter.expects(:value).with('ipaddress').returns("my.ip.address")
-        @compiler = Puppet::Node::Configuration::Compiler.new
+        @compiler = Puppet::Node::Catalog::Compiler.new
         @name = "me"
         @node = mock 'node'
         @compiler.stubs(:compile)
@@ -115,13 +115,13 @@ describe Puppet::Node::Configuration::Compiler, " after finding nodes" do
     end
 end
 
-describe Puppet::Node::Configuration::Compiler, " when creating configurations" do
+describe Puppet::Node::Catalog::Compiler, " when creating catalogs" do
     before do
         Facter.stubs(:value).returns("whatever")
         env = stub 'environment', :name => "yay"
         Puppet::Node::Environment.stubs(:new).returns(env)
 
-        @compiler = Puppet::Node::Configuration::Compiler.new
+        @compiler = Puppet::Node::Catalog::Compiler.new
         @name = "me"
         @node = Puppet::Node.new @name
         @node.stubs(:merge)
@@ -140,63 +140,63 @@ describe Puppet::Node::Configuration::Compiler, " when creating configurations"
         @compiler.find(@name)
     end
 
-    it "should return the results of compiling as the configuration" do
+    it "should return the results of compiling as the catalog" do
         config = mock 'config'
-        result = mock 'result', :to_transportable => :configuration
+        result = mock 'result', :to_transportable => :catalog
 
         @compiler.interpreter.expects(:compile).with(@node).returns(result)
-        @compiler.find(@name).should == :configuration
+        @compiler.find(@name).should == :catalog
     end
 
     it "should benchmark the compile process" do
         @compiler.stubs(:networked?).returns(true)
         @compiler.expects(:benchmark).with do |level, message|
-            level == :notice and message =~ /^Compiled configuration/
+            level == :notice and message =~ /^Compiled catalog/
         end
         @compiler.interpreter.stubs(:compile).with(@node)
         @compiler.find(@name)
     end
 end
 
-describe Puppet::Node::Configuration::Compiler, " when determining a client's available configuration version" do
+describe Puppet::Node::Catalog::Compiler, " when determining a client's available catalog version" do
     before do
         Puppet::Node::Facts.stubs(:find).returns(nil)
         Facter.stubs(:value).returns("whatever")
-        @configuration = Puppet::Node::Configuration::Compiler.new
+        @catalog = Puppet::Node::Catalog::Compiler.new
         @name = "johnny"
     end
 
-    it "should provide a mechanism for providing the version of a given client's configuration" do
-        @configuration.should respond_to(:version)
+    it "should provide a mechanism for providing the version of a given client's catalog" do
+        @catalog.should respond_to(:version)
     end
 
-    it "should use the client's Facts version as the available configuration version if it is the most recent" do
+    it "should use the client's Facts version as the available catalog version if it is the most recent" do
         Puppet::Node::Facts.expects(:version).with(@name).returns(5)
         Puppet::Node.expects(:version).with(@name).returns(3)
-        @configuration.interpreter.stubs(:configuration_version).returns(4)
+        @catalog.interpreter.stubs(:catalog_version).returns(4)
 
-        @configuration.version(@name).should == 5
+        @catalog.version(@name).should == 5
     end
 
-    it "should use the client's Node version as the available configuration version if it is the most recent" do
+    it "should use the client's Node version as the available catalog version if it is the most recent" do
         Puppet::Node::Facts.expects(:version).with(@name).returns(3)
         Puppet::Node.expects(:version).with(@name).returns(5)
-        @configuration.interpreter.stubs(:configuration_version).returns(4)
+        @catalog.interpreter.stubs(:catalog_version).returns(4)
 
-        @configuration.version(@name).should == 5
+        @catalog.version(@name).should == 5
     end
 
-    it "should use the last parse date as the available configuration version if it is the most recent" do
+    it "should use the last parse date as the available catalog version if it is the most recent" do
         Puppet::Node::Facts.expects(:version).with(@name).returns(3)
         Puppet::Node.expects(:version).with(@name).returns(4)
-        @configuration.interpreter.stubs(:configuration_version).returns(5)
+        @catalog.interpreter.stubs(:catalog_version).returns(5)
 
-        @configuration.version(@name).should == 5
+        @catalog.version(@name).should == 5
     end
 
     it "should return a version of 0 if no information on the node can be found" do
         Puppet::Node.stubs(:find_by_any_name).returns(nil)
-        @configuration.version(@name).should == 0
+        @catalog.version(@name).should == 0
     end
 
     it "should indicate when an update is available even if an input has clock skew" do
diff --git a/spec/unit/indirector/catalog/yaml.rb b/spec/unit/indirector/catalog/yaml.rb
new file mode 100755
index 000000000..717fb816c
--- /dev/null
+++ b/spec/unit/indirector/catalog/yaml.rb
@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/node/catalog'
+require 'puppet/indirector/catalog/yaml'
+
+describe Puppet::Node::Catalog::Yaml do
+    it "should be a subclass of the Yaml terminus" do
+        Puppet::Node::Catalog::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
+    end
+
+    it "should have documentation" do
+        Puppet::Node::Catalog::Yaml.doc.should_not be_nil
+    end
+
+    it "should be registered with the catalog store indirection" do
+        indirection = Puppet::Indirector::Indirection.instance(:catalog)
+        Puppet::Node::Catalog::Yaml.indirection.should equal(indirection)
+    end
+
+    it "should have its name set to :yaml" do
+        Puppet::Node::Catalog::Yaml.name.should == :yaml
+    end
+end
diff --git a/spec/unit/indirector/configuration/yaml.rb b/spec/unit/indirector/configuration/yaml.rb
deleted file mode 100755
index b9f3f40d1..000000000
--- a/spec/unit/indirector/configuration/yaml.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppet/node/configuration'
-require 'puppet/indirector/configuration/yaml'
-
-describe Puppet::Node::Configuration::Yaml do
-    it "should be a subclass of the Yaml terminus" do
-        Puppet::Node::Configuration::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
-    end
-
-    it "should have documentation" do
-        Puppet::Node::Configuration::Yaml.doc.should_not be_nil
-    end
-
-    it "should be registered with the configuration store indirection" do
-        indirection = Puppet::Indirector::Indirection.instance(:configuration)
-        Puppet::Node::Configuration::Yaml.indirection.should equal(indirection)
-    end
-
-    it "should have its name set to :yaml" do
-        Puppet::Node::Configuration::Yaml.name.should == :yaml
-    end
-end
diff --git a/spec/unit/network/client/master.rb b/spec/unit/network/client/master.rb
index dca923994..7bf755d88 100755
--- a/spec/unit/network/client/master.rb
+++ b/spec/unit/network/client/master.rb
@@ -6,7 +6,7 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'puppet/network/client/master'
 
-describe Puppet::Network::Client::Master, " when retrieving the configuration" do
+describe Puppet::Network::Client::Master, " when retrieving the catalog" do
     before do
         @master = mock 'master'
         @client = Puppet::Network::Client.master.new(
@@ -22,7 +22,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.getconfig
     end
 
-    it "should collect facts to use for configuration retrieval" do
+    it "should collect facts to use for catalog retrieval" do
         @client.stubs(:dostorage)
         @client.class.expects(:facts).returns(@facts)
         @master.stubs(:getconfig).returns(nil)
@@ -36,7 +36,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         proc { @client.getconfig }.should raise_error(Puppet::Network::ClientError)
     end
 
-    it "should use the cached configuration if it is up to date" do
+    it "should use the cached catalog if it is up to date" do
         file = "/path/to/cachefile"
         @client.stubs(:cachefile).returns(file)
         FileTest.expects(:exist?).with(file).returns(true)
@@ -48,7 +48,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.getconfig
     end
 
-    it "should log that the configuration does not need a recompile" do
+    it "should log that the catalog does not need a recompile" do
         file = "/path/to/cachefile"
         @client.stubs(:cachefile).returns(file)
         FileTest.stubs(:exist?).with(file).returns(true)
@@ -75,7 +75,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.getconfig
     end
 
-    it "should use the cached configuration if no configuration could be retrieved" do
+    it "should use the cached catalog if no catalog could be retrieved" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).raises(ArgumentError.new("whev"))
@@ -83,7 +83,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.getconfig
     end
 
-    it "should load the retrieved configuration using YAML" do
+    it "should load the retrieved catalog using YAML" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).returns("myconfig")
@@ -94,14 +94,14 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.stubs(:setclasses)
 
         config.stubs(:classes)
-        config.stubs(:to_configuration).returns(config)
+        config.stubs(:to_catalog).returns(config)
         config.stubs(:host_config=)
         config.stubs(:from_cache).returns(true)
 
         @client.getconfig
     end
 
-    it "should use the cached configuration if the retrieved configuration cannot be converted from YAML" do
+    it "should use the cached catalog if the retrieved catalog cannot be converted from YAML" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).returns("myconfig")
@@ -113,7 +113,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.getconfig
     end
 
-    it "should set the classes.txt file with the classes listed in the retrieved configuration" do
+    it "should set the classes.txt file with the classes listed in the retrieved catalog" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).returns("myconfig")
@@ -124,14 +124,14 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         config.expects(:classes).returns(:myclasses)
         @client.expects(:setclasses).with(:myclasses)
 
-        config.stubs(:to_configuration).returns(config)
+        config.stubs(:to_catalog).returns(config)
         config.stubs(:host_config=)
         config.stubs(:from_cache).returns(true)
 
         @client.getconfig
     end
 
-    it "should convert the retrieved configuration to a RAL configuration" do
+    it "should convert the retrieved catalog to a RAL catalog" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).returns("myconfig")
@@ -144,7 +144,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         config = mock 'config'
 
         yamlconfig.stubs(:classes)
-        yamlconfig.expects(:to_configuration).returns(config)
+        yamlconfig.expects(:to_catalog).returns(config)
 
         config.stubs(:host_config=)
         config.stubs(:from_cache).returns(true)
@@ -152,7 +152,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.getconfig
     end
 
-    it "should use the cached configuration if the retrieved configuration cannot be converted to a RAL configuration" do
+    it "should use the cached catalog if the retrieved catalog cannot be converted to a RAL catalog" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).returns("myconfig")
@@ -165,14 +165,14 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         config = mock 'config'
 
         yamlconfig.stubs(:classes)
-        yamlconfig.expects(:to_configuration).raises(ArgumentError)
+        yamlconfig.expects(:to_catalog).raises(ArgumentError)
 
         @client.expects(:use_cached_config).with(true)
 
         @client.getconfig
     end
 
-    it "should clear the failed configuration if using the cached configuration after failing to instantiate the retrieved configuration" do
+    it "should clear the failed catalog if using the cached catalog after failing to instantiate the retrieved catalog" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).returns("myconfig")
@@ -185,7 +185,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         config = mock 'config'
 
         yamlconfig.stubs(:classes)
-        yamlconfig.stubs(:to_configuration).raises(ArgumentError)
+        yamlconfig.stubs(:to_catalog).raises(ArgumentError)
 
         @client.stubs(:use_cached_config).with(true)
 
@@ -194,7 +194,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.getconfig
     end
 
-    it "should cache the retrieved yaml configuration if it is not from the cache and is valid" do
+    it "should cache the retrieved yaml catalog if it is not from the cache and is valid" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).returns("myconfig")
@@ -207,7 +207,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         config = mock 'config'
 
         yamlconfig.stubs(:classes)
-        yamlconfig.expects(:to_configuration).returns(config)
+        yamlconfig.expects(:to_catalog).returns(config)
 
         config.stubs(:host_config=)
 
@@ -218,7 +218,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         @client.getconfig
     end
 
-    it "should mark the configuration as a host configuration" do
+    it "should mark the catalog as a host catalog" do
         @client.stubs(:dostorage)
         @client.class.stubs(:facts).returns(@facts)
         @master.stubs(:getconfig).returns("myconfig")
@@ -231,7 +231,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
         config = mock 'config'
 
         yamlconfig.stubs(:classes)
-        yamlconfig.expects(:to_configuration).returns(config)
+        yamlconfig.expects(:to_catalog).returns(config)
 
         config.stubs(:from_cache).returns(true)
 
@@ -241,7 +241,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d
     end
 end
 
-describe Puppet::Network::Client::Master, " when using the cached configuration" do
+describe Puppet::Network::Client::Master, " when using the cached catalog" do
     before do
         @master = mock 'master'
         @client = Puppet::Network::Client.master.new(
@@ -250,8 +250,8 @@ describe Puppet::Network::Client::Master, " when using the cached configuration"
         @facts = {"one" => "two", "three" => "four"}
     end
 
-    it "should return do nothing and true if there is already an in-memory configuration" do
-        @client.configuration = :whatever
+    it "should return do nothing and true if there is already an in-memory catalog" do
+        @client.catalog = :whatever
         Puppet::Network::Client::Master.publicize_methods :use_cached_config do
             @client.use_cached_config.should be_true
         end
@@ -264,14 +264,14 @@ describe Puppet::Network::Client::Master, " when using the cached configuration"
         end
     end
 
-    it "should return false if no cached configuration can be found" do
+    it "should return false if no cached catalog can be found" do
         @client.expects(:retrievecache).returns(nil)
         Puppet::Network::Client::Master.publicize_methods :use_cached_config do
             @client.use_cached_config().should be_false
         end
     end
 
-    it "should return false if the cached configuration cannot be instantiated" do
+    it "should return false if the cached catalog cannot be instantiated" do
         YAML.expects(:load).raises(ArgumentError)
         @client.expects(:retrievecache).returns("whatever")
         Puppet::Network::Client::Master.publicize_methods :use_cached_config do
@@ -279,7 +279,7 @@ describe Puppet::Network::Client::Master, " when using the cached configuration"
         end
     end
 
-    it "should warn if the cached configuration cannot be instantiated" do
+    it "should warn if the cached catalog cannot be instantiated" do
         YAML.stubs(:load).raises(ArgumentError)
         @client.stubs(:retrievecache).returns("whatever")
         Puppet.expects(:warning).with { |m| m.include?("Could not load cache") }
@@ -288,7 +288,7 @@ describe Puppet::Network::Client::Master, " when using the cached configuration"
         end
     end
 
-    it "should clear the client if the cached configuration cannot be instantiated" do
+    it "should clear the client if the cached catalog cannot be instantiated" do
         YAML.stubs(:load).raises(ArgumentError)
         @client.stubs(:retrievecache).returns("whatever")
         @client.expects(:clear)
@@ -297,14 +297,14 @@ describe Puppet::Network::Client::Master, " when using the cached configuration"
         end
     end
 
-    it "should return true if the cached configuration can be instantiated" do
+    it "should return true if the cached catalog can be instantiated" do
         config = mock 'config'
         YAML.stubs(:load).returns(config)
 
         ral_config = mock 'ral config'
         ral_config.stubs(:from_cache=)
         ral_config.stubs(:host_config=)
-        config.expects(:to_configuration).returns(ral_config)
+        config.expects(:to_catalog).returns(ral_config)
 
         @client.stubs(:retrievecache).returns("whatever")
         Puppet::Network::Client::Master.publicize_methods :use_cached_config do
@@ -312,54 +312,54 @@ describe Puppet::Network::Client::Master, " when using the cached configuration"
         end
     end
 
-    it "should set the configuration instance variable if the cached configuration can be instantiated" do
+    it "should set the catalog instance variable if the cached catalog can be instantiated" do
         config = mock 'config'
         YAML.stubs(:load).returns(config)
 
         ral_config = mock 'ral config'
         ral_config.stubs(:from_cache=)
         ral_config.stubs(:host_config=)
-        config.expects(:to_configuration).returns(ral_config)
+        config.expects(:to_catalog).returns(ral_config)
 
         @client.stubs(:retrievecache).returns("whatever")
         Puppet::Network::Client::Master.publicize_methods :use_cached_config do
             @client.use_cached_config()
         end
 
-        @client.configuration.should equal(ral_config)
+        @client.catalog.should equal(ral_config)
     end
 
-    it "should mark the configuration as a host_config if valid" do
+    it "should mark the catalog as a host_config if valid" do
         config = mock 'config'
         YAML.stubs(:load).returns(config)
 
         ral_config = mock 'ral config'
         ral_config.stubs(:from_cache=)
         ral_config.expects(:host_config=).with(true)
-        config.expects(:to_configuration).returns(ral_config)
+        config.expects(:to_catalog).returns(ral_config)
 
         @client.stubs(:retrievecache).returns("whatever")
         Puppet::Network::Client::Master.publicize_methods :use_cached_config do
             @client.use_cached_config()
         end
 
-        @client.configuration.should equal(ral_config)
+        @client.catalog.should equal(ral_config)
     end
 
-    it "should mark the configuration as from the cache if valid" do
+    it "should mark the catalog as from the cache if valid" do
         config = mock 'config'
         YAML.stubs(:load).returns(config)
 
         ral_config = mock 'ral config'
         ral_config.expects(:from_cache=).with(true)
         ral_config.stubs(:host_config=)
-        config.expects(:to_configuration).returns(ral_config)
+        config.expects(:to_catalog).returns(ral_config)
 
         @client.stubs(:retrievecache).returns("whatever")
         Puppet::Network::Client::Master.publicize_methods :use_cached_config do
             @client.use_cached_config()
         end
 
-        @client.configuration.should equal(ral_config)
+        @client.catalog.should equal(ral_config)
     end
 end
diff --git a/spec/unit/network/http/mongrel.rb b/spec/unit/network/http/mongrel.rb
index b6ad07567..a39e7354a 100644
--- a/spec/unit/network/http/mongrel.rb
+++ b/spec/unit/network/http/mongrel.rb
@@ -23,7 +23,7 @@ describe Puppet::Network::HTTP::Mongrel, "when turning on listening" do
         @mock_mongrel.stubs(:run)
         @mock_mongrel.stubs(:register)
         Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
-        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :configuration ], :protocols => [ :rest, :xmlrpc ] }
+        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest, :xmlrpc ] }
     end
     
     it "should fail if already listening" do
@@ -102,7 +102,7 @@ describe Puppet::Network::HTTP::Mongrel, "when turning off listening" do
         @mock_mongrel.stubs(:register)
         Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
         @server = Puppet::Network::HTTP::Mongrel.new        
-        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :configuration ], :protocols => [ :rest, :xmlrpc ] }
+        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest, :xmlrpc ] }
     end
     
     it "should fail unless listening" do
diff --git a/spec/unit/network/http/webrick.rb b/spec/unit/network/http/webrick.rb
index 3ed223e7e..0689b1b6b 100644
--- a/spec/unit/network/http/webrick.rb
+++ b/spec/unit/network/http/webrick.rb
@@ -18,7 +18,7 @@ describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do
         [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}        
         WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
         @server = Puppet::Network::HTTP::WEBrick.new
-        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :configuration ], :protocols => [ :rest, :xmlrpc ] }
+        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest, :xmlrpc ] }
     end
     
     it "should fail if already listening" do
@@ -94,7 +94,7 @@ describe Puppet::Network::HTTP::WEBrick, "when turning off listening" do
         [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
         WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
         @server = Puppet::Network::HTTP::WEBrick.new        
-        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :configuration ], :protocols => [ :rest, :xmlrpc ] }
+        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest, :xmlrpc ] }
     end
     
     it "should fail unless listening" do
diff --git a/spec/unit/node/configuration.rb b/spec/unit/node/catalog.rb
index 0023e0f2b..a94ace68f 100755
--- a/spec/unit/node/configuration.rb
+++ b/spec/unit/node/catalog.rb
@@ -2,34 +2,34 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Puppet::Node::Configuration, " when compiling" do
+describe Puppet::Node::Catalog, " when compiling" do
     it "should accept tags" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
         config.tag("one")
         config.tags.should == %w{one}
     end
 
     it "should accept multiple tags at once" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
         config.tag("one", "two")
         config.tags.should == %w{one two}
     end
 
     it "should convert all tags to strings" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
         config.tag("one", :two)
         config.tags.should == %w{one two}
     end
 
     it "should tag with both the qualified name and the split name" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
         config.tag("one::two")
         config.tags.include?("one").should be_true
         config.tags.include?("one::two").should be_true
     end
 
     it "should accept classes" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
         config.add_class("one")
         config.classes.should == %w{one}
         config.add_class("two", "three")
@@ -37,22 +37,22 @@ describe Puppet::Node::Configuration, " when compiling" do
     end
 
     it "should tag itself with passed class names" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
         config.add_class("one")
         config.tags.should == %w{one}
     end
 end
 
-describe Puppet::Node::Configuration, " when extracting" do
+describe Puppet::Node::Catalog, " when extracting" do
     it "should return extraction result as the method result" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
         config.expects(:extraction_format).returns(:whatever)
         config.expects(:extract_to_whatever).returns(:result)
         config.extract.should == :result
     end
 end
 
-describe Puppet::Node::Configuration, " when extracting transobjects" do
+describe Puppet::Node::Catalog, " when extracting transobjects" do
 
     def mkscope
         @parser = Puppet::Parser::Parser.new :Code => ""
@@ -69,7 +69,7 @@ describe Puppet::Node::Configuration, " when extracting transobjects" do
     end
 
     it "should always create a TransBucket for the 'main' class" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @source = mock 'source'
@@ -87,7 +87,7 @@ describe Puppet::Node::Configuration, " when extracting transobjects" do
 
     # This isn't really a spec-style test, but I don't know how better to do it.
     it "should transform the resource graph into a tree of TransBuckets and TransObjects" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @source = mock 'source'
@@ -108,7 +108,7 @@ describe Puppet::Node::Configuration, " when extracting transobjects" do
 
     # Now try it with a more complicated graph -- a three tier graph, each tier
     it "should transform arbitrarily deep graphs into isomorphic trees" do
-        config = Puppet::Node::Configuration.new("mynode")
+        config = Puppet::Node::Catalog.new("mynode")
 
         @scope = mkscope
         @scope.stubs(:tags).returns([])
@@ -151,7 +151,7 @@ describe Puppet::Node::Configuration, " when extracting transobjects" do
     end
 end
 
-describe Puppet::Node::Configuration, " when converting to a transobject configuration" do
+describe Puppet::Node::Catalog, " when converting to a transobject catalog" do
     class TestResource
         attr_accessor :name, :virtual, :builtin
         def initialize(name, options = {})
@@ -181,7 +181,7 @@ describe Puppet::Node::Configuration, " when converting to a transobject configu
     end
 
     before do
-        @original = Puppet::Node::Configuration.new("mynode")
+        @original = Puppet::Node::Catalog.new("mynode")
         @original.tag(*%w{one two three})
         @original.add_class *%w{four five six}
 
@@ -219,11 +219,11 @@ describe Puppet::Node::Configuration, " when converting to a transobject configu
         @config.vertices.find { |v| v.name == "virtualobject" }.should be_nil
     end
 
-    it "should copy the tag list to the new configuration" do
+    it "should copy the tag list to the new catalog" do
         @config.tags.sort.should == @original.tags.sort
     end
 
-    it "should copy the class list to the new configuration" do
+    it "should copy the class list to the new catalog" do
         @config.classes.should == @original.classes
     end
 
@@ -239,14 +239,14 @@ describe Puppet::Node::Configuration, " when converting to a transobject configu
         end
     end
 
-    it "should set itself as the configuration for each converted resource" do
-        @config.vertices.each { |v| v.configuration.object_id.should equal(@config.object_id) }
+    it "should set itself as the catalog for each converted resource" do
+        @config.vertices.each { |v| v.catalog.object_id.should equal(@config.object_id) }
     end
 end
 
-describe Puppet::Node::Configuration, " when converting to a RAL configuration" do
+describe Puppet::Node::Catalog, " when converting to a RAL catalog" do
     before do
-        @original = Puppet::Node::Configuration.new("mynode")
+        @original = Puppet::Node::Catalog.new("mynode")
         @original.tag(*%w{one two three})
         @original.add_class *%w{four five six}
 
@@ -274,11 +274,11 @@ describe Puppet::Node::Configuration, " when converting to a RAL configuration"
         @resources.each { |resource| @config.resource(resource.ref).should be_instance_of(Puppet::Type) }
     end
 
-    it "should copy the tag list to the new configuration" do
+    it "should copy the tag list to the new catalog" do
         @config.tags.sort.should == @original.tags.sort
     end
 
-    it "should copy the class list to the new configuration" do
+    it "should copy the class list to the new catalog" do
         @config.classes.should == @original.classes
     end
 
@@ -288,21 +288,21 @@ describe Puppet::Node::Configuration, " when converting to a RAL configuration"
         end
     end
 
-    it "should set itself as the configuration for each converted resource" do
-        @config.vertices.each { |v| v.configuration.object_id.should equal(@config.object_id) }
+    it "should set itself as the catalog for each converted resource" do
+        @config.vertices.each { |v| v.catalog.object_id.should equal(@config.object_id) }
     end
 
     # This tests #931.
     it "should not lose track of resources whose names vary" do
         changer = Puppet::TransObject.new 'changer', 'test'
 
-        config = Puppet::Node::Configuration.new('test')
+        config = Puppet::Node::Catalog.new('test')
         config.add_resource(changer)
         config.add_resource(@top)
 
         config.add_edge!(@top, changer)
 
-        resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :configuration= => nil, :remove => nil
+        resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :catalog= => nil, :remove => nil
 
         changer.expects(:to_type).returns(resource)
 
@@ -320,12 +320,12 @@ describe Puppet::Node::Configuration, " when converting to a RAL configuration"
     end
 end
 
-describe Puppet::Node::Configuration, " when functioning as a resource container" do
+describe Puppet::Node::Catalog, " when functioning as a resource container" do
     before do
-        @config = Puppet::Node::Configuration.new("host")
-        @one = stub 'resource1', :ref => "Me[one]", :configuration= => nil
-        @two = stub 'resource2', :ref => "Me[two]", :configuration= => nil
-        @dupe = stub 'resource3', :ref => "Me[one]", :configuration= => nil
+        @config = Puppet::Node::Catalog.new("host")
+        @one = stub 'resource1', :ref => "Me[one]", :catalog= => nil
+        @two = stub 'resource2', :ref => "Me[two]", :catalog= => nil
+        @dupe = stub 'resource3', :ref => "Me[one]", :catalog= => nil
     end
 
     it "should provide a method to add one or more resources" do
@@ -334,13 +334,13 @@ describe Puppet::Node::Configuration, " when functioning as a resource container
         @config.resource(@two.ref).should equal(@two)
     end
 
-    it "should set itself as the resource's configuration if it is not a relationship graph" do
-        @one.expects(:configuration=).with(@config)
+    it "should set itself as the resource's catalog if it is not a relationship graph" do
+        @one.expects(:catalog=).with(@config)
         @config.add_resource @one
     end
 
-    it "should not set itself as the resource's configuration if it is a relationship graph" do
-        @one.expects(:configuration=).never
+    it "should not set itself as the resource's catalog if it is a relationship graph" do
+        @one.expects(:catalog=).never
         @config.is_relationship_graph = true
         @config.add_resource @one
     end
@@ -392,14 +392,14 @@ describe Puppet::Node::Configuration, " when functioning as a resource container
     it "should optionally support an initialization block and should finalize after such blocks" do
         @one.expects :finish
         @two.expects :finish
-        config = Puppet::Node::Configuration.new("host") do |conf|
+        config = Puppet::Node::Catalog.new("host") do |conf|
             conf.add_resource @one
             conf.add_resource @two
         end
     end
 
-    it "should inform the resource that it is the resource's configuration" do
-        @one.expects(:configuration=).with(@config)
+    it "should inform the resource that it is the resource's catalog" do
+        @one.expects(:catalog=).with(@config)
         @config.add_resource @one
     end
 
@@ -448,9 +448,9 @@ describe Puppet::Node::Configuration, " when functioning as a resource container
     end
 end
 
-module ApplyingConfigurations
+module ApplyingCatalogs
     def setup
-        @config = Puppet::Node::Configuration.new("host")
+        @config = Puppet::Node::Catalog.new("host")
 
         @config.retrieval_duration = Time.now
         @transaction = mock 'transaction'
@@ -461,15 +461,15 @@ module ApplyingConfigurations
     end
 end
 
-describe Puppet::Node::Configuration, " when applying" do
-    include ApplyingConfigurations
+describe Puppet::Node::Catalog, " when applying" do
+    include ApplyingCatalogs
 
     it "should create and evaluate a transaction" do
         @transaction.expects(:evaluate)
         @config.apply
     end
 
-    it "should provide the configuration time to the transaction" do
+    it "should provide the catalog time to the transaction" do
         @transaction.expects(:addtimes).with do |arg|
             arg[:config_retrieval].should be_instance_of(Time)
             true
@@ -492,7 +492,7 @@ describe Puppet::Node::Configuration, " when applying" do
         end
     end
     
-    it "should default to not being a host configuration" do
+    it "should default to not being a host catalog" do
         @config.host_config.should be_nil
     end
 
@@ -507,8 +507,8 @@ describe Puppet::Node::Configuration, " when applying" do
     end
 end
 
-describe Puppet::Node::Configuration, " when applying host configurations" do
-    include ApplyingConfigurations
+describe Puppet::Node::Catalog, " when applying host catalogs" do
+    include ApplyingCatalogs
 
     # super() doesn't work in the setup method for some reason
     before do
@@ -529,7 +529,7 @@ describe Puppet::Node::Configuration, " when applying host configurations" do
         @config.apply
     end
 
-    it "should initialize the state database before applying a configuration" do
+    it "should initialize the state database before applying a catalog" do
         Puppet::Util::Storage.expects(:load)
 
         # Short-circuit the apply, so we know we're loading before the transaction
@@ -546,8 +546,8 @@ describe Puppet::Node::Configuration, " when applying host configurations" do
     after { Puppet.settings.clear }
 end
 
-describe Puppet::Node::Configuration, " when applying non-host configurations" do
-    include ApplyingConfigurations
+describe Puppet::Node::Catalog, " when applying non-host catalogs" do
+    include ApplyingCatalogs
 
     before do
         @config.host_config = false
@@ -569,9 +569,9 @@ describe Puppet::Node::Configuration, " when applying non-host configurations" d
     after { Puppet.settings.clear }
 end
 
-describe Puppet::Node::Configuration, " when creating a relationship graph" do
+describe Puppet::Node::Catalog, " when creating a relationship graph" do
     before do
-        @config = Puppet::Node::Configuration.new("host")
+        @config = Puppet::Node::Catalog.new("host")
         @compone = Puppet::Type::Component.create :name => "one"
         @comptwo = Puppet::Type::Component.create :name => "two", :require => ["class", "one"]
         @file = Puppet::Type.type(:file)
@@ -592,11 +592,11 @@ describe Puppet::Node::Configuration, " when creating a relationship graph" do
     end
 
     it "should be able to create a relationship graph" do
-        @relationships.should be_instance_of(Puppet::Node::Configuration)
+        @relationships.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should copy its host_config setting to the relationship graph" do
-        config = Puppet::Node::Configuration.new
+        config = Puppet::Node::Catalog.new
         config.host_config = true
         config.relationship_graph.host_config.should be_true
     end
@@ -605,7 +605,7 @@ describe Puppet::Node::Configuration, " when creating a relationship graph" do
         @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil
     end
 
-    it "should have all non-component resources from the configuration" do
+    it "should have all non-component resources from the catalog" do
         # The failures print out too much info, so i just do a class comparison
         @relationships.vertex?(@five).should be_true
     end
@@ -618,7 +618,7 @@ describe Puppet::Node::Configuration, " when creating a relationship graph" do
         @relationships.edge?(@one, @two).should be_true
     end
 
-    it "should get removed when the configuration is cleaned up" do
+    it "should get removed when the catalog is cleaned up" do
         @relationships.expects(:clear).with(false)
         @config.clear
         @config.instance_variable_get("@relationship_graph").should be_nil
@@ -627,18 +627,18 @@ describe Puppet::Node::Configuration, " when creating a relationship graph" do
     it "should create a new relationship graph after clearing the old one" do
         @relationships.expects(:clear).with(false)
         @config.clear
-        @config.relationship_graph.should be_instance_of(Puppet::Node::Configuration)
+        @config.relationship_graph.should be_instance_of(Puppet::Node::Catalog)
     end
 
-    it "should look up resources in the relationship graph if not found in the main configuration" do
-        five = stub 'five', :ref => "File[five]", :configuration= => nil
+    it "should look up resources in the relationship graph if not found in the main catalog" do
+        five = stub 'five', :ref => "File[five]", :catalog= => nil
         @relationships.add_resource five
         @config.resource(five.ref).should equal(five)
     end
 
     it "should provide a method to create additional resources that also registers the resource" do
         args = {:name => "/yay", :ensure => :file}
-        resource = stub 'file', :ref => "File[/yay]", :configuration= => @config
+        resource = stub 'file', :ref => "File[/yay]", :catalog= => @config
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         @config.create_resource :file, args
         @config.resource("File[/yay]").should equal(resource)
@@ -646,7 +646,7 @@ describe Puppet::Node::Configuration, " when creating a relationship graph" do
 
     it "should provide a mechanism for creating implicit resources" do
         args = {:name => "/yay", :ensure => :file}
-        resource = stub 'file', :ref => "File[/yay]", :configuration= => @config
+        resource = stub 'file', :ref => "File[/yay]", :catalog= => @config
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         resource.expects(:implicit=).with(true)
         @config.create_implicit_resource :file, args
@@ -655,7 +655,7 @@ describe Puppet::Node::Configuration, " when creating a relationship graph" do
 
     it "should add implicit resources to the relationship graph if there is one" do
         args = {:name => "/yay", :ensure => :file}
-        resource = stub 'file', :ref => "File[/yay]", :configuration= => @config
+        resource = stub 'file', :ref => "File[/yay]", :catalog= => @config
         resource.expects(:implicit=).with(true)
         Puppet::Type.type(:file).expects(:create).with(args).returns(resource)
         # build the graph
@@ -667,7 +667,7 @@ describe Puppet::Node::Configuration, " when creating a relationship graph" do
 
     it "should remove resources created mid-transaction" do
         args = {:name => "/yay", :ensure => :file}
-        resource = stub 'file', :ref => "File[/yay]", :configuration= => @config
+        resource = stub 'file', :ref => "File[/yay]", :catalog= => @config
         @transaction = mock 'transaction'
         Puppet::Transaction.stubs(:new).returns(@transaction)
         @transaction.stubs(:evaluate)
@@ -692,13 +692,13 @@ describe Puppet::Node::Configuration, " when creating a relationship graph" do
     end
 end
 
-describe Puppet::Node::Configuration, " when writing dot files" do
+describe Puppet::Node::Catalog, " when writing dot files" do
     before do
-        @config = Puppet::Node::Configuration.new("host")
+        @config = Puppet::Node::Catalog.new("host")
         @name = :test
         @file = File.join(Puppet[:graphdir], @name.to_s + ".dot")
     end
-    it "should only write when it is a host configuration" do
+    it "should only write when it is a host catalog" do
         File.expects(:open).with(@file).never
         @config.host_config = false
         Puppet[:graph] = true
@@ -725,7 +725,7 @@ describe Puppet::Node::Configuration, " when writing dot files" do
     end
 end
 
-describe Puppet::Node::Configuration, " when indirecting" do
+describe Puppet::Node::Catalog, " when indirecting" do
     before do
         @indirection = mock 'indirection'
 
@@ -733,13 +733,13 @@ describe Puppet::Node::Configuration, " when indirecting" do
     end
 
     it "should redirect to the indirection for retrieval" do
-        Puppet::Node::Configuration.stubs(:indirection).returns(@indirection)
+        Puppet::Node::Catalog.stubs(:indirection).returns(@indirection)
         @indirection.expects(:find).with(:myconfig)
-        Puppet::Node::Configuration.find(:myconfig)
+        Puppet::Node::Catalog.find(:myconfig)
     end
 
     it "should default to the 'compiler' terminus" do
-        Puppet::Node::Configuration.indirection.terminus_class.should == :compiler
+        Puppet::Node::Catalog.indirection.terminus_class.should == :compiler
     end
 
     after do
@@ -748,36 +748,36 @@ describe Puppet::Node::Configuration, " when indirecting" do
     end
 end
 
-describe Puppet::Node::Configuration, " when converting to yaml" do
+describe Puppet::Node::Catalog, " when converting to yaml" do
     before do
-        @configuration = Puppet::Node::Configuration.new("me")
-        @configuration.add_edge!("one", "two")
+        @catalog = Puppet::Node::Catalog.new("me")
+        @catalog.add_edge!("one", "two")
     end
 
     it "should be able to be dumped to yaml" do
-        YAML.dump(@configuration).should be_instance_of(String)
+        YAML.dump(@catalog).should be_instance_of(String)
     end
 end
 
-describe Puppet::Node::Configuration, " when converting from yaml" do
+describe Puppet::Node::Catalog, " when converting from yaml" do
     before do
-        @configuration = Puppet::Node::Configuration.new("me")
-        @configuration.add_edge!("one", "two")
+        @catalog = Puppet::Node::Catalog.new("me")
+        @catalog.add_edge!("one", "two")
 
-        text = YAML.dump(@configuration)
-        @newconfig = YAML.load(text)
+        text = YAML.dump(@catalog)
+        @newcatalog = YAML.load(text)
     end
 
-    it "should get converted back to a configuration" do
-        @newconfig.should be_instance_of(Puppet::Node::Configuration)
+    it "should get converted back to a catalog" do
+        @newcatalog.should be_instance_of(Puppet::Node::Catalog)
     end
 
     it "should have all vertices" do
-        @newconfig.vertex?("one").should be_true
-        @newconfig.vertex?("two").should be_true
+        @newcatalog.vertex?("one").should be_true
+        @newcatalog.vertex?("two").should be_true
     end
 
     it "should have all edges" do
-        @newconfig.edge?("one", "two").should be_true
+        @newcatalog.edge?("one", "two").should be_true
     end
 end
diff --git a/spec/unit/other/transaction.rb b/spec/unit/other/transaction.rb
index 7990d2eef..d88f03005 100755
--- a/spec/unit/other/transaction.rb
+++ b/spec/unit/other/transaction.rb
@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Transaction, " when determining tags" do
     before do
-        @config = Puppet::Node::Configuration.new
+        @config = Puppet::Node::Catalog.new
         @transaction = Puppet::Transaction.new(@config)
     end
 
diff --git a/spec/unit/other/transbucket.rb b/spec/unit/other/transbucket.rb
index 84cf93fa4..3904e39fe 100755
--- a/spec/unit/other/transbucket.rb
+++ b/spec/unit/other/transbucket.rb
@@ -65,7 +65,7 @@ describe Puppet::TransBucket do
     end
 end
 
-describe Puppet::TransBucket, " when generating a configuration" do
+describe Puppet::TransBucket, " when generating a catalog" do
     before do
         @bottom = Puppet::TransBucket.new
         @bottom.type = "fake"
@@ -87,7 +87,7 @@ describe Puppet::TransBucket, " when generating a configuration" do
         @top.push(@topobj)
         @top.push(@middle)
 
-        @config = @top.to_configuration
+        @config = @top.to_catalog
 
         @users = %w{top middle bottom}
         @fakes = %w{Fake[bottom] Fake[middle] Fake[top]}
@@ -117,21 +117,21 @@ describe Puppet::TransBucket, " when generating a configuration" do
         @topobj.expects(:to_type)
         @bottomobj.expects(:to_type)
         Puppet::Type.allclear
-        @top.to_configuration
+        @top.to_catalog
     end
 
-    it "should set each TransObject's configuration before converting to a RAL resource" do
-        @middleobj.expects(:configuration=).with { |c| c.is_a?(Puppet::Node::Configuration) }
+    it "should set each TransObject's catalog before converting to a RAL resource" do
+        @middleobj.expects(:catalog=).with { |c| c.is_a?(Puppet::Node::Catalog) }
         Puppet::Type.allclear
-        @top.to_configuration
+        @top.to_catalog
     end
 
-    it "should set each TransBucket's configuration before converting to a RAL resource" do
+    it "should set each TransBucket's catalog before converting to a RAL resource" do
         # each bucket is seen twice in the loop, so we have to handle the case where the config
         # is set twice
-        @bottom.expects(:configuration=).with { |c| c.is_a?(Puppet::Node::Configuration) }.at_least_once
+        @bottom.expects(:catalog=).with { |c| c.is_a?(Puppet::Node::Catalog) }.at_least_once
         Puppet::Type.allclear
-        @top.to_configuration
+        @top.to_catalog
     end
 
     after do
diff --git a/spec/unit/parser/compile.rb b/spec/unit/parser/compile.rb
index 3be7d1637..2ae99b5fd 100755
--- a/spec/unit/parser/compile.rb
+++ b/spec/unit/parser/compile.rb
@@ -64,8 +64,8 @@ describe Puppet::Parser::Compile, " when evaluating classes" do
         proc { @compile.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
     end
 
-    it "should tag the configuration with the name of each not-found class" do
-        @compile.configuration.expects(:tag).with("notfound")
+    it "should tag the catalog with the name of each not-found class" do
+        @compile.catalog.expects(:tag).with("notfound")
         @scope.expects(:findclass).with("notfound").returns(nil)
         @compile.evaluate_classes(%w{notfound}, @scope)
     end
@@ -110,7 +110,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do
     end
 
     it "should create a resource for each found class" do
-        @compile.configuration.stubs(:tag)
+        @compile.catalog.stubs(:tag)
 
         @compile.stubs :store_resource
 
@@ -119,7 +119,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do
     end
 
     it "should store each created resource in the compile" do
-        @compile.configuration.stubs(:tag)
+        @compile.catalog.stubs(:tag)
 
         @compile.expects(:store_resource).with(@scope, @resource)
 
@@ -127,8 +127,8 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do
         @compile.evaluate_classes(%w{myclass}, @scope)
     end
 
-    it "should tag the configuration with the fully-qualified name of each found class" do
-        @compile.configuration.expects(:tag).with("my::class")
+    it "should tag the catalog with the fully-qualified name of each found class" do
+        @compile.catalog.expects(:tag).with("my::class")
 
         @compile.stubs(:store_resource)
 
@@ -137,7 +137,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do
     end
 
     it "should not evaluate the resources created for found classes unless asked" do
-        @compile.configuration.stubs(:tag)
+        @compile.catalog.stubs(:tag)
 
         @compile.stubs(:store_resource)
         @resource.expects(:evaluate).never
@@ -147,7 +147,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do
     end
 
     it "should immediately evaluate the resources created for found classes when asked" do
-        @compile.configuration.stubs(:tag)
+        @compile.catalog.stubs(:tag)
 
         @compile.stubs(:store_resource)
         @resource.expects(:evaluate)
@@ -157,7 +157,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do
     end
 
     it "should return the list of found classes" do
-        @compile.configuration.stubs(:tag)
+        @compile.catalog.stubs(:tag)
 
         @compile.stubs(:store_resource)
         @scope.stubs(:findclass).with("notfound").returns(nil)
@@ -227,14 +227,14 @@ describe Puppet::Parser::Compile, " when evaluating AST nodes with AST nodes pre
         @compile.send(:evaluate_ast_node)
     end
 
-    it "should tag the configuration with the found node name" do
+    it "should tag the catalog with the found node name" do
         node_class = stub 'node', :classname => "c"
         @nodes.stubs(:[]).with("c").returns(node_class)
 
         node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil
         Puppet::Parser::Resource.stubs(:new).returns(node_resource)
 
-        @compile.configuration.expects(:tag).with("c")
+        @compile.catalog.expects(:tag).with("c")
         @compile.send(:evaluate_ast_node)
     end
 
diff --git a/spec/unit/parser/interpreter.rb b/spec/unit/parser/interpreter.rb
index 782b30cc7..ed30ced93 100755
--- a/spec/unit/parser/interpreter.rb
+++ b/spec/unit/parser/interpreter.rb
@@ -111,7 +111,7 @@ describe Puppet::Parser::Interpreter, " when managing parser instances" do
     end
 end
 
-describe Puppet::Parser::Interpreter, " when compiling configurations" do
+describe Puppet::Parser::Interpreter, " when compiling catalog" do
     before do
         @interp = Puppet::Parser::Interpreter.new
         @node = stub 'node', :environment => :myenv
@@ -132,12 +132,12 @@ describe Puppet::Parser::Interpreter, " when compiling configurations" do
     end
 end
 
-describe Puppet::Parser::Interpreter, " when returning configuration version" do
+describe Puppet::Parser::Interpreter, " when returning catalog version" do
     before do
         @interp = Puppet::Parser::Interpreter.new
     end
 
-    it "should ask the appropriate parser for the configuration version" do
+    it "should ask the appropriate parser for the catalog version" do
         node = mock 'node'
         node.expects(:environment).returns(:myenv)
         parser = mock 'parser'
diff --git a/spec/unit/ral/type.rb b/spec/unit/ral/type.rb
index 60b99eeb8..25f8cbaf1 100755
--- a/spec/unit/ral/type.rb
+++ b/spec/unit/ral/type.rb
@@ -4,15 +4,15 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type, " when in a configuration" do
     before do
-        @configuration = Puppet::Node::Configuration.new
+        @catalog = Puppet::Node::Catalog.new
         @container = Puppet::Type.type(:component).create(:name => "container")
         @one = Puppet::Type.type(:file).create(:path => "/file/one")
         @two = Puppet::Type.type(:file).create(:path => "/file/two")
-        @configuration.add_resource @container
-        @configuration.add_resource @one
-        @configuration.add_resource @two
-        @configuration.add_edge! @container, @one
-        @configuration.add_edge! @container, @two
+        @catalog.add_resource @container
+        @catalog.add_resource @one
+        @catalog.add_resource @two
+        @catalog.add_edge! @container, @one
+        @catalog.add_edge! @container, @two
     end
 
     it "should have no parent if there is no in edge" do
@@ -24,6 +24,6 @@ describe Puppet::Type, " when in a configuration" do
     end
 
     after do
-        @configuration.clear(true)
+        @catalog.clear(true)
     end
 end
diff --git a/spec/unit/ral/types/package.rb b/spec/unit/ral/types/package.rb
index fd200c56f..f14a792b9 100755
--- a/spec/unit/ral/types/package.rb
+++ b/spec/unit/ral/types/package.rb
@@ -107,8 +107,8 @@ module PackageEvaluationTesting
         Puppet::Type::Package.defaultprovider.stubs(:new).returns(@provider)
         @package = Puppet::Type::Package.create(:name => "yay")
 
-        @configuration = Puppet::Node::Configuration.new
-        @configuration.add_resource(@package)
+        @catalog = Puppet::Node::Catalog.new
+        @catalog.add_resource(@package)
     end
 
     def setprops(properties)
@@ -116,7 +116,7 @@ module PackageEvaluationTesting
     end
 
     def teardown
-        @configuration.clear(true)
+        @catalog.clear(true)
         Puppet::Type::Package.clear
     end
 end
@@ -128,14 +128,14 @@ describe Puppet::Type::Package, "when it should be purged" do
 
     it "should do nothing if it is :purged" do
         @provider.expects(:properties).returns(:ensure => :purged)
-        @configuration.apply
+        @catalog.apply
     end
 
     [:absent, :installed, :present, :latest].each do |state|
         it "should purge if it is #{state.to_s}" do
             @provider.stubs(:properties).returns(:ensure => state)
             @provider.expects(:purge)
-            @configuration.apply
+            @catalog.apply
         end
     end
 end
@@ -148,7 +148,7 @@ describe Puppet::Type::Package, "when it should be absent" do
     [:purged, :absent].each do |state|
         it "should do nothing if it is #{state.to_s}" do
             @provider.expects(:properties).returns(:ensure => state)
-            @configuration.apply
+            @catalog.apply
         end
     end
 
@@ -156,7 +156,7 @@ describe Puppet::Type::Package, "when it should be absent" do
         it "should uninstall if it is #{state.to_s}" do
             @provider.stubs(:properties).returns(:ensure => state)
             @provider.expects(:uninstall)
-            @configuration.apply
+            @catalog.apply
         end
     end
 end
@@ -169,7 +169,7 @@ describe Puppet::Type::Package, "when it should be present" do
     [:present, :latest, "1.0"].each do |state|
         it "should do nothing if it is #{state.to_s}" do
             @provider.expects(:properties).returns(:ensure => state)
-            @configuration.apply
+            @catalog.apply
         end
     end
 
@@ -177,7 +177,7 @@ describe Puppet::Type::Package, "when it should be present" do
         it "should install if it is #{state.to_s}" do
             @provider.stubs(:properties).returns(:ensure => state)
             @provider.expects(:install)
-            @configuration.apply
+            @catalog.apply
         end
     end
 end
@@ -191,7 +191,7 @@ describe Puppet::Type::Package, "when it should be latest" do
         it "should upgrade if it is #{state.to_s}" do
             @provider.stubs(:properties).returns(:ensure => state)
             @provider.expects(:update)
-            @configuration.apply
+            @catalog.apply
         end
     end
 
@@ -199,21 +199,21 @@ describe Puppet::Type::Package, "when it should be latest" do
         @provider.stubs(:properties).returns(:ensure => "1.0")
         @provider.stubs(:latest).returns("2.0")
         @provider.expects(:update)
-        @configuration.apply
+        @catalog.apply
     end
 
     it "should do nothing if it is equal to the latest version" do
         @provider.stubs(:properties).returns(:ensure => "1.0")
         @provider.stubs(:latest).returns("1.0")
         @provider.expects(:update).never
-        @configuration.apply
+        @catalog.apply
     end
 
     it "should do nothing if the provider returns :present as the latest version" do
         @provider.stubs(:properties).returns(:ensure => :present)
         @provider.stubs(:latest).returns("1.0")
         @provider.expects(:update).never
-        @configuration.apply
+        @catalog.apply
     end
 end
 
@@ -226,19 +226,19 @@ describe Puppet::Type::Package, "when it should be a specific version" do
         it "should install if it is #{state.to_s}" do
             @provider.stubs(:properties).returns(:ensure => state)
             @provider.expects(:install)
-            @configuration.apply
+            @catalog.apply
         end
     end
 
     it "should do nothing if the current version is equal to the desired version" do
         @provider.stubs(:properties).returns(:ensure => "1.0")
         @provider.expects(:install).never
-        @configuration.apply
+        @catalog.apply
     end
 
     it "should install if the current version is not equal to the specified version" do
         @provider.stubs(:properties).returns(:ensure => "2.0")
         @provider.expects(:install)
-        @configuration.apply
+        @catalog.apply
     end
 end
diff --git a/spec/unit/resource_reference.rb b/spec/unit/resource_reference.rb
index 93eeaa5b8..ef172d80a 100755
--- a/spec/unit/resource_reference.rb
+++ b/spec/unit/resource_reference.rb
@@ -42,7 +42,7 @@ describe Puppet::ResourceReference do
     end
 end
 
-describe Puppet::ResourceReference, "when resolving resources without a configuration" do
+describe Puppet::ResourceReference, "when resolving resources without a catalog" do
     it "should be able to resolve builtin resources from their types" do
         Puppet::Type.type(:file).expects(:[]).with("myfile").returns(:myfile)
         Puppet::ResourceReference.new(:file, "myfile").resolve.should == :myfile
@@ -54,11 +54,11 @@ describe Puppet::ResourceReference, "when resolving resources without a configur
     end
 end
 
-describe Puppet::ResourceReference, "when resolving resources with a configuration" do
-    it "should resolve all resources using the configuration" do
-        config = mock 'configuration'
+describe Puppet::ResourceReference, "when resolving resources with a catalog" do
+    it "should resolve all resources using the catalog" do
+        config = mock 'catalog'
         ref = Puppet::ResourceReference.new("foo::bar", "yay")
-        ref.configuration = config
+        ref.catalog = config
 
         config.expects(:resource).with("Foo::Bar[yay]").returns(:myresource)
 
diff --git a/spec/unit/util/settings.rb b/spec/unit/util/settings.rb
index 5a0333798..540743d7e 100755
--- a/spec/unit/util/settings.rb
+++ b/spec/unit/util/settings.rb
@@ -485,7 +485,7 @@ describe Puppet::Util::Settings, " when being used to manage the host machine" d
         @trans = mock 'transaction'
 
         @settings.expects(:to_transportable).with(:whatever).returns(@bucket)
-        @bucket.expects(:to_configuration).returns(@config)
+        @bucket.expects(:to_catalog).returns(@config)
         @config.expects(:apply).yields(@trans)
         @config.stubs(:host_config=)
     end