puppet 0.23.2 → 0.24.0

data/test/network/client/resource.rb

@@ -1,12 +1,15 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
+require 'puppettest/support/utils'
+require 'puppettest/support/assertions'
 require 'puppet/network/client/resource'
 
 class TestResourceClient < Test::Unit::TestCase
     include PuppetTest::ServerTest
+    include PuppetTest::Support::Utils
 
     def mkresourceserver
         Puppet::Network::Handler.resource.new
@@ -35,6 +38,7 @@ class TestResourceClient < Test::Unit::TestCase
 
         assert_instance_of(Puppet::TransObject, tobj)
 
+        Puppet::Type.allclear
         obj = nil
         assert_nothing_raised {
             obj = tobj.to_type
@@ -45,6 +49,7 @@ class TestResourceClient < Test::Unit::TestCase
         File.unlink(file)
 
         # Now test applying
+        Puppet::Type.allclear
         result = nil
         assert_nothing_raised {
             result = client.apply(tobj)
@@ -52,6 +57,7 @@ class TestResourceClient < Test::Unit::TestCase
         assert(FileTest.exists?(file), "File was not created on apply")
 
         # Lastly, test "list"
+        Puppet::Type.allclear
         list = nil
         assert_nothing_raised {
             list = client.list("user")
@@ -64,12 +70,14 @@ class TestResourceClient < Test::Unit::TestCase
             break if count > 3
             assert_instance_of(Puppet::TransObject, tobj)
 
+            Puppet::Type.allclear
             tobj2 = nil
             assert_nothing_raised {
                 tobj2 = client.describe(tobj.type, tobj.name)
             }
 
             obj = nil
+            Puppet::Type.allclear
             assert_nothing_raised {
                 obj = tobj2.to_type
             }
@@ -80,4 +88,3 @@ class TestResourceClient < Test::Unit::TestCase
     end
 end
 
-# $Id: resource.rb 2259 2007-03-06 19:03:05Z luke $

data/test/network/client_request.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppettest'
 
@@ -35,5 +35,4 @@ class TestClientRequest < Test::Unit::TestCase
     end
 end
 
-# $Id: client_request.rb 2259 2007-03-06 19:03:05Z luke $
 

data/test/network/daemon.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../lib/puppettest'
 
 require 'puppettest'
 require 'puppet/daemon'
@@ -67,5 +67,4 @@ class TestDaemon < Test::Unit::TestCase
     end
 end
 
-# $Id: daemon.rb 2259 2007-03-06 19:03:05Z luke $
 

data/test/network/handler/bucket.rb

@@ -1,10 +1,11 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppet/network/handler/filebucket'
 require 'base64'
+require 'mocha'
 
 class TestBucket < Test::Unit::TestCase
     include PuppetTest::ServerTest
@@ -202,35 +203,6 @@ class TestBucket < Test::Unit::TestCase
         checkfiles(client)
     end
 
-    # test that things work over the wire
-    def test_webxmlmix
-        files = filelist()
-
-        tmpdir = File.join(tmpdir(),"tmpfiledir")
-        @@tmpfiles << tmpdir
-        FileUtils.mkdir_p(tmpdir)
-
-        Puppet[:autosign] = true
-        client = nil
-        port = Puppet[:masterport]
-
-        pid = mkserver(:CA => {}, :FileBucket => { :Path => @bucket})
-
-        assert_nothing_raised {
-            client = Puppet::Network::Client.dipper.new(
-                :Server => "localhost",
-                :Port => @@port
-            )
-        }
-
-        checkfiles(client)
-
-        unless pid
-            raise "Uh, we don't have a child pid"
-        end
-        Process.kill("TERM", pid)
-    end
-
     def test_no_path_duplicates
         bucket = nil
         assert_nothing_raised {
@@ -339,4 +311,3 @@ class TestBucket < Test::Unit::TestCase
     end
 end
 
-# $Id: bucket.rb 2348 2007-03-24 21:16:20Z luke $

data/test/network/handler/ca.rb

@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppet/network/handler/ca'
+require 'mocha'
 
 if ARGV.length > 0 and ARGV[0] == "short"
     $short = true
@@ -13,6 +14,12 @@ end
 
 class TestCA < Test::Unit::TestCase
     include PuppetTest::ServerTest
+
+    def setup
+        Puppet::Util::SUIDManager.stubs(:asuser).yields
+        super
+    end
+
     # Verify that we're autosigning.  We have to autosign a "different" machine,
     # since we always autosign the CA server's certificate.
     def test_autocertgeneration
@@ -184,7 +191,7 @@ class TestCA < Test::Unit::TestCase
         server = nil
         Puppet[:name] = "puppetmasterd"
         assert_nothing_raised {
-            server = Puppet::Network::Server::WEBrick.new(
+            server = Puppet::Network::HTTPServer::WEBrick.new(
                 :Port => @@port,
                 :Handlers => {
                     :CA => {}, # so that certs autogenerate
@@ -265,4 +272,3 @@ class TestCA < Test::Unit::TestCase
     end
 end
 
-# $Id: ca.rb 2612 2007-06-18 19:51:17Z luke $

data/test/network/handler/configuration.rb

@@ -0,0 +1,160 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../lib/puppettest'
+
+require 'puppettest'
+require 'puppet/network/handler/configuration'
+
+class TestHandlerConfiguration < Test::Unit::TestCase
+	include PuppetTest
+
+    Config = Puppet::Network::Handler.handler(:configuration)
+
+    # Check all of the setup stuff.
+    def test_initialize
+        config = nil
+        assert_nothing_raised("Could not create local config") do
+            config = Config.new(:Local => true)
+        end
+
+        assert(config.local?, "Config is not considered local after being started that way")
+    end
+
+    # Test creation/returning of the interpreter
+    def test_interpreter
+        config = Config.new
+
+        # First test the defaults
+        config.expects(:create_interpreter).returns(:interp)
+        assert_equal(:interp, config.send(:interpreter), "Did not return the interpreter")
+
+        # Now run it again and make sure we get the same thing
+        assert_equal(:interp, config.send(:interpreter), "Did not cache the interpreter")
+    end
+
+    def test_create_interpreter
+        config = Config.new(:Local => false)
+        args = {}
+
+        # Try it first with defaults.
+        Puppet::Parser::Interpreter.expects(:new).returns(:interp)
+        assert_equal(:interp, config.send(:create_interpreter), "Did not return the interpreter")
+    end
+
+    # Make sure node objects get appropriate data added to them.
+    def test_add_node_data
+        # First with no classes
+        config = Config.new
+
+        fakenode = Object.new
+        # Set the server facts to something
+        config.instance_variable_set("@server_facts", :facts)
+        fakenode.expects(:merge).with(:facts)
+        config.send(:add_node_data, fakenode)
+
+        # Now try it with classes.
+        config.classes = %w{a b}
+        list = []
+        fakenode = Object.new
+        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")
+    end
+
+    def test_compile
+        config = Config.new
+
+        # First do a local
+        node = mock 'node'
+        node.stubs(:name).returns(:mynode)
+        node.stubs(:environment).returns(:myenv)
+
+        interp = mock 'interpreter'
+        interp.stubs(:environment)
+        interp.expects(:compile).with(node).returns(:config)
+        config.expects(:interpreter).returns(interp)
+
+        Puppet.expects(:notice) # The log message from benchmarking
+
+        assert_equal(:config, config.send(:compile, node), "Did not return config")
+        
+        # Now try it non-local
+        node = mock 'node'
+        node.stubs(:name).returns(:mynode)
+        node.stubs(:environment).returns(:myenv)
+
+        interp = mock 'interpreter'
+        interp.stubs(:environment)
+        interp.expects(:compile).with(node).returns(:config)
+
+        config = Config.new(:Local => true)
+        config.expects(:interpreter).returns(interp)
+
+        assert_equal(:config, config.send(:compile, node), "Did not return config")
+    end
+
+    def test_set_server_facts
+        config = Config.new
+        assert_nothing_raised("Could not call :set_server_facts") do
+            config.send(:set_server_facts)
+        end
+        facts = config.instance_variable_get("@server_facts")
+        %w{servername serverversion serverip}.each do |fact|
+            assert(facts.include?(fact), "Config did not set %s fact" % fact)
+        end
+    end
+
+    def test_translate
+        # First do a local config
+        config = Config.new(:Local => true)
+        assert_equal(:plain, config.send(:translate, :plain), "Attempted to translate local config")
+
+        # Now a non-local
+        config = Config.new(:Local => false)
+        assert(! config.local?, "Config wrongly thinks it's local")
+        obj = mock 'dumpee'
+        yamld = mock 'yaml'
+        obj.expects(:to_yaml).with(:UseBlock => true).returns(yamld)
+        CGI.expects(:escape).with(yamld).returns(:translated)
+        assert_equal(:translated, config.send(:translate, obj), "Did not return translated config")
+    end
+
+    # Check that we're storing the node freshness into the rails db.  Hackilicious.
+    def test_update_node_check
+        # This is stupid.
+        config = Config.new
+        node = Object.new
+        node.expects(:name).returns(:hostname)
+        now = Object.new
+        Time.expects(:now).returns(now)
+        host = Object.new
+        host.expects(:last_freshcheck=).with(now)
+        host.expects(:save)
+
+        # Only test the case where rails is there
+        Puppet[:storeconfigs] = true
+        Puppet.features.expects(:rails?).returns(true)
+        Puppet::Rails.expects(:connect)
+        Puppet::Rails::Host.expects(:find_or_create_by_name).with(:hostname).returns(host)
+
+        config.send(:update_node_check, node)
+    end
+
+    def test_version
+        # First try the case where we can't look up the node
+        config = Config.new
+        node = Object.new
+        Puppet::Node.stubs(:find_by_any_name).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
+        config.expects(:update_node_check).with(node)
+        interp = Object.new
+        interp.expects(:configuration_version).returns(:version)
+        config.expects(:interpreter).returns(interp)
+        assert_equal(:version, config.version(:client), "Did not return configuration version")
+    end
+end

data/test/network/handler/fileserver.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppet/network/handler/fileserver'
@@ -970,12 +970,16 @@ allow *
         }
 
         dir = tempfile()
+        Facter.stubs(:value).with(:ipaddress).returns("127.0.0.1")
+        Facter.stubs(:value).with { |v| v.to_s == "hostname" }.returns("myhost")
+        Facter.stubs(:value).with { |v| v.to_s == "domain" }.returns("mydomain.com")
+        Facter.stubs(:value).with(:domain).returns("mydomain.com")
         ip = Facter.value(:ipaddress)
 
         Dir.mkdir(dir)
-        host = "host.domain.com"
+        host = "myhost.mydomain.com"
         {
-            "%H" => "host.domain.com", "%h" => "host", "%d" => "domain.com"
+            "%H" => "myhost.mydomain.com", "%h" => "myhost", "%d" => "mydomain.com"
         }.each do |pattern, string|
             file = File.join(dir, string)
             mount = File.join(dir, pattern)
@@ -1030,7 +1034,6 @@ allow *
         end
 
         conffile = tempfile
-        @@tmpfiles << conffile
 
         File.open(conffile, "w") { |f| f.puts "# a test config file" }
 
@@ -1148,7 +1151,23 @@ allow *
             }
         end
     end
+
+    def test_can_start_without_configuration
+        Puppet[:fileserverconfig] = tempfile
+        assert_nothing_raised("Could not create fileserver when configuration is absent") do
+                server = Puppet::Network::Handler::FileServer.new(
+                    :Local => false
+                )
+        end
+    end
+
+    def test_creates_default_mounts_when_no_configuration_is_available
+        Puppet[:fileserverconfig] = tempfile
+        server = Puppet::Network::Handler::FileServer.new(:Local => false)
+
+        assert(server.mounted?("plugins"), "Did not create default plugins mount when missing configuration file")
+        assert(server.mounted?("modules"), "Did not create default modules mount when missing configuration file")
+    end
 end
 
-# $Id: fileserver.rb 2629 2007-06-19 22:18:55Z luke $
 

data/test/network/handler/handler.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppet/network/handler'
@@ -61,4 +61,3 @@ class TestHandler < Test::Unit::TestCase
     end
 end
 
-# $Id: handler.rb 2497 2007-05-09 16:21:56Z luke $

data/test/network/handler/master.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+require File.dirname(__FILE__) + '/../../lib/puppettest'
 
 require 'puppettest'
 require 'puppet/network/handler/master'
@@ -8,89 +8,16 @@ require 'puppet/network/handler/master'
 class TestMaster < Test::Unit::TestCase
     include PuppetTest::ServerTest
 
-    # run through all of the existing test files and make sure everything
-    # works
-    def test_files
-        count = 0
-        textfiles { |file|
-            Puppet.debug("parsing %s" % file)
-            client = nil
-            master = nil
-
-            # create our master
-            assert_nothing_raised() {
-                # this is the default server setup
-                master = Puppet::Network::Handler.master.new(
-                    :Manifest => file,
-                    :UseNodes => false,
-                    :Local => true
-                )
-            }
-
-            # and our client
-            assert_nothing_raised() {
-                client = Puppet::Network::Client.master.new(
-                    :Master => master
-                )
-            }
-
-            # pull our configuration a few times
-            assert_nothing_raised() {
-                client.getconfig
-                stopservices
-                Puppet::Type.allclear
-            }
-            assert_nothing_raised() {
-                client.getconfig
-                stopservices
-                Puppet::Type.allclear
-            }
-            assert_nothing_raised() {
-                client.getconfig
-                stopservices
-                Puppet::Type.allclear
-            }
-            # only test three files; that's plenty
-            if count > 3
-                break
-            end
-            count += 1
-        }
-    end
-
-    def test_defaultmanifest
-        textfiles { |file|
-            Puppet[:manifest] = file
-            client = nil
-            master = nil
-            assert_nothing_raised() {
-                # this is the default server setup
-                master = Puppet::Network::Handler.master.new(
-                    :Manifest => file,
-                    :UseNodes => false,
-                    :Local => true
-                )
-            }
-            assert_nothing_raised() {
-                client = Puppet::Network::Client.master.new(
-                    :Master => master
-                )
-            }
-
-            # pull our configuration
-            assert_nothing_raised() {
-                client.getconfig
-                stopservices
-                Puppet::Type.allclear
-            }
-
-            break
-        }
+    def teardown
+        super
+        Puppet::Indirector::Indirection.clear_cache
     end
 
+    # Make sure that files are reread when they change.
     def test_filereread
         # Start with a normal setting
         Puppet[:filetimeout] = 15
+
         manifest = mktestmanifest()
 
         facts = Puppet::Network::Client.master.facts
@@ -101,41 +28,18 @@ class TestMaster < Test::Unit::TestCase
         @@tmpfiles << file2
 
         client = master = nil
+        Puppet[:manifest] = manifest
         assert_nothing_raised() {
             # this is the default server setup
             master = Puppet::Network::Handler.master.new(
-                :Manifest => manifest,
-                :UseNodes => false,
                 :Local => true
             )
         }
-        assert_nothing_raised() {
-            client = Puppet::Network::Client.master.new(
-                :Master => master
-            )
-        }
 
-        assert(client, "did not create master client")
-        # The client doesn't have a config, so it can't be up to date
-        assert(! client.fresh?(facts),
-            "Client is incorrectly up to date")
-
-        Puppet.config.use(:main)
-        assert_nothing_raised {
-            client.getconfig
-            client.apply
-        }
-
-        # Now it should be up to date
-        assert(client.fresh?(facts), "Client is not up to date")
+        config = master.getconfig({"hostname" => "blah"})
 
         # Cache this value for later
-        parse1 = master.freshness
-
-        # Verify the config got applied
-        assert(FileTest.exists?(@createdfile),
-            "Created file %s does not exist" % @createdfile)
-        Puppet::Type.allclear
+        parse1 = master.freshness("mynode")
 
         sleep 1.5
         # Create a new manifest
@@ -145,161 +49,52 @@ class TestMaster < Test::Unit::TestCase
 
         # Verify that the master doesn't immediately reparse the file; we
         # want to wait through the timeout
-        assert_equal(parse1, master.freshness, "Master did not wait through timeout")
-        assert(client.fresh?(facts), "Client is not up to date")
+        assert_equal(parse1, master.freshness("mynode"), "Master did not wait through timeout")
 
         # Then eliminate it
         Puppet[:filetimeout] = 0
 
         # Now make sure the master does reparse
         #Puppet.notice "%s vs %s" % [parse1, master.freshness]
-        assert(parse1 != master.freshness, "Master did not reparse file")
-        assert(! client.fresh?(facts), "Client is incorrectly up to date")
+        assert(parse1 != master.freshness("mynode"), "Master did not reparse file")
 
-        # Retrieve and apply the new config
-        assert_nothing_raised {
-            client.getconfig
-            client.apply
-        }
-        assert(client.fresh?(facts), "Client is not up to date")
-
-        assert(FileTest.exists?(file2), "Second file %s does not exist" % file2)
-    end
-
-    def test_addfacts
-        master = nil
-        file = mktestmanifest()
-        # create our master
-        assert_nothing_raised() {
-            # this is the default server setup
-            master = Puppet::Network::Handler.master.new(
-                :Manifest => file,
-                :UseNodes => false,
-                :Local => true
-            )
-        }
-
-        facts = {}
-
-        assert_nothing_raised {
-            master.addfacts(facts)
-        }
-
-        %w{serverversion servername serverip}.each do |fact|
-            assert(facts.include?(fact), "Fact %s was not set" % fact)
-        end
-    end
-
-    # Make sure we're using the hostname as configured with :node_name
-    def test_hostname_in_getconfig
-        master = nil
-        file = tempfile()
-        #@createdfile = File.join(tmpdir(), self.class.to_s + "manifesttesting" +
-        #    "_" + @method_name)
-        file_cert = tempfile()
-        file_fact = tempfile()
-
-        certname = "y4yn3ss"
-        factname = Facter.value("hostname")
-
-        File.open(file, "w") { |f|
-            f.puts %{
-    node #{certname} { file { "#{file_cert}": ensure => file, mode => 755 } }
-    node #{factname} { file { "#{file_fact}": ensure => file, mode => 755 } }
-}
-        }
-        # create our master
-        assert_nothing_raised() {
-            # this is the default server setup
-            master = Puppet::Network::Handler.master.new(
-                :Manifest => file,
-                :UseNodes => true,
-                :Local => true
-            )
-        }
-
-        result = nil
-
-        # Use the hostname from facter
-        Puppet[:node_name] = 'facter'
-        assert_nothing_raised {
-            result = master.getconfig({"hostname" => factname}, "yaml", certname, "127.0.0.1")
-        }
-
-        result = result.flatten
-
-        assert(result.find { |obj| obj.name == file_fact },
-            "Could not find correct file")
-        assert(!result.find { |obj| obj.name == file_cert },
-            "Found incorrect file")
-
-        # Use the hostname from the cert
-        Puppet[:node_name] = 'cert'
-        assert_nothing_raised {
-            result = master.getconfig({"hostname" => factname}, "yaml", certname, "127.0.0.1")
-        }
-
-        result = result.flatten
-
-        assert(!result.find { |obj| obj.name == file_fact },
-            "Could not find correct file")
-        assert(result.find { |obj| obj.name == file_cert },
-            "Found incorrect file")
+        assert(master.getconfig({"hostname" => "blah"}) != config, "Did not use reloaded config")
     end
 
     # Make sure we're correctly doing clientname manipulations.
     # Testing to make sure we always get a hostname and IP address.
     def test_clientname
-        master = nil
-        file = tempfile()
-
-        File.open(file, "w") { |f|
-            f.puts %{
-    node yay { file { "/something": ensure => file, mode => 755 } }
-}
-        }
         # create our master
-        assert_nothing_raised() {
-            # this is the default server setup
-            master = Puppet::Network::Handler.master.new(
-                :Manifest => file,
-                :UseNodes => true,
-                :Local => true
-            )
-        }
-
-        Puppet[:node_name] = "cert"
-        # First act like we're local
-        fakename = nil
-        fakeip = nil
+        master = Puppet::Network::Handler.master.new(
+            :Manifest => tempfile,
+            :UseNodes => true,
+            :Local => true
+        )
 
-        name = ip = nil
-        facts = Facter.to_hash
-        assert_nothing_raised do
-            name, ip = master.clientname(fakename, fakeip, facts)
-        end
 
-        assert(facts["hostname"], "Removed hostname fact")
-        assert(facts["ipaddress"], "Removed ipaddress fact")
-
-        assert_equal(facts["hostname"], name)
-        assert_equal(facts["ipaddress"], ip)
-
-        # Now set them to something real, and make sure we get them back
-        fakename = "yayness"
-        fakeip = "192.168.0.1"
-        facts = Facter.to_hash
-        assert_nothing_raised do
-            name, ip = master.clientname(fakename, fakeip, facts)
-        end
-
-        assert(facts["hostname"], "Removed hostname fact")
-        assert(facts["ipaddress"], "Removed ipaddress fact")
+        # First check that 'cert' works
+        Puppet[:node_name] = "cert"
 
-        assert_equal(fakename, name)
-        assert_equal(fakeip, ip)
+        # Make sure we get the fact data back when nothing is set
+        facts = {"hostname" => "fact_hostname", "ipaddress" => "fact_ip"}
+        certname = "cert_hostname"
+        certip = "cert_ip"
+
+        resname, resip = master.send(:clientname, nil, nil, facts)
+        assert_equal(facts["hostname"], resname, "Did not use fact hostname when no certname was present")
+        assert_equal(facts["ipaddress"], resip, "Did not use fact ip when no certname was present")
+
+        # Now try it with the cert stuff present
+        resname, resip = master.send(:clientname, certname, certip, facts)
+        assert_equal(certname, resname, "Did not use cert hostname when certname was present")
+        assert_equal(certip, resip, "Did not use cert ip when certname was present")
+
+        # And reset the node_name stuff and make sure we use it.
+        Puppet[:node_name] = :facter
+        resname, resip = master.send(:clientname, certname, certip, facts)
+        assert_equal(facts["hostname"], resname, "Did not use fact hostname when nodename was set to facter")
+        assert_equal(facts["ipaddress"], resip, "Did not use fact ip when nodename was set to facter")
     end
 end
 
-# $Id: master.rb 2616 2007-06-18 21:03:18Z luke $