From 65c1501504dd7e9166176661f9ed9f80300954db Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Tue, 11 Sep 2007 16:19:03 -0500 Subject: The Node handler is now obsolete. Node searching is handled through the indirector. I have not yet added the tests for the node handlers themselves, which is next. --- test/network/handler/configuration.rb | 22 +- test/network/handler/node.rb | 640 ---------------------------------- 2 files changed, 2 insertions(+), 660 deletions(-) delete mode 100755 test/network/handler/node.rb (limited to 'test/network/handler') diff --git a/test/network/handler/configuration.rb b/test/network/handler/configuration.rb index 072fdc053..0964a4c5e 100755 --- a/test/network/handler/configuration.rb +++ b/test/network/handler/configuration.rb @@ -20,19 +20,6 @@ class TestHandlerConfiguration < Test::Unit::TestCase assert(config.local?, "Config is not considered local after being started that way") end - # Make sure we create the node handler when necessary. - def test_node_handler - config = Config.new - handler = nil - assert_nothing_raised("Could not create node handler") do - handler = config.send(:node_handler) - end - assert_instance_of(Puppet::Network::Handler.handler(:node), handler, "Did not create node handler") - - # Now make sure we get the same object back again - assert_equal(handler.object_id, config.send(:node_handler).object_id, "Did not cache node handler") - end - # Test creation/returning of the interpreter def test_interpreter config = Config.new @@ -170,19 +157,14 @@ class TestHandlerConfiguration < Test::Unit::TestCase def test_version # First try the case where we can't look up the node config = Config.new - handler = Object.new - handler.expects(:details).with(:client).returns(false) - config.expects(:node_handler).returns(handler) + node = Object.new + Puppet::Node.stubs(:search).with(:client).returns(false, node) interp = Object.new assert_instance_of(Bignum, config.version(:client), "Did not return configuration version") # And then when we find the node. config = Config.new - node = Object.new - handler = Object.new - handler.expects(:details).with(:client).returns(node) config.expects(:update_node_check).with(node) - config.expects(:node_handler).returns(handler) interp = Object.new interp.expects(:configuration_version).returns(:version) config.expects(:interpreter).returns(interp) diff --git a/test/network/handler/node.rb b/test/network/handler/node.rb deleted file mode 100755 index 6b8ab9290..000000000 --- a/test/network/handler/node.rb +++ /dev/null @@ -1,640 +0,0 @@ -#!/usr/bin/env ruby - -$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/ - -require 'mocha' -require 'puppettest' -require 'puppettest/resourcetesting' -require 'puppettest/parsertesting' -require 'puppettest/servertest' -require 'puppet/network/handler/node' - -module NodeTesting - include PuppetTest - Node = Puppet::Network::Handler::Node - SimpleNode = Puppet::Node - - def mk_node_mapper - # First, make sure our nodesearch command works as we expect - # Make a nodemapper - mapper = tempfile() - ruby = %x{which ruby}.chomp - File.open(mapper, "w") { |f| - f.puts "#!#{ruby} - require 'yaml' - name = ARGV.last.chomp - result = {} - - if name =~ /a/ - result[:parameters] = {'one' => ARGV.last + '1', 'two' => ARGV.last + '2'} - end - - if name =~ /p/ - result['classes'] = [1,2,3].collect { |n| ARGV.last + n.to_s } - end - - puts YAML.dump(result) - " - } - File.chmod(0755, mapper) - mapper - end - - def mk_searcher(name) - searcher = Object.new - searcher.extend(Node.node_source(name)) - searcher.meta_def(:newnode) do |name, *args| - SimpleNode.new(name, *args) - end - searcher - end - - def mk_node_source - @node_info = {} - @node_source = Node.newnode_source(:testing, :fact_merge => true) do - def nodesearch(key) - if info = @node_info[key] - SimpleNode.new(info) - else - nil - end - end - end - Puppet[:node_source] = "testing" - - cleanup { Node.rm_node_source(:testing) } - end -end - -class TestNodeHandler < Test::Unit::TestCase - include NodeTesting - - def setup - super - mk_node_source - end - - # Make sure that the handler includes the appropriate - # node source. - def test_initialize - # First try it when passing in the node source - handler = nil - assert_nothing_raised("Could not specify a node source") do - handler = Node.new(:Source => :testing) - end - assert(handler.metaclass.included_modules.include?(@node_source), "Handler did not include node source") - - # Now use the Puppet[:node_source] - Puppet[:node_source] = "testing" - assert_nothing_raised("Could not specify a node source") do - handler = Node.new() - end - assert(handler.metaclass.included_modules.include?(@node_source), "Handler did not include node source") - - # And make sure we throw an exception when an invalid node source is used - assert_raise(ArgumentError, "Accepted an invalid node source") do - handler = Node.new(:Source => "invalid") - end - end - - # Make sure we can find and we cache a fact handler. - def test_fact_handler - handler = Node.new - fhandler = nil - assert_nothing_raised("Could not retrieve the fact handler") do - fhandler = handler.send(:fact_handler) - end - assert_instance_of(Puppet::Network::Handler::Facts, fhandler, "Did not get a fact handler back") - - # Now call it again, making sure we're caching the value. - fhandler2 = nil - assert_nothing_raised("Could not retrieve the fact handler") do - fhandler2 = handler.send(:fact_handler) - end - assert_instance_of(Puppet::Network::Handler::Facts, fhandler2, "Did not get a fact handler on the second run") - assert_equal(fhandler.object_id, fhandler2.object_id, "Did not cache fact handler") - end - - # Make sure we can get node facts from the fact handler. - def test_node_facts - # Check the case where we find the node. - handler = Node.new - fhandler = handler.send(:fact_handler) - fhandler.expects(:get).with("present").returns("a" => "b") - - result = nil - assert_nothing_raised("Could not get facts from fact handler") do - result = handler.send(:node_facts, "present") - end - assert_equal({"a" => "b"}, result, "Did not get correct facts back") - - # Now try the case where the fact handler knows nothing about our host - fhandler.expects(:get).with('missing').returns(nil) - result = nil - assert_nothing_raised("Could not get facts from fact handler when host is missing") do - result = handler.send(:node_facts, "missing") - end - assert_equal({}, result, "Did not get empty hash when no facts are known") - end - - # Test our simple shorthand - def test_newnode - SimpleNode.expects(:new).with("stuff") - handler = Node.new - handler.send(:newnode, "stuff") - end - - # Make sure we can build up the correct node names to search for - def test_node_names - handler = Node.new - - # Verify that the handler asks for the facts if we don't pass them in - handler.expects(:node_facts).with("testing").returns({}) - handler.send(:node_names, "testing") - - handler = Node.new - # Test it first with no parameters - assert_equal(%w{testing}, handler.send(:node_names, "testing"), "Node names did not default to an array including just the node name") - - # Now test it with a fully qualified name - assert_equal(%w{testing.domain.com testing}, handler.send(:node_names, "testing.domain.com"), - "Fully qualified names did not get turned into multiple names, longest first") - - # And try it with a short name + domain fact - assert_equal(%w{testing host.domain.com host}, handler.send(:node_names, "testing", "domain" => "domain.com", "hostname" => "host"), - "The domain fact was not used to build up an fqdn") - - # And with an fqdn - assert_equal(%w{testing host.domain.com host}, handler.send(:node_names, "testing", "fqdn" => "host.domain.com"), - "The fqdn was not used") - - # And make sure the fqdn beats the domain - assert_equal(%w{testing host.other.com host}, handler.send(:node_names, "testing", "domain" => "domain.com", "fqdn" => "host.other.com"), - "The domain was used in preference to the fqdn") - end - - # Make sure we can retrieve a whole node by name. - def test_details_when_we_find_nodes - handler = Node.new - - # Make sure we get the facts first - handler.expects(:node_facts).with("host").returns(:facts) - - # Find the node names - handler.expects(:node_names).with("host", :facts).returns(%w{a b c}) - - # Iterate across them - handler.expects(:nodesearch).with("a").returns(nil) - handler.expects(:nodesearch).with("b").returns(nil) - - # Create an example node to return - node = SimpleNode.new("host") - - # Make sure its source is set - node.expects(:source=).with(handler.source) - - # And that the names are retained - node.expects(:names=).with(%w{a b c}) - - # And make sure we actually get it back - handler.expects(:nodesearch).with("c").returns(node) - - handler.expects(:fact_merge?).returns(true) - - # Make sure we merge the facts with the node's parameters. - node.expects(:fact_merge).with(:facts) - - # Now call the method - result = nil - assert_nothing_raised("could not call 'details'") do - result = handler.details("host") - end - assert_equal(node, result, "Did not get correct node back") - end - - # But make sure we pass through to creating default nodes when appropriate. - def test_details_using_default_node - handler = Node.new - - # Make sure we get the facts first - handler.expects(:node_facts).with("host").returns(:facts) - - # Find the node names - handler.expects(:node_names).with("host", :facts).returns([]) - - # Create an example node to return - node = SimpleNode.new("host") - - # Make sure its source is set - node.expects(:source=).with(handler.source) - - # And make sure we actually get it back - handler.expects(:nodesearch).with("default").returns(node) - - # This time, have it return false - handler.expects(:fact_merge?).returns(false) - - # And because fact_merge was false, we don't merge them. - node.expects(:fact_merge).never - - # Now call the method - result = nil - assert_nothing_raised("could not call 'details'") do - result = handler.details("host") - end - assert_equal(node, result, "Did not get correct node back") - end - - # Make sure our handler behaves rationally when it comes to getting environment data. - def test_environment - # What happens when we can't find the node - handler = Node.new - handler.expects(:details).with("fake").returns(nil) - - result = nil - assert_nothing_raised("Could not call 'Node.environment'") do - result = handler.environment("fake") - end - assert_nil(result, "Got an environment for a node we could not find") - - # Now for nodes we can find - handler = Node.new - node = SimpleNode.new("fake") - handler.expects(:details).with("fake").returns(node) - node.expects(:environment).returns("dev") - - result = nil - assert_nothing_raised("Could not call 'Node.environment'") do - result = handler.environment("fake") - end - assert_equal("dev", result, "Did not get environment back") - end - - # Make sure our handler behaves rationally when it comes to getting parameter data. - def test_parameters - # What happens when we can't find the node - handler = Node.new - handler.expects(:details).with("fake").returns(nil) - - result = nil - assert_nothing_raised("Could not call 'Node.parameters'") do - result = handler.parameters("fake") - end - assert_nil(result, "Got parameters for a node we could not find") - - # Now for nodes we can find - handler = Node.new - node = SimpleNode.new("fake") - handler.expects(:details).with("fake").returns(node) - node.expects(:parameters).returns({"a" => "b"}) - - result = nil - assert_nothing_raised("Could not call 'Node.parameters'") do - result = handler.parameters("fake") - end - assert_equal({"a" => "b"}, result, "Did not get parameters back") - end - - def test_classes - # What happens when we can't find the node - handler = Node.new - handler.expects(:details).with("fake").returns(nil) - - result = nil - assert_nothing_raised("Could not call 'Node.classes'") do - result = handler.classes("fake") - end - assert_nil(result, "Got classes for a node we could not find") - - # Now for nodes we can find - handler = Node.new - node = SimpleNode.new("fake") - handler.expects(:details).with("fake").returns(node) - node.expects(:classes).returns(%w{yay foo}) - - result = nil - assert_nothing_raised("Could not call 'Node.classes'") do - result = handler.classes("fake") - end - assert_equal(%w{yay foo}, result, "Did not get classes back") - end - - # We reuse the filetimeout for the node caching timeout. - def test_node_caching - handler = Node.new - - node = Object.new - node.metaclass.instance_eval do - attr_accessor :time, :name - end - node.time = Time.now - node.name = "yay" - - # Make sure caching works normally - assert_nothing_raised("Could not cache node") do - handler.send(:cache, node) - end - assert_equal(node.object_id, handler.send(:cached?, "yay").object_id, "Did not get node back from the cache") - - # And that it's returned if we ask for it, instead of creating a new node. - assert_equal(node.object_id, handler.details("yay").object_id, "Did not use cached node") - - # Now set the node's time to be a long time ago - node.time = Time.now - 50000 - assert(! handler.send(:cached?, "yay"), "Timed-out node was returned from cache") - end -end - -# Test our configuration object. -class TestNodeSources < Test::Unit::TestCase - include NodeTesting - - def test_node_sources - mod = nil - assert_nothing_raised("Could not add new search type") do - mod = Node.newnode_source(:testing) do - def nodesearch(name) - end - end - end - assert_equal(mod, Node.node_source(:testing), "Did not get node_source back") - - cleanup do - Node.rm_node_source(:testing) - assert(! Node.const_defined?("Testing"), "Did not remove constant") - end - end - - def test_external_node_source - source = Node.node_source(:external) - assert(source, "Could not find external node source") - mapper = mk_node_mapper - searcher = mk_searcher(:external) - assert(searcher.fact_merge?, "External node source does not merge facts") - - # Make sure it gives the right response - assert_equal({'classes' => %w{apple1 apple2 apple3}, :parameters => {"one" => "apple1", "two" => "apple2"}}, - YAML.load(%x{#{mapper} apple})) - - # First make sure we get nil back by default - assert_nothing_raised { - assert_nil(searcher.nodesearch("apple"), - "Interp#nodesearch_external defaulted to a non-nil response") - } - assert_nothing_raised { Puppet[:external_nodes] = mapper } - - node = nil - # Both 'a' and 'p', so we get classes and parameters - assert_nothing_raised { node = searcher.nodesearch("apple") } - assert_equal("apple", node.name, "node name was not set correctly for apple") - assert_equal(%w{apple1 apple2 apple3}, node.classes, "node classes were not set correctly for apple") - assert_equal( {"one" => "apple1", "two" => "apple2"}, node.parameters, "node parameters were not set correctly for apple") - - # A 'p' but no 'a', so we only get classes - assert_nothing_raised { node = searcher.nodesearch("plum") } - assert_equal("plum", node.name, "node name was not set correctly for plum") - assert_equal(%w{plum1 plum2 plum3}, node.classes, "node classes were not set correctly for plum") - assert_equal({}, node.parameters, "node parameters were not set correctly for plum") - - # An 'a' but no 'p', so we only get parameters. - assert_nothing_raised { node = searcher.nodesearch("guava")} # no p's, thus no classes - assert_equal("guava", node.name, "node name was not set correctly for guava") - assert_equal([], node.classes, "node classes were not set correctly for guava") - assert_equal({"one" => "guava1", "two" => "guava2"}, node.parameters, "node parameters were not set correctly for guava") - - assert_nothing_raised { node = searcher.nodesearch("honeydew")} # neither, thus nil - assert_nil(node) - end - - # Make sure a nodesearch with arguments works - def test_nodesearch_external_arguments - mapper = mk_node_mapper - Puppet[:external_nodes] = "#{mapper} -s something -p somethingelse" - searcher = mk_searcher(:external) - node = nil - assert_nothing_raised do - node = searcher.nodesearch("apple") - end - assert_instance_of(SimpleNode, node, "did not create node") - end - - # A wrapper test, to make sure we're correctly calling the external search method. - def test_nodesearch_external_functional - mapper = mk_node_mapper - searcher = mk_searcher(:external) - - Puppet[:external_nodes] = mapper - - node = nil - assert_nothing_raised do - node = searcher.nodesearch("apple") - end - assert_instance_of(SimpleNode, node, "did not create node") - end - - # This can stay in the main test suite because it doesn't actually use ldapsearch, - # it just overrides the method so it behaves as though it were hitting ldap. - def test_ldap_nodesearch - source = Node.node_source(:ldap) - assert(source, "Could not find ldap node source") - searcher = mk_searcher(:ldap) - assert(searcher.fact_merge?, "LDAP node source does not merge facts") - - nodetable = {} - - # Override the ldapsearch definition, so we don't have to actually set it up. - searcher.meta_def(:ldapsearch) do |name| - nodetable[name] - end - - # Make sure we get nothing for nonexistent hosts - node = nil - assert_nothing_raised do - node = searcher.nodesearch("nosuchhost") - end - - assert_nil(node, "Got a node for a non-existent host") - - # Now add a base node with some classes and parameters - nodetable["base"] = [nil, %w{one two}, {"base" => "true"}] - - assert_nothing_raised do - node = searcher.nodesearch("base") - end - - assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch") - assert_equal("base", node.name, "node name was not set") - - assert_equal(%w{one two}, node.classes, "node classes were not set") - assert_equal({"base" => "true"}, node.parameters, "node parameters were not set") - - # Now use a different with this as the base - nodetable["middle"] = ["base", %w{three}, {"center" => "boo"}] - assert_nothing_raised do - node = searcher.nodesearch("middle") - end - - assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch") - assert_equal("middle", node.name, "node name was not set") - - assert_equal(%w{one two three}.sort, node.classes.sort, "node classes were not set correctly with a parent node") - assert_equal({"base" => "true", "center" => "boo"}, node.parameters, "node parameters were not set correctly with a parent node") - - # And one further, to make sure we fully recurse - nodetable["top"] = ["middle", %w{four five}, {"master" => "far"}] - assert_nothing_raised do - node = searcher.nodesearch("top") - end - - assert_instance_of(SimpleNode, node, "Did not get node from ldap nodesearch") - assert_equal("top", node.name, "node name was not set") - - assert_equal(%w{one two three four five}.sort, node.classes.sort, "node classes were not set correctly with the top node") - assert_equal({"base" => "true", "center" => "boo", "master" => "far"}, node.parameters, "node parameters were not set correctly with the top node") - end - - # Make sure we always get a node back from the 'none' nodesource. - def test_nodesource_none - source = Node.node_source(:none) - assert(source, "Could not find 'none' node source") - searcher = mk_searcher(:none) - assert(searcher.fact_merge?, "'none' node source does not merge facts") - - # Run a couple of node names through it - node = nil - %w{192.168.0.1 0:0:0:3:a:f host host.domain.com}.each do |name| - assert_nothing_raised("Could not create an empty node with name '%s'" % name) do - node = searcher.nodesearch(name) - end - assert_instance_of(SimpleNode, node, "Did not get a simple node back for %s" % name) - assert_equal(name, node.name, "Name was not set correctly") - end - end -end - -class LdapNodeTest < PuppetTest::TestCase - include NodeTesting - include PuppetTest::ServerTest - include PuppetTest::ParserTesting - include PuppetTest::ResourceTesting - AST = Puppet::Parser::AST - confine "LDAP is not available" => Puppet.features.ldap? - confine "No LDAP test data for networks other than Luke's" => Facter.value(:domain) == "madstop.com" - - def ldapconnect - - @ldap = LDAP::Conn.new("ldap", 389) - @ldap.set_option( LDAP::LDAP_OPT_PROTOCOL_VERSION, 3 ) - @ldap.simple_bind("", "") - - return @ldap - end - - def ldaphost(name) - node = Puppet::Node.new(name) - parent = nil - found = false - @ldap.search( "ou=hosts, dc=madstop, dc=com", 2, - "(&(objectclass=puppetclient)(cn=%s))" % name - ) do |entry| - node.classes = entry.vals("puppetclass") || [] - node.parameters = entry.to_hash.inject({}) do |hash, ary| - if ary[1].length == 1 - hash[ary[0]] = ary[1].shift - else - hash[ary[0]] = ary[1] - end - hash - end - parent = node.parameters["parentnode"] - found = true - end - raise "Could not find node %s" % name unless found - - return node, parent - end - - def test_ldapsearch - Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com" - Puppet[:ldapnodes] = true - - searcher = Object.new - searcher.extend(Node.node_source(:ldap)) - - ldapconnect() - - # Make sure we get nil and nil back when we search for something missing - parent, classes, parameters = nil - assert_nothing_raised do - parent, classes, parameters = searcher.ldapsearch("nosuchhost") - end - - assert_nil(parent, "Got a parent for a non-existent host") - assert_nil(classes, "Got classes for a non-existent host") - - # Make sure we can find 'culain' in ldap - assert_nothing_raised do - parent, classes, parameters = searcher.ldapsearch("culain") - end - - node, realparent = ldaphost("culain") - assert_equal(realparent, parent, "did not get correct parent node from ldap") - assert_equal(node.classes, classes, "did not get correct ldap classes from ldap") - assert_equal(node.parameters, parameters, "did not get correct ldap parameters from ldap") - - # Now compare when we specify the attributes to get. - Puppet[:ldapattrs] = "cn" - assert_nothing_raised do - parent, classes, parameters = searcher.ldapsearch("culain") - end - assert_equal(realparent, parent, "did not get correct parent node from ldap") - assert_equal(node.classes, classes, "did not get correct ldap classes from ldap") - - list = %w{cn puppetclass parentnode dn} - should = node.parameters.inject({}) { |h, a| h[a[0]] = a[1] if list.include?(a[0]); h } - assert_equal(should, parameters, "did not get correct ldap parameters from ldap") - end -end - -class LdapReconnectTests < PuppetTest::TestCase - include NodeTesting - include PuppetTest::ServerTest - include PuppetTest::ParserTesting - include PuppetTest::ResourceTesting - AST = Puppet::Parser::AST - confine "Not running on culain as root" => (Puppet::Util::SUIDManager.uid == 0 and Facter.value("hostname") == "culain") - - def test_ldapreconnect - Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com" - Puppet[:ldapnodes] = true - - searcher = Object.new - searcher.extend(Node.node_source(:ldap)) - hostname = "culain.madstop.com" - - # look for our host - assert_nothing_raised { - parent, classes = searcher.nodesearch(hostname) - } - - # Now restart ldap - system("/etc/init.d/slapd restart 2>/dev/null >/dev/null") - sleep(1) - - # and look again - assert_nothing_raised { - parent, classes = searcher.nodesearch(hostname) - } - - # Now stop ldap - system("/etc/init.d/slapd stop 2>/dev/null >/dev/null") - cleanup do - system("/etc/init.d/slapd start 2>/dev/null >/dev/null") - end - - # And make sure we actually fail here - assert_raise(Puppet::Error) { - parent, classes = searcher.nodesearch(hostname) - } - end -end -- cgit From a6fe70054f4fb3efe4d558ffdd244917ca1c6f9c Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Wed, 12 Sep 2007 15:32:25 -0500 Subject: Another intermediate commit. The node and fact classes are now functional and are used instead of the network handlers, which have been removed. There are some failing tests as a result, but I want to get this code committed before I massage the rest of the system to make it work again. --- test/network/handler/configuration.rb | 4 +- test/network/handler/facts.rb | 112 ---------------------------------- test/network/handler/master.rb | 5 ++ 3 files changed, 7 insertions(+), 114 deletions(-) delete mode 100755 test/network/handler/facts.rb (limited to 'test/network/handler') diff --git a/test/network/handler/configuration.rb b/test/network/handler/configuration.rb index 0964a4c5e..29a393769 100755 --- a/test/network/handler/configuration.rb +++ b/test/network/handler/configuration.rb @@ -63,14 +63,14 @@ class TestHandlerConfiguration < Test::Unit::TestCase fakenode = Object.new # Set the server facts to something config.instance_variable_set("@server_facts", :facts) - fakenode.expects(:fact_merge).with(:facts) + fakenode.expects(:merge).with(:facts) config.send(:add_node_data, fakenode) # Now try it with classes. config.instance_variable_set("@options", {:Classes => %w{a b}}) list = [] fakenode = Object.new - fakenode.expects(:fact_merge).with(:facts) + fakenode.expects(:merge).with(:facts) fakenode.expects(:classes).returns(list).times(2) config.send(:add_node_data, fakenode) assert_equal(%w{a b}, list, "Did not add classes to node") diff --git a/test/network/handler/facts.rb b/test/network/handler/facts.rb deleted file mode 100755 index 03327b8c4..000000000 --- a/test/network/handler/facts.rb +++ /dev/null @@ -1,112 +0,0 @@ -#!/usr/bin/env ruby - -$:.unshift("../../lib") if __FILE__ =~ /\.rb$/ - -require 'puppettest' -require 'mocha' -require 'puppet/network/handler/facts' - -class TestFactsHandler < Test::Unit::TestCase - include PuppetTest::ServerTest - - def setup - super - - @class = Puppet::Network::Handler.handler(:facts) - - @@client_facts = {} - - unless Puppet::Util::FactStore.store(:testing) - Puppet::Util::FactStore.newstore(:testing) do - def get(node) - @@client_facts[node] - end - - def set(node, facts) - @@client_facts[node] = facts - end - end - end - - Puppet[:factstore] = :testing - - @handler = @class.new - - @facts = {:a => :b, :c => :d} - @name = "foo" - - @backend = @handler.instance_variable_get("@backend") - end - - def teardown - @@client_facts.clear - end - - def test_strip_internal - @facts[:_puppet_one] = "yay" - @facts[:_puppet_two] = "boo" - @facts[:_puppetthree] = "foo" - - newfacts = nil - assert_nothing_raised("Could not call strip_internal") do - newfacts = @handler.send(:strip_internal, @facts) - end - - [:_puppet_one, :_puppet_two, :_puppetthree].each do |name| - assert(@facts.include?(name), "%s was removed in strip_internal from original hash" % name) - end - [:_puppet_one, :_puppet_two].each do |name| - assert(! newfacts.include?(name), "%s was not removed in strip_internal" % name) - end - assert_equal("foo", newfacts[:_puppetthree], "_puppetthree was removed in strip_internal") - end - - def test_add_internal - newfacts = nil - assert_nothing_raised("Could not call strip_internal") do - newfacts = @handler.send(:add_internal, @facts) - end - - assert_instance_of(Time, newfacts[:_puppet_timestamp], "Did not set timestamp in add_internal") - assert(! @facts.include?(:_puppet_timestamp), "Modified original hash in add_internal") - end - - def test_set - newfacts = @facts.dup - newfacts[:_puppet_timestamp] = Time.now - @handler.expects(:add_internal).with(@facts).returns(newfacts) - @backend.expects(:set).with(@name, newfacts).returns(nil) - - assert_nothing_raised("Could not set facts") do - assert_nil(@handler.set(@name, @facts), "handler.set did not return nil") - end - end - - def test_get - prefacts = @facts.dup - prefacts[:_puppet_timestamp] = Time.now - @@client_facts[@name] = prefacts - @handler.expects(:strip_internal).with(prefacts).returns(@facts) - @backend.expects(:get).with(@name).returns(prefacts) - - assert_nothing_raised("Could not retrieve facts") do - assert_equal(@facts, @handler.get(@name), "did not get correct answer from handler.get") - end - - @handler = @class.new - assert_nothing_raised("Failed to call 'get' with no stored facts") do - @handler.get("nosuchname") - end - end - - def test_store_date - time = Time.now - @facts[:_puppet_timestamp] = time - - @handler.expects(:get).with(@name).returns(@facts) - - assert_equal(time.to_i, @handler.store_date(@name), "Did not retrieve timestamp correctly") - end -end - -# $Id$ diff --git a/test/network/handler/master.rb b/test/network/handler/master.rb index a976726ef..9749c7bdf 100755 --- a/test/network/handler/master.rb +++ b/test/network/handler/master.rb @@ -8,6 +8,11 @@ require 'puppet/network/handler/master' class TestMaster < Test::Unit::TestCase include PuppetTest::ServerTest + def teardown + super + Puppet::Indirector::Indirection.clear_cache + end + def test_defaultmanifest textfiles { |file| Puppet[:manifest] = file -- cgit From 9fa2628a844c75b8f554f283dfece01667f20594 Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Mon, 17 Sep 2007 15:21:44 -0700 Subject: This is basically another intermediate commit. I feel like I've gone too far down the rabbit hole to turn back now, but the code is clearly getting more centralized around the Configuration class, which is the goal. Things are currently a bit muddy between recursion, dynamic resource generation, transactions, and the configuration, and I don't expect to be able to clear it up much until we rewrite all of the tests for the Transaction class, since that is when we'll actually be setting its behaviour. At this point, Files (which are currently the only resources that generate other resources) are responsible for adding their edges to the relationship graph. This puts them knowing more than I would like about how the relationship graph works, but it'll have to do for now. There are still failing tests, but files seem to work again. Now to go through the rest of the tests and make them work. --- test/network/handler/master.rb | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'test/network/handler') diff --git a/test/network/handler/master.rb b/test/network/handler/master.rb index 9749c7bdf..df946fa33 100755 --- a/test/network/handler/master.rb +++ b/test/network/handler/master.rb @@ -76,9 +76,10 @@ class TestMaster < Test::Unit::TestCase "Client is incorrectly up to date") Puppet.config.use(:main) + config = nil assert_nothing_raised { - client.getconfig - client.apply + config = client.getconfig + config.apply } # Now it should be up to date @@ -113,8 +114,8 @@ class TestMaster < Test::Unit::TestCase # Retrieve and apply the new config assert_nothing_raised { - client.getconfig - client.apply + config = client.getconfig + config.apply } assert(client.fresh?(facts), "Client is not up to date") -- cgit From 3a18348fdbea39f56857b03c8f531bd5a2a8105d Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Sat, 22 Sep 2007 17:54:46 -0500 Subject: Renaming the 'Puppet::Util::Config' class to 'Puppet::Util::Settings'. This is to clear up confusion caused by the fact that we now have a 'Configuration' class to model host configurations, or any set of resources as a "configuration". --- test/network/handler/master.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'test/network/handler') diff --git a/test/network/handler/master.rb b/test/network/handler/master.rb index df946fa33..4f8e7fab2 100755 --- a/test/network/handler/master.rb +++ b/test/network/handler/master.rb @@ -75,7 +75,7 @@ class TestMaster < Test::Unit::TestCase assert(! client.fresh?(facts), "Client is incorrectly up to date") - Puppet.config.use(:main) + Puppet.settings.use(:main) config = nil assert_nothing_raised { config = client.getconfig -- cgit