From cb0c4eebb0a7b2fadc5e0487e1c692007cb8b2e5 Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Tue, 11 Dec 2007 15:35:36 -0600 Subject: Renaming 'configuration' to 'catalog', fixing #954. --- spec/unit/indirector/catalog/compiler.rb | 209 +++++++ spec/unit/indirector/catalog/yaml.rb | 25 + spec/unit/indirector/configuration/compiler.rb | 209 ------- spec/unit/indirector/configuration/yaml.rb | 25 - spec/unit/network/client/master.rb | 76 +-- spec/unit/network/http/mongrel.rb | 4 +- spec/unit/network/http/webrick.rb | 4 +- spec/unit/node/catalog.rb | 783 +++++++++++++++++++++++++ spec/unit/node/configuration.rb | 783 ------------------------- spec/unit/other/transaction.rb | 2 +- spec/unit/other/transbucket.rb | 18 +- spec/unit/parser/compile.rb | 22 +- spec/unit/parser/interpreter.rb | 6 +- spec/unit/ral/type.rb | 14 +- spec/unit/ral/types/package.rb | 32 +- spec/unit/resource_reference.rb | 10 +- spec/unit/util/settings.rb | 2 +- 17 files changed, 1112 insertions(+), 1112 deletions(-) create mode 100755 spec/unit/indirector/catalog/compiler.rb create mode 100755 spec/unit/indirector/catalog/yaml.rb delete mode 100755 spec/unit/indirector/configuration/compiler.rb delete mode 100755 spec/unit/indirector/configuration/yaml.rb create mode 100755 spec/unit/node/catalog.rb delete mode 100755 spec/unit/node/configuration.rb (limited to 'spec') diff --git a/spec/unit/indirector/catalog/compiler.rb b/spec/unit/indirector/catalog/compiler.rb new file mode 100755 index 000000000..77638a410 --- /dev/null +++ b/spec/unit/indirector/catalog/compiler.rb @@ -0,0 +1,209 @@ +#!/usr/bin/env ruby +# +# Created by Luke Kanies on 2007-9-23. +# Copyright (c) 2007. All rights reserved. + +require File.dirname(__FILE__) + '/../../../spec_helper' + +require 'puppet/indirector/catalog/compiler' + +describe Puppet::Node::Catalog::Compiler do + before do + Puppet.expects(:version).returns(1) + Facter.expects(:value).with('fqdn').returns("my.server.com") + Facter.expects(:value).with('ipaddress').returns("my.ip.address") + end + + it "should gather data about itself" do + Puppet::Node::Catalog::Compiler.new + end + + it "should cache the server metadata and reuse it" do + compiler = Puppet::Node::Catalog::Compiler.new + node1 = stub 'node1', :merge => nil + node2 = stub 'node2', :merge => nil + compiler.stubs(:compile) + Puppet::Node.stubs(:find_by_any_name).with('node1').returns(node1) + Puppet::Node.stubs(:find_by_any_name).with('node2').returns(node2) + + compiler.find('node1') + compiler.find('node2') + end + + 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::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::Catalog::Compiler.new + end + + it "should not create the interpreter until it is asked for the first time" do + interp = mock 'interp' + Puppet::Parser::Interpreter.expects(:new).with().returns(interp) + @compiler.interpreter.should equal(interp) + end + + it "should use the same interpreter for all compiles" do + interp = mock 'interp' + Puppet::Parser::Interpreter.expects(:new).with().returns(interp) + @compiler.interpreter.should equal(interp) + @compiler.interpreter.should equal(interp) + end +end + +describe Puppet::Node::Catalog::Compiler, " when finding nodes" do + before do + Facter.stubs(:value).returns("whatever") + @compiler = Puppet::Node::Catalog::Compiler.new + @name = "me" + @node = mock 'node' + @compiler.stubs(:compile) + end + + it "should look node information up via the Node class with the provided key" do + @node.stubs :merge + Puppet::Node.expects(:find_by_any_name).with(@name).returns(@node) + @compiler.find(@name) + end + + it "should fail if it cannot find the node" do + @node.stubs :merge + Puppet::Node.expects(:find_by_any_name).with(@name).returns(nil) + proc { @compiler.find(@name) }.should raise_error(Puppet::Error) + end +end + +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::Catalog::Compiler.new + @name = "me" + @node = mock 'node' + @compiler.stubs(:compile) + Puppet::Node.stubs(:find_by_any_name).with(@name).returns(@node) + end + + it "should add the server's Puppet version to the node's parameters as 'serverversion'" do + @node.expects(:merge).with { |args| args["serverversion"] == "1" } + @compiler.find(@name) + end + + it "should add the server's fqdn to the node's parameters as 'servername'" do + @node.expects(:merge).with { |args| args["servername"] == "my.server.com" } + @compiler.find(@name) + end + + it "should add the server's IP address to the node's parameters as 'serverip'" do + @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" } + @compiler.find(@name) + end + + # LAK:TODO This is going to be difficult, because this whole process is so + # far removed from the actual connection that the certificate information + # will be quite hard to come by, dum by, gum by. + it "should search for the name using the client certificate's DN if the :node_name setting is set to 'cert'" do + pending "Probably will end up in the REST work" + end +end + +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::Catalog::Compiler.new + @name = "me" + @node = Puppet::Node.new @name + @node.stubs(:merge) + Puppet::Node.stubs(:find_by_any_name).with(@name).returns(@node) + end + + it "should directly use provided nodes" do + Puppet::Node.expects(:find_by_any_name).never + @compiler.interpreter.expects(:compile).with(@node) + @compiler.find(@node) + end + + it "should pass the found node to the interpreter for compiling" do + config = mock 'config' + @compiler.interpreter.expects(:compile).with(@node) + @compiler.find(@name) + end + + it "should return the results of compiling as the catalog" do + config = mock 'config' + result = mock 'result', :to_transportable => :catalog + + @compiler.interpreter.expects(:compile).with(@node).returns(result) + @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 catalog/ + end + @compiler.interpreter.stubs(:compile).with(@node) + @compiler.find(@name) + end +end + +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") + @catalog = Puppet::Node::Catalog::Compiler.new + @name = "johnny" + end + + 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 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) + @catalog.interpreter.stubs(:catalog_version).returns(4) + + @catalog.version(@name).should == 5 + end + + 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) + @catalog.interpreter.stubs(:catalog_version).returns(4) + + @catalog.version(@name).should == 5 + end + + 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) + @catalog.interpreter.stubs(:catalog_version).returns(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) + @catalog.version(@name).should == 0 + end + + it "should indicate when an update is available even if an input has clock skew" do + pending "Unclear how to implement this" + end + + it "should not indicate an available update when apparent updates are a result of clock skew" do + pending "Unclear how to implement this" + end +end 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/compiler.rb b/spec/unit/indirector/configuration/compiler.rb deleted file mode 100755 index d949a28a5..000000000 --- a/spec/unit/indirector/configuration/compiler.rb +++ /dev/null @@ -1,209 +0,0 @@ -#!/usr/bin/env ruby -# -# Created by Luke Kanies on 2007-9-23. -# Copyright (c) 2007. All rights reserved. - -require File.dirname(__FILE__) + '/../../../spec_helper' - -require 'puppet/indirector/configuration/compiler' - -describe Puppet::Node::Configuration::Compiler do - before do - Puppet.expects(:version).returns(1) - Facter.expects(:value).with('fqdn').returns("my.server.com") - Facter.expects(:value).with('ipaddress').returns("my.ip.address") - end - - it "should gather data about itself" do - Puppet::Node::Configuration::Compiler.new - end - - it "should cache the server metadata and reuse it" do - compiler = Puppet::Node::Configuration::Compiler.new - node1 = stub 'node1', :merge => nil - node2 = stub 'node2', :merge => nil - compiler.stubs(:compile) - Puppet::Node.stubs(:find_by_any_name).with('node1').returns(node1) - Puppet::Node.stubs(:find_by_any_name).with('node2').returns(node2) - - compiler.find('node1') - compiler.find('node2') - end - - it "should provide a method for determining if the configuration is networked" do - compiler = Puppet::Node::Configuration::Compiler.new - compiler.should respond_to(:networked?) - end -end - -describe Puppet::Node::Configuration::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 - end - - it "should not create the interpreter until it is asked for the first time" do - interp = mock 'interp' - Puppet::Parser::Interpreter.expects(:new).with().returns(interp) - @compiler.interpreter.should equal(interp) - end - - it "should use the same interpreter for all compiles" do - interp = mock 'interp' - Puppet::Parser::Interpreter.expects(:new).with().returns(interp) - @compiler.interpreter.should equal(interp) - @compiler.interpreter.should equal(interp) - end -end - -describe Puppet::Node::Configuration::Compiler, " when finding nodes" do - before do - Facter.stubs(:value).returns("whatever") - @compiler = Puppet::Node::Configuration::Compiler.new - @name = "me" - @node = mock 'node' - @compiler.stubs(:compile) - end - - it "should look node information up via the Node class with the provided key" do - @node.stubs :merge - Puppet::Node.expects(:find_by_any_name).with(@name).returns(@node) - @compiler.find(@name) - end - - it "should fail if it cannot find the node" do - @node.stubs :merge - Puppet::Node.expects(:find_by_any_name).with(@name).returns(nil) - proc { @compiler.find(@name) }.should raise_error(Puppet::Error) - end -end - -describe Puppet::Node::Configuration::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 - @name = "me" - @node = mock 'node' - @compiler.stubs(:compile) - Puppet::Node.stubs(:find_by_any_name).with(@name).returns(@node) - end - - it "should add the server's Puppet version to the node's parameters as 'serverversion'" do - @node.expects(:merge).with { |args| args["serverversion"] == "1" } - @compiler.find(@name) - end - - it "should add the server's fqdn to the node's parameters as 'servername'" do - @node.expects(:merge).with { |args| args["servername"] == "my.server.com" } - @compiler.find(@name) - end - - it "should add the server's IP address to the node's parameters as 'serverip'" do - @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" } - @compiler.find(@name) - end - - # LAK:TODO This is going to be difficult, because this whole process is so - # far removed from the actual connection that the certificate information - # will be quite hard to come by, dum by, gum by. - it "should search for the name using the client certificate's DN if the :node_name setting is set to 'cert'" do - pending "Probably will end up in the REST work" - end -end - -describe Puppet::Node::Configuration::Compiler, " when creating configurations" 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 - @name = "me" - @node = Puppet::Node.new @name - @node.stubs(:merge) - Puppet::Node.stubs(:find_by_any_name).with(@name).returns(@node) - end - - it "should directly use provided nodes" do - Puppet::Node.expects(:find_by_any_name).never - @compiler.interpreter.expects(:compile).with(@node) - @compiler.find(@node) - end - - it "should pass the found node to the interpreter for compiling" do - config = mock 'config' - @compiler.interpreter.expects(:compile).with(@node) - @compiler.find(@name) - end - - it "should return the results of compiling as the configuration" do - config = mock 'config' - result = mock 'result', :to_transportable => :configuration - - @compiler.interpreter.expects(:compile).with(@node).returns(result) - @compiler.find(@name).should == :configuration - 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/ - 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 - before do - Puppet::Node::Facts.stubs(:find).returns(nil) - Facter.stubs(:value).returns("whatever") - @configuration = Puppet::Node::Configuration::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) - end - - it "should use the client's Facts version as the available configuration 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) - - @configuration.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 - Puppet::Node::Facts.expects(:version).with(@name).returns(3) - Puppet::Node.expects(:version).with(@name).returns(5) - @configuration.interpreter.stubs(:configuration_version).returns(4) - - @configuration.version(@name).should == 5 - end - - it "should use the last parse date as the available configuration 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) - - @configuration.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 - end - - it "should indicate when an update is available even if an input has clock skew" do - pending "Unclear how to implement this" - end - - it "should not indicate an available update when apparent updates are a result of clock skew" do - pending "Unclear how to implement this" - 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/catalog.rb b/spec/unit/node/catalog.rb new file mode 100755 index 000000000..a94ace68f --- /dev/null +++ b/spec/unit/node/catalog.rb @@ -0,0 +1,783 @@ +#!/usr/bin/env ruby + +require File.dirname(__FILE__) + '/../../spec_helper' + +describe Puppet::Node::Catalog, " when compiling" do + it "should accept tags" do + 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::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::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::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::Catalog.new("mynode") + config.add_class("one") + config.classes.should == %w{one} + config.add_class("two", "three") + config.classes.should == %w{one two three} + end + + it "should tag itself with passed class names" do + config = Puppet::Node::Catalog.new("mynode") + config.add_class("one") + config.tags.should == %w{one} + end +end + +describe Puppet::Node::Catalog, " when extracting" do + it "should return extraction result as the method result" do + 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::Catalog, " when extracting transobjects" do + + def mkscope + @parser = Puppet::Parser::Parser.new :Code => "" + @node = Puppet::Node.new("mynode") + @compile = Puppet::Parser::Compile.new(@node, @parser) + + # XXX This is ridiculous. + @compile.send(:evaluate_main) + @scope = @compile.topscope + end + + def mkresource(type, name) + Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope) + end + + it "should always create a TransBucket for the 'main' class" do + config = Puppet::Node::Catalog.new("mynode") + + @scope = mkscope + @source = mock 'source' + + main = mkresource("class", :main) + config.add_vertex!(main) + + bucket = mock 'bucket' + bucket.expects(:classes=).with(config.classes) + main.stubs(:builtin?).returns(false) + main.expects(:to_transbucket).returns(bucket) + + config.extract_to_transportable.should equal(bucket) + end + + # 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::Catalog.new("mynode") + + @scope = mkscope + @source = mock 'source' + + defined = mkresource("class", :main) + builtin = mkresource("file", "/yay") + + config.add_edge!(defined, builtin) + + bucket = [] + bucket.expects(:classes=).with(config.classes) + defined.stubs(:builtin?).returns(false) + defined.expects(:to_transbucket).returns(bucket) + builtin.expects(:to_transobject).returns(:builtin) + + config.extract_to_transportable.should == [:builtin] + end + + # 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::Catalog.new("mynode") + + @scope = mkscope + @scope.stubs(:tags).returns([]) + @source = mock 'source' + + # Create our scopes. + top = mkresource "class", :main + topbucket = [] + topbucket.expects(:classes=).with([]) + top.expects(:to_trans).returns(topbucket) + topres = mkresource "file", "/top" + topres.expects(:to_trans).returns(:topres) + config.add_edge! top, topres + + middle = mkresource "class", "middle" + middle.expects(:to_trans).returns([]) + config.add_edge! top, middle + midres = mkresource "file", "/mid" + midres.expects(:to_trans).returns(:midres) + config.add_edge! middle, midres + + bottom = mkresource "class", "bottom" + bottom.expects(:to_trans).returns([]) + config.add_edge! middle, bottom + botres = mkresource "file", "/bot" + botres.expects(:to_trans).returns(:botres) + config.add_edge! bottom, botres + + toparray = config.extract_to_transportable + + # This is annoying; it should look like: + # [[[:botres], :midres], :topres] + # but we can't guarantee sort order. + toparray.include?(:topres).should be_true + + midarray = toparray.find { |t| t.is_a?(Array) } + midarray.include?(:midres).should be_true + botarray = midarray.find { |t| t.is_a?(Array) } + botarray.include?(:botres).should be_true + end +end + +describe Puppet::Node::Catalog, " when converting to a transobject catalog" do + class TestResource + attr_accessor :name, :virtual, :builtin + def initialize(name, options = {}) + @name = name + options.each { |p,v| send(p.to_s + "=", v) } + end + + def ref + if builtin? + "File[%s]" % name + else + "Class[%s]" % name + end + end + + def virtual? + virtual + end + + def builtin? + builtin + end + + def to_transobject + Puppet::TransObject.new(name, builtin? ? "file" : "class") + end + end + + before do + @original = Puppet::Node::Catalog.new("mynode") + @original.tag(*%w{one two three}) + @original.add_class *%w{four five six} + + @top = TestResource.new 'top' + @topobject = TestResource.new 'topobject', :builtin => true + @virtual = TestResource.new 'virtual', :virtual => true + @virtualobject = TestResource.new 'virtualobject', :builtin => true, :virtual => true + @middle = TestResource.new 'middle' + @middleobject = TestResource.new 'middleobject', :builtin => true + @bottom = TestResource.new 'bottom' + @bottomobject = TestResource.new 'bottomobject', :builtin => true + + @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject] + + @original.add_edge!(@top, @topobject) + @original.add_edge!(@top, @virtual) + @original.add_edge!(@virtual, @virtualobject) + @original.add_edge!(@top, @middle) + @original.add_edge!(@middle, @middleobject) + @original.add_edge!(@middle, @bottom) + @original.add_edge!(@bottom, @bottomobject) + + @config = @original.to_transportable + end + + it "should add all resources as TransObjects" do + @resources.each { |resource| @config.resource(resource.ref).should be_instance_of(Puppet::TransObject) } + end + + it "should not extract defined virtual resources" do + @config.vertices.find { |v| v.name == "virtual" }.should be_nil + end + + it "should not extract builtin virtual resources" do + @config.vertices.find { |v| v.name == "virtualobject" }.should be_nil + end + + 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 catalog" do + @config.classes.should == @original.classes + end + + it "should duplicate the original edges" do + @original.edges.each do |edge| + next if edge.source.virtual? or edge.target.virtual? + source = @config.resource(edge.source.ref) + target = @config.resource(edge.target.ref) + + source.should_not be_nil + target.should_not be_nil + @config.edge?(source, target).should be_true + end + end + + 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::Catalog, " when converting to a RAL catalog" do + before do + @original = Puppet::Node::Catalog.new("mynode") + @original.tag(*%w{one two three}) + @original.add_class *%w{four five six} + + @top = Puppet::TransObject.new 'top', "class" + @topobject = Puppet::TransObject.new '/topobject', "file" + @middle = Puppet::TransObject.new 'middle', "class" + @middleobject = Puppet::TransObject.new '/middleobject', "file" + @bottom = Puppet::TransObject.new 'bottom', "class" + @bottomobject = Puppet::TransObject.new '/bottomobject', "file" + + @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject] + + @original.add_resource(*@resources) + + @original.add_edge!(@top, @topobject) + @original.add_edge!(@top, @middle) + @original.add_edge!(@middle, @middleobject) + @original.add_edge!(@middle, @bottom) + @original.add_edge!(@bottom, @bottomobject) + + @config = @original.to_ral + end + + it "should add all resources as RAL instances" do + @resources.each { |resource| @config.resource(resource.ref).should be_instance_of(Puppet::Type) } + end + + 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 catalog" do + @config.classes.should == @original.classes + end + + it "should duplicate the original edges" do + @original.edges.each do |edge| + @config.edge?(@config.resource(edge.source.ref), @config.resource(edge.target.ref)).should be_true + end + end + + 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::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]", :catalog= => nil, :remove => nil + + changer.expects(:to_type).returns(resource) + + newconfig = nil + + Puppet::Type.allclear + + proc { @config = config.to_ral }.should_not raise_error + @config.resource("Test[changer2]").should equal(resource) + end + + after do + # Remove all resource instances. + @config.clear(true) + end +end + +describe Puppet::Node::Catalog, " when functioning as a resource container" do + before do + @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 + @config.add_resource @one, @two + @config.resource(@one.ref).should equal(@one) + @config.resource(@two.ref).should equal(@two) + end + + 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 catalog if it is a relationship graph" do + @one.expects(:catalog=).never + @config.is_relationship_graph = true + @config.add_resource @one + end + + it "should make all vertices available by resource reference" do + @config.add_resource(@one) + @config.resource(@one.ref).should equal(@one) + @config.vertices.find { |r| r.ref == @one.ref }.should equal(@one) + end + + it "should canonize how resources are referred to during retrieval when both type and title are provided" do + @config.add_resource(@one) + + @config.resource("me", "one").should equal(@one) + end + + it "should canonize how resources are referred to during retrieval when just the title is provided" do + @config.add_resource(@one) + + @config.resource("me[one]", nil).should equal(@one) + end + + it "should not allow two resources with the same resource reference" do + @config.add_resource(@one) + proc { @config.add_resource(@dupe) }.should raise_error(ArgumentError) + end + + it "should not store objects that do not respond to :ref" do + proc { @config.add_resource("thing") }.should raise_error(ArgumentError) + end + + it "should remove all resources when asked" do + @config.add_resource @one + @config.add_resource @two + @one.expects :remove + @two.expects :remove + @config.clear(true) + end + + it "should support a mechanism for finishing resources" do + @one.expects :finish + @two.expects :finish + @config.add_resource @one + @config.add_resource @two + + @config.finalize + end + + it "should optionally support an initialization block and should finalize after such blocks" do + @one.expects :finish + @two.expects :finish + 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 catalog" do + @one.expects(:catalog=).with(@config) + @config.add_resource @one + end + + it "should be able to find resources by reference" do + @config.add_resource @one + @config.resource(@one.ref).should equal(@one) + end + + it "should be able to find resources by reference or by type/title tuple" do + @config.add_resource @one + @config.resource("me", "one").should equal(@one) + end + + it "should have a mechanism for removing resources" do + @config.add_resource @one + @one.expects :remove + @config.remove_resource(@one) + @config.resource(@one.ref).should be_nil + @config.vertex?(@one).should be_false + end + + it "should have a method for creating aliases for resources" do + @config.add_resource @one + @config.alias(@one, "other") + @config.resource("me", "other").should equal(@one) + end + + # This test is the same as the previous, but the behaviour should be explicit. + it "should alias using the class name from the resource reference, not the resource class name" do + @config.add_resource @one + @config.alias(@one, "other") + @config.resource("me", "other").should equal(@one) + end + + it "should fail to add an alias if the aliased name already exists" do + @config.add_resource @one + proc { @config.alias @two, "one" }.should raise_error(ArgumentError) + end + + it "should remove resource aliases when the target resource is removed" do + @config.add_resource @one + @config.alias(@one, "other") + @one.expects :remove + @config.remove_resource(@one) + @config.resource("me", "other").should be_nil + end +end + +module ApplyingCatalogs + def setup + @config = Puppet::Node::Catalog.new("host") + + @config.retrieval_duration = Time.now + @transaction = mock 'transaction' + Puppet::Transaction.stubs(:new).returns(@transaction) + @transaction.stubs(:evaluate) + @transaction.stubs(:cleanup) + @transaction.stubs(:addtimes) + end +end + +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 catalog time to the transaction" do + @transaction.expects(:addtimes).with do |arg| + arg[:config_retrieval].should be_instance_of(Time) + true + end + @config.apply + end + + it "should clean up the transaction" do + @transaction.expects :cleanup + @config.apply + end + + it "should return the transaction" do + @config.apply.should equal(@transaction) + end + + it "should yield the transaction if a block is provided" do + @config.apply do |trans| + trans.should equal(@transaction) + end + end + + it "should default to not being a host catalog" do + @config.host_config.should be_nil + end + + it "should pass supplied tags on to the transaction" do + @transaction.expects(:tags=).with(%w{one two}) + @config.apply(:tags => %w{one two}) + end + + it "should set ignoreschedules on the transaction if specified in apply()" do + @transaction.expects(:ignoreschedules=).with(true) + @config.apply(:ignoreschedules => true) + end +end + +describe Puppet::Node::Catalog, " when applying host catalogs" do + include ApplyingCatalogs + + # super() doesn't work in the setup method for some reason + before do + @config.host_config = true + end + + it "should send a report if reporting is enabled" do + Puppet[:report] = true + @transaction.expects :send_report + @transaction.stubs :any_failed? => false + @config.apply + end + + it "should send a report if report summaries are enabled" do + Puppet[:summarize] = true + @transaction.expects :send_report + @transaction.stubs :any_failed? => false + @config.apply + end + + 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 + Puppet::Transaction.expects(:new).raises ArgumentError + proc { @config.apply }.should raise_error(ArgumentError) + end + + it "should sync the state database after applying" do + Puppet::Util::Storage.expects(:store) + @transaction.stubs :any_failed? => false + @config.apply + end + + after { Puppet.settings.clear } +end + +describe Puppet::Node::Catalog, " when applying non-host catalogs" do + include ApplyingCatalogs + + before do + @config.host_config = false + end + + it "should never send reports" do + Puppet[:report] = true + Puppet[:summarize] = true + @transaction.expects(:send_report).never + @config.apply + end + + it "should never modify the state database" do + Puppet::Util::Storage.expects(:load).never + Puppet::Util::Storage.expects(:store).never + @config.apply + end + + after { Puppet.settings.clear } +end + +describe Puppet::Node::Catalog, " when creating a relationship graph" do + before do + @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) + @one = @file.create :path => "/one" + @two = @file.create :path => "/two" + @config.add_edge! @compone, @one + @config.add_edge! @comptwo, @two + + @three = @file.create :path => "/three" + @four = @file.create :path => "/four", :require => ["file", "/three"] + @five = @file.create :path => "/five" + @config.add_resource @compone, @comptwo, @one, @two, @three, @four, @five + @relationships = @config.relationship_graph + end + + it "should fail when trying to create a relationship graph for a relationship graph" do + proc { @relationships.relationship_graph }.should raise_error(Puppet::DevError) + end + + it "should be able to create a relationship graph" do + @relationships.should be_instance_of(Puppet::Node::Catalog) + end + + it "should copy its host_config setting to the relationship graph" do + config = Puppet::Node::Catalog.new + config.host_config = true + config.relationship_graph.host_config.should be_true + end + + it "should not have any components" do + @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil + end + + 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 + + it "should have all resource relationships set as edges" do + @relationships.edge?(@three, @four).should be_true + end + + it "should copy component relationships to all contained resources" do + @relationships.edge?(@one, @two).should be_true + end + + 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 + end + + 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::Catalog) + end + + 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]", :catalog= => @config + Puppet::Type.type(:file).expects(:create).with(args).returns(resource) + @config.create_resource :file, args + @config.resource("File[/yay]").should equal(resource) + end + + it "should provide a mechanism for creating implicit resources" do + args = {:name => "/yay", :ensure => :file} + 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 + @config.resource("File[/yay]").should equal(resource) + end + + 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]", :catalog= => @config + resource.expects(:implicit=).with(true) + Puppet::Type.type(:file).expects(:create).with(args).returns(resource) + # build the graph + relgraph = @config.relationship_graph + + @config.create_implicit_resource :file, args + relgraph.resource("File[/yay]").should equal(resource) + end + + it "should remove resources created mid-transaction" do + args = {:name => "/yay", :ensure => :file} + resource = stub 'file', :ref => "File[/yay]", :catalog= => @config + @transaction = mock 'transaction' + Puppet::Transaction.stubs(:new).returns(@transaction) + @transaction.stubs(:evaluate) + @transaction.stubs(:cleanup) + @transaction.stubs(:addtimes) + Puppet::Type.type(:file).expects(:create).with(args).returns(resource) + resource.expects :remove + @config.apply do |trans| + @config.create_resource :file, args + @config.resource("File[/yay]").should equal(resource) + end + @config.resource("File[/yay]").should be_nil + end + + it "should remove resources from the relationship graph if it exists" do + @config.remove_resource(@one) + @config.relationship_graph.vertex?(@one).should be_false + end + + after do + Puppet::Type.allclear + end +end + +describe Puppet::Node::Catalog, " when writing dot files" do + before do + @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 catalog" do + File.expects(:open).with(@file).never + @config.host_config = false + Puppet[:graph] = true + @config.write_graph(@name) + end + + it "should only write when graphing is enabled" do + File.expects(:open).with(@file).never + @config.host_config = true + Puppet[:graph] = false + @config.write_graph(@name) + end + + it "should write a dot file based on the passed name" do + File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil)) + @config.expects(:to_dot).with("name" => @name.to_s.capitalize) + @config.host_config = true + Puppet[:graph] = true + @config.write_graph(@name) + end + + after do + Puppet.settings.clear + end +end + +describe Puppet::Node::Catalog, " when indirecting" do + before do + @indirection = mock 'indirection' + + Puppet::Indirector::Indirection.clear_cache + end + + it "should redirect to the indirection for retrieval" do + Puppet::Node::Catalog.stubs(:indirection).returns(@indirection) + @indirection.expects(:find).with(:myconfig) + Puppet::Node::Catalog.find(:myconfig) + end + + it "should default to the 'compiler' terminus" do + Puppet::Node::Catalog.indirection.terminus_class.should == :compiler + end + + after do + mocha_verify + Puppet::Indirector::Indirection.clear_cache + end +end + +describe Puppet::Node::Catalog, " when converting to yaml" do + before do + @catalog = Puppet::Node::Catalog.new("me") + @catalog.add_edge!("one", "two") + end + + it "should be able to be dumped to yaml" do + YAML.dump(@catalog).should be_instance_of(String) + end +end + +describe Puppet::Node::Catalog, " when converting from yaml" do + before do + @catalog = Puppet::Node::Catalog.new("me") + @catalog.add_edge!("one", "two") + + text = YAML.dump(@catalog) + @newcatalog = YAML.load(text) + end + + it "should get converted back to a catalog" do + @newcatalog.should be_instance_of(Puppet::Node::Catalog) + end + + it "should have all vertices" do + @newcatalog.vertex?("one").should be_true + @newcatalog.vertex?("two").should be_true + end + + it "should have all edges" do + @newcatalog.edge?("one", "two").should be_true + end +end diff --git a/spec/unit/node/configuration.rb b/spec/unit/node/configuration.rb deleted file mode 100755 index 0023e0f2b..000000000 --- a/spec/unit/node/configuration.rb +++ /dev/null @@ -1,783 +0,0 @@ -#!/usr/bin/env ruby - -require File.dirname(__FILE__) + '/../../spec_helper' - -describe Puppet::Node::Configuration, " when compiling" do - it "should accept tags" do - config = Puppet::Node::Configuration.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.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.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.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.add_class("one") - config.classes.should == %w{one} - config.add_class("two", "three") - config.classes.should == %w{one two three} - end - - it "should tag itself with passed class names" do - config = Puppet::Node::Configuration.new("mynode") - config.add_class("one") - config.tags.should == %w{one} - end -end - -describe Puppet::Node::Configuration, " when extracting" do - it "should return extraction result as the method result" do - config = Puppet::Node::Configuration.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 - - def mkscope - @parser = Puppet::Parser::Parser.new :Code => "" - @node = Puppet::Node.new("mynode") - @compile = Puppet::Parser::Compile.new(@node, @parser) - - # XXX This is ridiculous. - @compile.send(:evaluate_main) - @scope = @compile.topscope - end - - def mkresource(type, name) - Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope) - end - - it "should always create a TransBucket for the 'main' class" do - config = Puppet::Node::Configuration.new("mynode") - - @scope = mkscope - @source = mock 'source' - - main = mkresource("class", :main) - config.add_vertex!(main) - - bucket = mock 'bucket' - bucket.expects(:classes=).with(config.classes) - main.stubs(:builtin?).returns(false) - main.expects(:to_transbucket).returns(bucket) - - config.extract_to_transportable.should equal(bucket) - end - - # 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") - - @scope = mkscope - @source = mock 'source' - - defined = mkresource("class", :main) - builtin = mkresource("file", "/yay") - - config.add_edge!(defined, builtin) - - bucket = [] - bucket.expects(:classes=).with(config.classes) - defined.stubs(:builtin?).returns(false) - defined.expects(:to_transbucket).returns(bucket) - builtin.expects(:to_transobject).returns(:builtin) - - config.extract_to_transportable.should == [:builtin] - end - - # 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") - - @scope = mkscope - @scope.stubs(:tags).returns([]) - @source = mock 'source' - - # Create our scopes. - top = mkresource "class", :main - topbucket = [] - topbucket.expects(:classes=).with([]) - top.expects(:to_trans).returns(topbucket) - topres = mkresource "file", "/top" - topres.expects(:to_trans).returns(:topres) - config.add_edge! top, topres - - middle = mkresource "class", "middle" - middle.expects(:to_trans).returns([]) - config.add_edge! top, middle - midres = mkresource "file", "/mid" - midres.expects(:to_trans).returns(:midres) - config.add_edge! middle, midres - - bottom = mkresource "class", "bottom" - bottom.expects(:to_trans).returns([]) - config.add_edge! middle, bottom - botres = mkresource "file", "/bot" - botres.expects(:to_trans).returns(:botres) - config.add_edge! bottom, botres - - toparray = config.extract_to_transportable - - # This is annoying; it should look like: - # [[[:botres], :midres], :topres] - # but we can't guarantee sort order. - toparray.include?(:topres).should be_true - - midarray = toparray.find { |t| t.is_a?(Array) } - midarray.include?(:midres).should be_true - botarray = midarray.find { |t| t.is_a?(Array) } - botarray.include?(:botres).should be_true - end -end - -describe Puppet::Node::Configuration, " when converting to a transobject configuration" do - class TestResource - attr_accessor :name, :virtual, :builtin - def initialize(name, options = {}) - @name = name - options.each { |p,v| send(p.to_s + "=", v) } - end - - def ref - if builtin? - "File[%s]" % name - else - "Class[%s]" % name - end - end - - def virtual? - virtual - end - - def builtin? - builtin - end - - def to_transobject - Puppet::TransObject.new(name, builtin? ? "file" : "class") - end - end - - before do - @original = Puppet::Node::Configuration.new("mynode") - @original.tag(*%w{one two three}) - @original.add_class *%w{four five six} - - @top = TestResource.new 'top' - @topobject = TestResource.new 'topobject', :builtin => true - @virtual = TestResource.new 'virtual', :virtual => true - @virtualobject = TestResource.new 'virtualobject', :builtin => true, :virtual => true - @middle = TestResource.new 'middle' - @middleobject = TestResource.new 'middleobject', :builtin => true - @bottom = TestResource.new 'bottom' - @bottomobject = TestResource.new 'bottomobject', :builtin => true - - @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject] - - @original.add_edge!(@top, @topobject) - @original.add_edge!(@top, @virtual) - @original.add_edge!(@virtual, @virtualobject) - @original.add_edge!(@top, @middle) - @original.add_edge!(@middle, @middleobject) - @original.add_edge!(@middle, @bottom) - @original.add_edge!(@bottom, @bottomobject) - - @config = @original.to_transportable - end - - it "should add all resources as TransObjects" do - @resources.each { |resource| @config.resource(resource.ref).should be_instance_of(Puppet::TransObject) } - end - - it "should not extract defined virtual resources" do - @config.vertices.find { |v| v.name == "virtual" }.should be_nil - end - - it "should not extract builtin virtual resources" do - @config.vertices.find { |v| v.name == "virtualobject" }.should be_nil - end - - it "should copy the tag list to the new configuration" do - @config.tags.sort.should == @original.tags.sort - end - - it "should copy the class list to the new configuration" do - @config.classes.should == @original.classes - end - - it "should duplicate the original edges" do - @original.edges.each do |edge| - next if edge.source.virtual? or edge.target.virtual? - source = @config.resource(edge.source.ref) - target = @config.resource(edge.target.ref) - - source.should_not be_nil - target.should_not be_nil - @config.edge?(source, target).should be_true - 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) } - end -end - -describe Puppet::Node::Configuration, " when converting to a RAL configuration" do - before do - @original = Puppet::Node::Configuration.new("mynode") - @original.tag(*%w{one two three}) - @original.add_class *%w{four five six} - - @top = Puppet::TransObject.new 'top', "class" - @topobject = Puppet::TransObject.new '/topobject', "file" - @middle = Puppet::TransObject.new 'middle', "class" - @middleobject = Puppet::TransObject.new '/middleobject', "file" - @bottom = Puppet::TransObject.new 'bottom', "class" - @bottomobject = Puppet::TransObject.new '/bottomobject', "file" - - @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject] - - @original.add_resource(*@resources) - - @original.add_edge!(@top, @topobject) - @original.add_edge!(@top, @middle) - @original.add_edge!(@middle, @middleobject) - @original.add_edge!(@middle, @bottom) - @original.add_edge!(@bottom, @bottomobject) - - @config = @original.to_ral - end - - it "should add all resources as RAL instances" do - @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 - @config.tags.sort.should == @original.tags.sort - end - - it "should copy the class list to the new configuration" do - @config.classes.should == @original.classes - end - - it "should duplicate the original edges" do - @original.edges.each do |edge| - @config.edge?(@config.resource(edge.source.ref), @config.resource(edge.target.ref)).should be_true - 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) } - 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.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 - - changer.expects(:to_type).returns(resource) - - newconfig = nil - - Puppet::Type.allclear - - proc { @config = config.to_ral }.should_not raise_error - @config.resource("Test[changer2]").should equal(resource) - end - - after do - # Remove all resource instances. - @config.clear(true) - end -end - -describe Puppet::Node::Configuration, " 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 - end - - it "should provide a method to add one or more resources" do - @config.add_resource @one, @two - @config.resource(@one.ref).should equal(@one) - @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) - @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 - @config.is_relationship_graph = true - @config.add_resource @one - end - - it "should make all vertices available by resource reference" do - @config.add_resource(@one) - @config.resource(@one.ref).should equal(@one) - @config.vertices.find { |r| r.ref == @one.ref }.should equal(@one) - end - - it "should canonize how resources are referred to during retrieval when both type and title are provided" do - @config.add_resource(@one) - - @config.resource("me", "one").should equal(@one) - end - - it "should canonize how resources are referred to during retrieval when just the title is provided" do - @config.add_resource(@one) - - @config.resource("me[one]", nil).should equal(@one) - end - - it "should not allow two resources with the same resource reference" do - @config.add_resource(@one) - proc { @config.add_resource(@dupe) }.should raise_error(ArgumentError) - end - - it "should not store objects that do not respond to :ref" do - proc { @config.add_resource("thing") }.should raise_error(ArgumentError) - end - - it "should remove all resources when asked" do - @config.add_resource @one - @config.add_resource @two - @one.expects :remove - @two.expects :remove - @config.clear(true) - end - - it "should support a mechanism for finishing resources" do - @one.expects :finish - @two.expects :finish - @config.add_resource @one - @config.add_resource @two - - @config.finalize - end - - 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| - 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) - @config.add_resource @one - end - - it "should be able to find resources by reference" do - @config.add_resource @one - @config.resource(@one.ref).should equal(@one) - end - - it "should be able to find resources by reference or by type/title tuple" do - @config.add_resource @one - @config.resource("me", "one").should equal(@one) - end - - it "should have a mechanism for removing resources" do - @config.add_resource @one - @one.expects :remove - @config.remove_resource(@one) - @config.resource(@one.ref).should be_nil - @config.vertex?(@one).should be_false - end - - it "should have a method for creating aliases for resources" do - @config.add_resource @one - @config.alias(@one, "other") - @config.resource("me", "other").should equal(@one) - end - - # This test is the same as the previous, but the behaviour should be explicit. - it "should alias using the class name from the resource reference, not the resource class name" do - @config.add_resource @one - @config.alias(@one, "other") - @config.resource("me", "other").should equal(@one) - end - - it "should fail to add an alias if the aliased name already exists" do - @config.add_resource @one - proc { @config.alias @two, "one" }.should raise_error(ArgumentError) - end - - it "should remove resource aliases when the target resource is removed" do - @config.add_resource @one - @config.alias(@one, "other") - @one.expects :remove - @config.remove_resource(@one) - @config.resource("me", "other").should be_nil - end -end - -module ApplyingConfigurations - def setup - @config = Puppet::Node::Configuration.new("host") - - @config.retrieval_duration = Time.now - @transaction = mock 'transaction' - Puppet::Transaction.stubs(:new).returns(@transaction) - @transaction.stubs(:evaluate) - @transaction.stubs(:cleanup) - @transaction.stubs(:addtimes) - end -end - -describe Puppet::Node::Configuration, " when applying" do - include ApplyingConfigurations - - it "should create and evaluate a transaction" do - @transaction.expects(:evaluate) - @config.apply - end - - it "should provide the configuration time to the transaction" do - @transaction.expects(:addtimes).with do |arg| - arg[:config_retrieval].should be_instance_of(Time) - true - end - @config.apply - end - - it "should clean up the transaction" do - @transaction.expects :cleanup - @config.apply - end - - it "should return the transaction" do - @config.apply.should equal(@transaction) - end - - it "should yield the transaction if a block is provided" do - @config.apply do |trans| - trans.should equal(@transaction) - end - end - - it "should default to not being a host configuration" do - @config.host_config.should be_nil - end - - it "should pass supplied tags on to the transaction" do - @transaction.expects(:tags=).with(%w{one two}) - @config.apply(:tags => %w{one two}) - end - - it "should set ignoreschedules on the transaction if specified in apply()" do - @transaction.expects(:ignoreschedules=).with(true) - @config.apply(:ignoreschedules => true) - end -end - -describe Puppet::Node::Configuration, " when applying host configurations" do - include ApplyingConfigurations - - # super() doesn't work in the setup method for some reason - before do - @config.host_config = true - end - - it "should send a report if reporting is enabled" do - Puppet[:report] = true - @transaction.expects :send_report - @transaction.stubs :any_failed? => false - @config.apply - end - - it "should send a report if report summaries are enabled" do - Puppet[:summarize] = true - @transaction.expects :send_report - @transaction.stubs :any_failed? => false - @config.apply - end - - it "should initialize the state database before applying a configuration" do - Puppet::Util::Storage.expects(:load) - - # Short-circuit the apply, so we know we're loading before the transaction - Puppet::Transaction.expects(:new).raises ArgumentError - proc { @config.apply }.should raise_error(ArgumentError) - end - - it "should sync the state database after applying" do - Puppet::Util::Storage.expects(:store) - @transaction.stubs :any_failed? => false - @config.apply - end - - after { Puppet.settings.clear } -end - -describe Puppet::Node::Configuration, " when applying non-host configurations" do - include ApplyingConfigurations - - before do - @config.host_config = false - end - - it "should never send reports" do - Puppet[:report] = true - Puppet[:summarize] = true - @transaction.expects(:send_report).never - @config.apply - end - - it "should never modify the state database" do - Puppet::Util::Storage.expects(:load).never - Puppet::Util::Storage.expects(:store).never - @config.apply - end - - after { Puppet.settings.clear } -end - -describe Puppet::Node::Configuration, " when creating a relationship graph" do - before do - @config = Puppet::Node::Configuration.new("host") - @compone = Puppet::Type::Component.create :name => "one" - @comptwo = Puppet::Type::Component.create :name => "two", :require => ["class", "one"] - @file = Puppet::Type.type(:file) - @one = @file.create :path => "/one" - @two = @file.create :path => "/two" - @config.add_edge! @compone, @one - @config.add_edge! @comptwo, @two - - @three = @file.create :path => "/three" - @four = @file.create :path => "/four", :require => ["file", "/three"] - @five = @file.create :path => "/five" - @config.add_resource @compone, @comptwo, @one, @two, @three, @four, @five - @relationships = @config.relationship_graph - end - - it "should fail when trying to create a relationship graph for a relationship graph" do - proc { @relationships.relationship_graph }.should raise_error(Puppet::DevError) - end - - it "should be able to create a relationship graph" do - @relationships.should be_instance_of(Puppet::Node::Configuration) - end - - it "should copy its host_config setting to the relationship graph" do - config = Puppet::Node::Configuration.new - config.host_config = true - config.relationship_graph.host_config.should be_true - end - - it "should not have any components" 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 - # The failures print out too much info, so i just do a class comparison - @relationships.vertex?(@five).should be_true - end - - it "should have all resource relationships set as edges" do - @relationships.edge?(@three, @four).should be_true - end - - it "should copy component relationships to all contained resources" do - @relationships.edge?(@one, @two).should be_true - end - - it "should get removed when the configuration is cleaned up" do - @relationships.expects(:clear).with(false) - @config.clear - @config.instance_variable_get("@relationship_graph").should be_nil - end - - 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) - 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 - @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 - Puppet::Type.type(:file).expects(:create).with(args).returns(resource) - @config.create_resource :file, args - @config.resource("File[/yay]").should equal(resource) - end - - it "should provide a mechanism for creating implicit resources" do - args = {:name => "/yay", :ensure => :file} - resource = stub 'file', :ref => "File[/yay]", :configuration= => @config - Puppet::Type.type(:file).expects(:create).with(args).returns(resource) - resource.expects(:implicit=).with(true) - @config.create_implicit_resource :file, args - @config.resource("File[/yay]").should equal(resource) - end - - 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.expects(:implicit=).with(true) - Puppet::Type.type(:file).expects(:create).with(args).returns(resource) - # build the graph - relgraph = @config.relationship_graph - - @config.create_implicit_resource :file, args - relgraph.resource("File[/yay]").should equal(resource) - end - - it "should remove resources created mid-transaction" do - args = {:name => "/yay", :ensure => :file} - resource = stub 'file', :ref => "File[/yay]", :configuration= => @config - @transaction = mock 'transaction' - Puppet::Transaction.stubs(:new).returns(@transaction) - @transaction.stubs(:evaluate) - @transaction.stubs(:cleanup) - @transaction.stubs(:addtimes) - Puppet::Type.type(:file).expects(:create).with(args).returns(resource) - resource.expects :remove - @config.apply do |trans| - @config.create_resource :file, args - @config.resource("File[/yay]").should equal(resource) - end - @config.resource("File[/yay]").should be_nil - end - - it "should remove resources from the relationship graph if it exists" do - @config.remove_resource(@one) - @config.relationship_graph.vertex?(@one).should be_false - end - - after do - Puppet::Type.allclear - end -end - -describe Puppet::Node::Configuration, " when writing dot files" do - before do - @config = Puppet::Node::Configuration.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 - File.expects(:open).with(@file).never - @config.host_config = false - Puppet[:graph] = true - @config.write_graph(@name) - end - - it "should only write when graphing is enabled" do - File.expects(:open).with(@file).never - @config.host_config = true - Puppet[:graph] = false - @config.write_graph(@name) - end - - it "should write a dot file based on the passed name" do - File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil)) - @config.expects(:to_dot).with("name" => @name.to_s.capitalize) - @config.host_config = true - Puppet[:graph] = true - @config.write_graph(@name) - end - - after do - Puppet.settings.clear - end -end - -describe Puppet::Node::Configuration, " when indirecting" do - before do - @indirection = mock 'indirection' - - Puppet::Indirector::Indirection.clear_cache - end - - it "should redirect to the indirection for retrieval" do - Puppet::Node::Configuration.stubs(:indirection).returns(@indirection) - @indirection.expects(:find).with(:myconfig) - Puppet::Node::Configuration.find(:myconfig) - end - - it "should default to the 'compiler' terminus" do - Puppet::Node::Configuration.indirection.terminus_class.should == :compiler - end - - after do - mocha_verify - Puppet::Indirector::Indirection.clear_cache - end -end - -describe Puppet::Node::Configuration, " when converting to yaml" do - before do - @configuration = Puppet::Node::Configuration.new("me") - @configuration.add_edge!("one", "two") - end - - it "should be able to be dumped to yaml" do - YAML.dump(@configuration).should be_instance_of(String) - end -end - -describe Puppet::Node::Configuration, " when converting from yaml" do - before do - @configuration = Puppet::Node::Configuration.new("me") - @configuration.add_edge!("one", "two") - - text = YAML.dump(@configuration) - @newconfig = YAML.load(text) - end - - it "should get converted back to a configuration" do - @newconfig.should be_instance_of(Puppet::Node::Configuration) - end - - it "should have all vertices" do - @newconfig.vertex?("one").should be_true - @newconfig.vertex?("two").should be_true - end - - it "should have all edges" do - @newconfig.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 -- cgit