Okay, last file moves for the night. The test code has been moved to match the lib directory, and I have moved a couple of things into network/ instead of network/server, since they did not belong as much.

git-svn-id: https://reductivelabs.com/svn/puppet/trunk@2180 980ebf18-57e1-0310-9a29-db15c13687c0

4 files changed, 835 insertions, 0 deletions

diff --git a/test/network/client/client.rb b/test/network/client/client.rb
new file mode 100755
index 000000000..7fd2afb71
--- /dev/null
+++ b/test/network/client/client.rb
@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/client'
+
+class TestClient < Test::Unit::TestCase
+    include PuppetTest::ServerTest
+    # a single run through of connect, auth, etc.
+    def test_sslInitWithAutosigningLocalServer
+        # autosign everything, for simplicity
+        Puppet[:autosign] = true
+
+        # create a server to which to connect
+        mkserver()
+
+        # create our client
+        client = nil
+        assert_nothing_raised {
+            client = Puppet::Network::Client::MasterClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+
+        # get our certs
+        assert_nothing_raised {
+            client.initcerts
+        }
+
+        # make sure all of our cert files exist
+        certfile = File.join(Puppet[:certdir], [client.fqdn, "pem"].join("."))
+        keyfile = File.join(Puppet[:privatekeydir], [client.fqdn, "pem"].join("."))
+        publickeyfile = File.join(Puppet[:publickeydir], [client.fqdn, "pem"].join("."))
+
+        assert(File.exists?(keyfile))
+        assert(File.exists?(certfile))
+        assert(File.exists?(publickeyfile))
+
+        # verify we can retrieve the configuration
+        assert_nothing_raised("Client could not retrieve configuration") {
+            client.getconfig
+        }
+
+        # and apply it
+        assert_nothing_raised("Client could not apply configuration") {
+            client.apply
+        }
+
+        # and verify that it did what it was supposed to
+        assert(FileTest.exists?(@createdfile),
+            "Applied file does not exist")
+    end
+
+
+    # here we create two servers; we 
+    def test_failureWithUntrustedCerts
+        Puppet[:autosign] = true
+
+        # create a pair of clients with no certs
+        nonemaster = nil
+        assert_nothing_raised {
+            nonemaster = Puppet::Network::Client::MasterClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+
+        nonebucket = nil
+        assert_nothing_raised {
+            nonebucket = Puppet::Network::Client::Dipper.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+
+        # create a ca so we can create a set of certs
+        # make a new ssldir for it
+        ca = nil
+        assert_nothing_raised {
+            ca = Puppet::Network::Client::CA.new(
+                :CA => true, :Local => true
+            )
+            ca.requestcert
+        }
+
+        # initialize our clients with this set of certs
+        certmaster = nil
+        assert_nothing_raised {
+            certmaster = Puppet::Network::Client::MasterClient.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+
+        certbucket = nil
+        assert_nothing_raised {
+            certbucket = Puppet::Network::Client::Dipper.new(
+                :Server => "localhost",
+                :Port => @@port
+            )
+        }
+
+        # Create a new ssl root.
+        confdir = tempfile()
+        Puppet[:ssldir] = confdir
+        Puppet.config.mkdir(:ssldir)
+        Puppet.config.clearused
+        Puppet.config.use(:certificates, :ca)
+
+        mkserver
+
+        # now verify that our client cannot do non-cert operations
+        # because its certs are signed by a different CA
+        assert_raise(Puppet::Error,
+            "Client was allowed to call getconfig with no certs") {
+            nonemaster.getconfig
+        }
+        assert_raise(Puppet::Error,
+            "Client was allowed to call getconfig with untrusted certs") {
+            certmaster.getconfig
+        }
+
+        assert_raise(Puppet::Network::NetworkClientError,
+            "Client was allowed to call backup with no certs") {
+            nonebucket.backup("/etc/passwd")
+        }
+        assert_raise(Puppet::Network::NetworkClientError,
+            "Client was allowed to call backup with untrusted certs") {
+            certbucket.backup("/etc/passwd")
+        }
+    end
+
+    def test_classfile
+        manifest = tempfile()
+
+        File.open(manifest, "w") do |file|
+            file.puts "class yaytest {}\n class bootest {}\n include yaytest, bootest"
+        end
+
+        master = client = nil
+        assert_nothing_raised() {
+            master = Puppet::Network::Server::Master.new(
+                :Manifest => manifest,
+                :UseNodes => false,
+                :Local => false
+            )
+        }
+        assert_nothing_raised() {
+            client = Puppet::Network::Client::MasterClient.new(
+                :Master => master
+            )
+        }
+
+        # Fake that it's local, so it creates the class file
+        client.local = false
+
+        assert_nothing_raised {
+            client.getconfig
+        }
+
+        assert(FileTest.exists?(Puppet[:classfile]), "Class file does not exist")
+
+        classes = File.read(Puppet[:classfile]).split("\n")
+
+        assert_equal(%w{bootest yaytest}, classes.sort)
+    end
+
+    def test_setpidfile
+        FileUtils.mkdir_p(Puppet[:rundir])
+        $clientrun = false
+        newclass = Class.new(Puppet::Network::Client) do
+            def run
+                $clientrun = true
+            end
+
+            def initialize
+            end
+        end
+
+        inst = newclass.new
+
+        assert_nothing_raised {
+            inst.start
+        }
+
+        assert(FileTest.exists?(inst.pidfile),
+               "PID file was not created")
+    end
+end
+
+# $Id$
diff --git a/test/network/client/master.rb b/test/network/client/master.rb
new file mode 100755
index 000000000..de94cd93a
--- /dev/null
+++ b/test/network/client/master.rb
@@ -0,0 +1,530 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+class TestMasterClient < Test::Unit::TestCase
+    include PuppetTest::ServerTest
+    
+    class FakeTrans
+        def initialize
+            @counters = Hash.new { |h,k| h[k] = 0 }
+        end
+        [:evaluate, :report, :cleanup, :addtimes, :tags, :ignoreschedules].each do |m|
+            define_method(m.to_s + "=") do |*args|
+                @counters[m] += 1
+            end
+            define_method(m) do |*args|
+                @counters[m] += 1
+            end
+            define_method(m.to_s + "?") do
+                @counters[m]
+            end
+        end
+    end
+    class FakeComponent
+        attr_accessor :trans
+        def evaluate
+            @trans = FakeTrans.new
+            @trans
+        end
+        
+        def finalize
+            @finalized = true
+        end
+        
+        def finalized?
+            @finalized
+        end
+    end
+
+    def mkmaster(file = nil)
+        master = nil
+
+        file ||= mktestmanifest()
+        # create our master
+        assert_nothing_raised() {
+            # this is the default server setup
+            master = Puppet::Network::Server::Master.new(
+                :Manifest => file,
+                :UseNodes => false,
+                :Local => true
+            )
+        }
+        return master
+    end
+
+    def mkclient(master = nil)
+        master ||= mkmaster()
+        client = nil
+        assert_nothing_raised() {
+            client = Puppet::Network::Client::MasterClient.new(
+                :Master => master
+            )
+        }
+
+        return client
+    end
+    
+    def mk_fake_client
+        server = Puppet::Network::Server::Master.new :Code => ""
+        master = Puppet::Network::Client::MasterClient.new :Server => server, :Local => true
+
+        # Now create some objects
+        objects = FakeComponent.new
+
+        master.send(:instance_variable_set, "@objects", objects)
+
+        class << master
+            def report(r)
+                @reported ||= 0
+                @reported += 1
+            end
+            def reported
+                @reported ||= 0
+                @reported
+            end
+        end
+        return master, objects
+    end
+    
+    def test_apply
+        master, objects = mk_fake_client
+        
+        check = Proc.new do |hash|
+            assert(objects.trans, "transaction was not created")
+            trans = objects.trans
+            hash[:yes].each do |m|
+                assert_equal(1, trans.send(m.to_s + "?"), "did not call #{m} enough times")
+            end
+            hash[:no].each do |m|
+                assert_equal(0, trans.send(m.to_s + "?"), "called #{m} too many times")
+            end
+        end
+        
+        # First try it with no arguments
+        assert_nothing_raised do
+            master.apply
+        end
+        check.call :yes => %w{evaluate cleanup addtimes}, :no => %w{report tags ignoreschedules}
+        assert_equal(0, master.reported, "master sent report with reports disabled")
+        
+        
+        # Now enable reporting and make sure the report method gets called
+        Puppet[:report] = true
+        assert_nothing_raised do
+            master.apply
+        end
+        check.call :yes => %w{evaluate cleanup addtimes}, :no => %w{tags ignoreschedules}
+        assert_equal(1, master.reported, "master did not send report")
+        
+        # Now try it with tags enabled
+        assert_nothing_raised do
+            master.apply("tags")
+        end
+        check.call :yes => %w{evaluate cleanup tags addtimes}, :no => %w{ignoreschedules}
+        assert_equal(2, master.reported, "master did not send report")
+        
+        # and ignoreschedules
+        assert_nothing_raised do
+            master.apply("tags", true)
+        end
+        check.call :yes => %w{evaluate cleanup tags ignoreschedules addtimes}, :no => %w{}
+        assert_equal(3, master.reported, "master did not send report")
+    end
+    
+    def test_getconfig
+        client = mkclient
+        
+        $methodsrun = []
+        cleanup { $methodsrun = nil }
+        client.meta_def(:getplugins) do
+            $methodsrun << :getplugins
+        end
+        client.meta_def(:get_actual_config) do
+            $methodsrun << :get_actual_config
+            result = Puppet::TransBucket.new()
+            result.type = "testing"
+            result.name = "yayness"
+            result
+        end
+        
+        assert_nothing_raised do
+            client.getconfig
+        end
+        [:get_actual_config].each do |method|
+            assert($methodsrun.include?(method), "method %s was not run" % method)
+        end
+        assert(! $methodsrun.include?(:getplugins), "plugins were synced even tho disabled")
+
+        # Now set pluginsync
+        Puppet[:pluginsync] = true
+        $methodsrun.clear
+        
+        assert_nothing_raised do
+            client.getconfig
+        end
+        [:getplugins, :get_actual_config].each do |method|
+            assert($methodsrun.include?(method), "method %s was not run" % method)
+        end
+        
+        objects = client.objects
+        assert(objects.finalized?, "objects were not finalized")
+    end
+
+    def test_disable
+        FileUtils.mkdir_p(Puppet[:statedir])
+        manifest = mktestmanifest
+
+        master = mkmaster(manifest)
+
+        client = mkclient(master)
+
+        assert(! FileTest.exists?(@createdfile))
+
+        assert_nothing_raised {
+            client.disable
+        }
+
+        assert_nothing_raised {
+            client.run
+        }
+
+        assert(! FileTest.exists?(@createdfile), "Disabled client ran")
+
+        assert_nothing_raised {
+            client.enable
+        }
+
+        assert_nothing_raised {
+            client.run
+        }
+
+        assert(FileTest.exists?(@createdfile), "Enabled client did not run")
+    end
+
+    # Make sure we're getting the client version in our list of facts
+    def test_clientversionfact
+        facts = nil
+        assert_nothing_raised {
+            facts = Puppet::Network::Client::MasterClient.facts
+        }
+
+        assert_equal(Puppet.version.to_s, facts["clientversion"])
+        
+    end
+
+    # Make sure non-string facts don't make things go kablooie
+    def test_nonstring_facts
+        FileUtils.mkdir_p(Puppet[:statedir])
+        # Add a nonstring fact
+        Facter.add("nonstring") do
+            setcode { 1 }
+        end
+
+        assert_equal(1, Facter.nonstring, "Fact was a string from facter")
+
+        client = mkclient()
+
+        assert(! FileTest.exists?(@createdfile))
+
+        assert_nothing_raised {
+            client.run
+        }
+    end
+    
+    # This method is supposed
+    def test_download
+        source = tempfile()
+        dest = tempfile()
+        sfile = File.join(source, "file")
+        dfile = File.join(dest, "file")
+        Dir.mkdir(source)
+        File.open(sfile, "w") {|f| f.puts "yay"}
+        
+        files = []
+        assert_nothing_raised do
+            files = Puppet::Network::Client::MasterClient.download(:dest => dest, :source => source, :name => "testing")
+        end
+        
+        assert(FileTest.directory?(dest), "dest dir was not created")
+        assert(FileTest.file?(dfile), "dest file was not created")
+        assert_equal(File.read(sfile), File.read(dfile), "Dest file had incorrect contents")
+        assert_equal([dest, dfile].sort, files.sort, "Changed files were not returned correctly")
+    end
+
+    def test_getplugins
+        Puppet[:pluginsource] = tempfile()
+        Dir.mkdir(Puppet[:pluginsource])
+
+        myplugin = File.join(Puppet[:pluginsource], "myplugin.rb")
+        File.open(myplugin, "w") do |f|
+            f.puts %{Puppet::Type.newtype(:myplugin) do
+    newparam(:argument) do
+        isnamevar
+    end
+end
+}
+        end
+
+        assert_nothing_raised {
+            Puppet::Network::Client::MasterClient.getplugins
+        }
+
+        destfile = File.join(Puppet[:plugindest], "myplugin.rb")
+
+        assert(File.exists?(destfile), "Did not get plugin")
+
+        obj = Puppet::Type.type(:myplugin)
+
+        assert(obj, "Did not define type")
+
+        assert(obj.validattr?(:argument),
+            "Did not get namevar")
+
+        # Now modify the file and make sure the type is replaced
+        File.open(myplugin, "w") do |f|
+            f.puts %{Puppet::Type.newtype(:myplugin) do
+    newparam(:yayness) do
+        isnamevar
+    end
+
+    newparam(:rahness) do
+    end
+end
+}
+        end
+
+        assert_nothing_raised {
+            Puppet::Network::Client::MasterClient.getplugins
+        }
+
+        destfile = File.join(Puppet[:pluginpath], "myplugin.rb")
+
+        obj = Puppet::Type.type(:myplugin)
+
+        assert(obj, "Did not define type")
+
+        assert(obj.validattr?(:yayness),
+            "Did not get namevar")
+
+        assert(obj.validattr?(:rahness),
+            "Did not get other var")
+
+        assert(! obj.validattr?(:argument),
+            "Old namevar is still valid")
+
+        # Now try it again, to make sure we don't have any objects lying around
+        assert_nothing_raised {
+            Puppet::Network::Client::MasterClient.getplugins
+        }
+    end
+
+    def test_getfacts
+        Puppet[:factsource] = tempfile()
+        Dir.mkdir(Puppet[:factsource])
+        hostname = Facter.value(:hostname)
+
+        myfact = File.join(Puppet[:factsource], "myfact.rb")
+        File.open(myfact, "w") do |f|
+            f.puts %{Facter.add("myfact") do
+            setcode { "yayness" }
+end
+}
+        end
+
+        assert_nothing_raised {
+            Puppet::Network::Client::MasterClient.getfacts
+        }
+
+        destfile = File.join(Puppet[:factdest], "myfact.rb")
+
+        assert(File.exists?(destfile), "Did not get fact")
+
+        assert_equal(hostname, Facter.value(:hostname),
+            "Lost value to hostname")
+        assert_equal("yayness", Facter.value(:myfact),
+            "Did not get correct fact value")
+
+        # Now modify the file and make sure the type is replaced
+        File.open(myfact, "w") do |f|
+            f.puts %{Facter.add("myfact") do
+            setcode { "funtest" }
+end
+}
+        end
+
+        assert_nothing_raised {
+            Puppet::Network::Client::MasterClient.getfacts
+        }
+
+        assert_equal("funtest", Facter.value(:myfact),
+            "Did not reload fact")
+        assert_equal(hostname, Facter.value(:hostname),
+            "Lost value to hostname")
+
+        # Now run it again and make sure the fact still loads
+        assert_nothing_raised {
+            Puppet::Network::Client::MasterClient.getfacts
+        }
+
+        assert_equal("funtest", Facter.value(:myfact),
+            "Did not reload fact")
+        assert_equal(hostname, Facter.value(:hostname),
+            "Lost value to hostname")
+    end
+
+    # Make sure we load all facts on startup.
+    def test_loadfacts
+        dirs = [tempfile(), tempfile()]
+        count = 0
+        names = []
+        dirs.each do |dir|
+            Dir.mkdir(dir)
+            name = "fact%s" % count
+            names << name
+            file = File.join(dir, "%s.rb" % name)
+
+            # Write out a plugin file
+            File.open(file, "w") do |f|
+                f.puts %{Facter.add("#{name}") do setcode { "#{name}" } end }
+            end
+            count += 1
+        end
+
+        Puppet[:factpath] = dirs.join(":")
+
+        names.each do |name|
+            assert_nil(Facter.value(name), "Somehow retrieved invalid fact")
+        end
+
+        assert_nothing_raised {
+            Puppet::Network::Client::MasterClient.loadfacts
+        }
+
+        names.each do |name|
+            assert_equal(name, Facter.value(name),
+                    "Did not retrieve facts")
+        end
+    end
+
+    if Process.uid == 0
+    # Testing #283.  Make sure plugins et al are downloaded as the running user.
+    def test_download_ownership
+        dir = tstdir()
+        dest = tstdir()
+        file = File.join(dir, "file")
+        File.open(file, "w") { |f| f.puts "funtest" }
+
+        user = nonrootuser()
+        group = nonrootgroup()
+        chowner = Puppet::Type.type(:file).create :path => dir,
+            :owner => user.name, :group => group.name, :recurse => true
+        assert_apply(chowner)
+        chowner.remove
+
+        assert_equal(user.uid, File.stat(file).uid)
+        assert_equal(group.gid, File.stat(file).gid)
+
+
+        assert_nothing_raised {
+            Puppet::Network::Client::MasterClient.download(:dest => dest, :source => dir,
+                :name => "testing"
+            ) {}
+        }
+
+        destfile = File.join(dest, "file")
+
+        assert(FileTest.exists?(destfile), "Did not create destfile")
+
+        assert_equal(Process.uid, File.stat(destfile).uid)
+    end
+    end
+    
+    # Test retrieving all of the facts.
+    def test_facts
+        facts = nil
+        assert_nothing_raised do
+            facts = Puppet::Network::Client::MasterClient.facts
+        end
+        Facter.to_hash.each do |fact, value|
+            assert_equal(facts[fact.downcase], value, "%s is not equal" % fact.inspect)
+        end
+        
+        # Make sure the puppet version got added
+        assert_equal(Puppet::PUPPETVERSION, facts["clientversion"], "client version did not get added")
+        
+        # And make sure the ruby version is in there
+        assert_equal(RUBY_VERSION, facts["rubyversion"], "ruby version did not get added")
+    end
+    
+    # #424
+    def test_caching_of_compile_time
+        file = tempfile()
+        manifest = tempfile()
+        File.open(manifest, "w") { |f| f.puts "file { '#{file}': content => yay }" }
+        
+        driver = mkmaster(manifest)
+        driver.local = false
+        master = mkclient(driver)
+        
+        # We have to make everything thinks it's remote, because there's no local caching info
+        master.local = false
+        
+        assert(! master.fresh?, "Considered fresh with no compile at all")
+        
+        assert_nothing_raised { master.run }
+        assert(master.fresh?, "not considered fresh after compile")
+        
+        # Now make sure the config time is cached
+        assert(master.compile_time, "No stored config time")
+        assert_equal(master.compile_time, Puppet::Util::Storage.cache(:configuration)[:compile_time], "times did not match")
+        time = master.compile_time
+        master.clear
+        File.unlink(file)
+        Puppet::Util::Storage.store
+        
+        # Now make a new master
+        Puppet::Util::Storage.clear
+        master = mkclient(driver)
+        master.run
+        assert_equal(time, master.compile_time, "time was not retrieved from cache")
+        assert(FileTest.exists?(file), "file was not created on second run")
+    end
+
+    def test_default_objects
+        # Make sure they start out missing
+        assert_nil(Puppet::Type.type(:filebucket)["puppet"],
+            "default filebucket already exists")
+        assert_nil(Puppet::Type.type(:schedule)["daily"],
+            "default schedules already exists")
+
+        master = mkclient()
+
+        # Now make sure they got created
+        assert(Puppet::Type.type(:filebucket)["puppet"],
+            "default filebucket not found")
+        assert(Puppet::Type.type(:schedule)["daily"],
+            "default schedules not found")
+
+        # clear everything, and make sure we can recreate them
+        Puppet::Type.allclear
+        assert_nil(Puppet::Type.type(:filebucket)["puppet"],
+            "default filebucket not removed")
+        assert_nil(Puppet::Type.type(:schedule)["daily"],
+            "default schedules not removed")
+        assert_nothing_raised  { master.mkdefault_objects }
+        assert(Puppet::Type.type(:filebucket)["puppet"],
+            "default filebucket not found")
+        assert(Puppet::Type.type(:schedule)["daily"],
+            "default schedules not found")
+
+
+        # Make sure we've got schedules
+        assert(Puppet::Type.type(:schedule)["hourly"], "Could not retrieve hourly schedule")
+        assert(Puppet::Type.type(:filebucket)["puppet"], "Could not retrieve default bucket")
+    end
+end
+
+# $Id$
diff --git a/test/network/client/networkclient.rb b/test/network/client/networkclient.rb
new file mode 100755
index 000000000..957a1ceda
--- /dev/null
+++ b/test/network/client/networkclient.rb
@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/client'
+
+class TestClient < Test::Unit::TestCase
+    def test_set_backtrace
+        error = Puppet::Network::NetworkClientError.new("An error")
+        assert_nothing_raised do
+            error.set_backtrace ["caller"]
+        end
+    end
+end
+
+# $Id$
+
diff --git a/test/network/client/resource.rb b/test/network/client/resource.rb
new file mode 100755
index 000000000..fcbb367ca
--- /dev/null
+++ b/test/network/client/resource.rb
@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/network/client/resource'
+
+class TestResourceClient < Test::Unit::TestCase
+    include PuppetTest::ServerTest
+
+    def mkresourceserver
+        handlers = {
+            :CA => {}, # so that certs autogenerate
+            :Resource => {},
+        }
+
+        return mkserver(handlers)
+    end
+
+    def mkclient
+        client = nil
+        assert_nothing_raised {
+            client = Puppet::Network::Client::Resource.new(:Server => "localhost",
+                :Port => @@port)
+        }
+
+        return client
+    end
+
+    def test_resources
+        file = tempfile()
+        text = "yayness\n"
+        File.open(file, "w") { |f| f.print text }
+
+        mkresourceserver()
+
+        client = mkclient()
+
+        # Test describing
+        tobj = nil
+        assert_nothing_raised {
+            tobj = client.describe("file", file)
+        }
+
+        assert(tobj, "Did not get response")
+
+        assert_instance_of(Puppet::TransObject, tobj)
+
+        obj = nil
+        assert_nothing_raised {
+            obj = tobj.to_type
+        }
+        assert_events([], obj)
+        File.unlink(file)
+        assert_events([:file_created], obj)
+        File.unlink(file)
+
+        # Now test applying
+        result = nil
+        assert_nothing_raised {
+            result = client.apply(tobj)
+        }
+        assert(FileTest.exists?(file), "File was not created on apply")
+
+        # Lastly, test "list"
+        list = nil
+        assert_nothing_raised {
+            list = client.list("user")
+        }
+
+        assert_instance_of(Puppet::TransBucket, list)
+
+        count = 0
+        list.each do |tobj|
+            break if count > 3
+            assert_instance_of(Puppet::TransObject, tobj)
+
+            tobj2 = nil
+            assert_nothing_raised {
+                tobj2 = client.describe(tobj.type, tobj.name)
+            }
+
+            obj = nil
+            assert_nothing_raised {
+                obj = tobj2.to_type
+            }
+            assert_events([], obj)
+
+            count += 1
+        end
+    end
+end
+
+# $Id$