puppet 0.13.6 → 0.16.0

data/test/server/master.rb

@@ -34,7 +34,7 @@ class TestMaster < Test::Unit::TestCase
             assert_nothing_raised() {
                 # this is the default server setup
                 master = Puppet::Server::Master.new(
-                    :File => file,
+                    :Manifest => file,
                     :UseNodes => false,
                     :Local => true
                 )
@@ -79,7 +79,7 @@ class TestMaster < Test::Unit::TestCase
             assert_nothing_raised() {
                 # this is the default server setup
                 master = Puppet::Server::Master.new(
-                    :File => file,
+                    :Manifest => file,
                     :UseNodes => false,
                     :Local => true
                 )
@@ -111,7 +111,7 @@ class TestMaster < Test::Unit::TestCase
         assert_nothing_raised() {
             # this is the default server setup
             master = Puppet::Server::Master.new(
-                :File => manifest,
+                :Manifest => manifest,
                 :UseNodes => false,
                 :Local => true,
                 :FileTimeout => 15
@@ -173,7 +173,30 @@ class TestMaster < Test::Unit::TestCase
         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::Server::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
 end
 
-# $Id: master.rb 845 2006-01-18 21:30:56Z luke $
+# $Id: master.rb 1102 2006-04-11 16:12:38Z luke $
 

data/test/server/pelement.rb

@@ -0,0 +1,298 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server/pelement'
+require 'test/unit'
+require 'puppettest.rb'
+require 'base64'
+require 'cgi'
+
+class TestPElementServer < Test::Unit::TestCase
+	include ServerTest
+
+    def verify_described(type, described)
+        described.each do |name, trans|
+            type.clear
+            obj = nil
+            assert_nothing_raised do
+                obj = trans.to_type
+            end
+
+            assert(obj, "Could not create object")
+            assert_nothing_raised do
+                obj.retrieve
+            end
+
+            assert(obj.insync?, "Described %s[%s] is not in sync" %
+                [trans.type, name])
+
+            if trans.type == :package
+                assert_equal(Puppet::Type.type(:package).default, obj[:type])
+            end
+        end
+        type.clear
+    end
+
+    def test_describe_file
+        # Make a file to describe
+        file = tempfile()
+        str = "yayness\n"
+
+        server = nil
+
+        assert_nothing_raised do
+            server = Puppet::Server::PElement.new()
+        end
+
+        # The first run we create the file on the copy, the second run
+        # the file is already there so the object should be in sync
+        2.times do |i|
+            [   [nil],
+                [[:content, :mode], []],
+                [[], [:content]],
+                [[:content], [:mode]]
+            ].each do |ary|
+                retrieve = ary[0] || []
+                ignore = ary[1] || []
+
+                File.open(file, "w") { |f| f.print str }
+
+                result = nil
+                assert_nothing_raised do
+                    result = server.describe("file", file, *ary)
+                end
+
+                assert(result, "Could not retrieve file information")
+
+                assert_instance_of(Puppet::TransObject, result)
+
+                # Now we have to clear, so that the server's object gets removed
+                Puppet::Type.type(:file).clear
+
+                # And remove the file, so we can verify it gets recreated
+                if i == 0
+                    File.unlink(file)
+                end
+
+                object = nil
+                assert_nothing_raised do
+                    object = result.to_type
+                end
+
+                assert(object, "Could not create type")
+
+                retrieve.each do |state|
+                    assert(object.should(state), "Did not retrieve %s" % state)
+                end
+
+                ignore.each do |state|
+                    assert(! object.should(state), "Incorrectly retrieved %s" % state)
+                end
+
+                if i == 0
+                    assert_events([:file_created], object)
+                else
+                    assert_nothing_raised {
+                        object.retrieve
+                    }
+                    assert(object.insync?, "Object was not in sync")
+                end
+
+                assert(FileTest.exists?(file), "File did not get recreated")
+
+                if i == 0
+                if object.should(:content)
+                    assert_equal(str, File.read(file), "File contents are not the same")
+                else
+                    assert_equal("", File.read(file), "File content was incorrectly made")
+                end
+                end
+                if FileTest.exists? file
+                    File.unlink(file)
+                end
+            end
+        end
+    end
+
+    def test_describe_directory
+        # Make a file to describe
+        file = tempfile()
+
+        server = nil
+
+        assert_nothing_raised do
+            server = Puppet::Server::PElement.new()
+        end
+
+        [   [nil],
+            [[:ensure, :checksum, :mode], []],
+            [[], [:checksum]],
+            [[:ensure, :checksum], [:mode]]
+        ].each do |ary|
+            retrieve = ary[0] || []
+            ignore = ary[1] || []
+
+            Dir.mkdir(file)
+
+            result = nil
+            assert_nothing_raised do
+                result = server.describe("file", file, *ary)
+            end
+
+            assert(result, "Could not retrieve file information")
+
+            assert_instance_of(Puppet::TransObject, result)
+
+            # Now we have to clear, so that the server's object gets removed
+            Puppet::Type.type(:file).clear
+
+            # And remove the file, so we can verify it gets recreated
+            Dir.rmdir(file)
+
+            object = nil
+            assert_nothing_raised do
+                object = result.to_type
+            end
+
+            assert(object, "Could not create type")
+
+            retrieve.each do |state|
+                assert(object.should(state), "Did not retrieve %s" % state)
+            end
+
+            ignore.each do |state|
+                assert(! object.should(state), "Incorrectly retrieved %s" % state)
+            end
+
+            assert_events([:directory_created], object)
+
+            assert(FileTest.directory?(file), "Directory did not get recreated")
+            Dir.rmdir(file)
+        end
+    end
+
+    def test_describe_alltypes
+        # Systems get pretty retarded, so I'm going to set the path to some fake
+        # data for ports
+        #Puppet::Type::ParsedType::Port.path = File.join($puppetbase,
+        #    "test/data/types/ports/1")
+        #Puppet.err Puppet::Type::ParsedType::Port.path
+        server = nil
+        assert_nothing_raised do
+            server = Puppet::Server::PElement.new()
+        end
+
+        require 'etc'
+
+        # Make the example schedules, for testing
+        Puppet::Type.type(:schedule).mkdefaultschedules
+
+        Puppet::Type.eachtype do |type|
+            unless type.respond_to? :list
+                Puppet.warning "%s does not respond to :list" % type.name
+                next
+            end
+            #next unless type.name == :port
+            Puppet.info "Describing each %s" % type.name
+
+            # First do a listing from the server
+            bucket = nil
+            assert_nothing_raised {
+                bucket = server.list(type.name)
+            }
+
+            #type.clear
+
+            count = 0
+            described = {}
+            bucket.each do |obj|
+                assert_instance_of(Puppet::TransObject, obj)
+                break if count > 5
+                described[obj.name] = server.describe(obj.type, obj.name)
+                count += 1
+            end
+
+            verify_described(type, described)
+
+            count = 0
+            described = {}
+            type.list.each do |obj|
+                assert_instance_of(type, obj)
+
+                break if count > 5
+                trans = nil
+                assert_nothing_raised do
+                    described[obj.name] = server.describe(type.name, obj.name)
+                end
+
+                count += 1
+            end
+
+            if described.empty?
+                Puppet.notice "Got no example objects for %s" % type.name
+            end
+
+            # We separate these, in case the list operation creates objects
+            verify_described(type, described)
+        end
+    end
+
+    def test_apply
+        server = nil
+        assert_nothing_raised do
+            server = Puppet::Server::PElement.new()
+        end
+
+        file = tempfile()
+        str = "yayness\n"
+
+        File.open(file, "w") { |f| f.print str }
+
+        filetrans = nil
+        assert_nothing_raised {
+            filetrans = server.describe("file", file)
+        }
+
+        Puppet::Type.type(:file).clear
+
+        bucket = Puppet::TransBucket.new
+        bucket.type = "file"
+        bucket.push filetrans
+
+        File.unlink(file)
+        assert_nothing_raised {
+            server.apply(bucket)
+        }
+
+        assert(FileTest.exists?(file), "File did not get recreated")
+
+        # Now try it as a "nonlocal" server
+        server.local = false
+        yaml = nil
+        assert_nothing_raised {
+            yaml = CGI.escape(YAML::dump(bucket))
+        }
+
+        Puppet::Type.type(:file).clear
+        File.unlink(file)
+
+        if yaml =~ /(.{20}Loglevel.{20})/
+            Puppet.warning "YAML is broken on this machine"
+            return
+        end
+        assert_nothing_raised("Could not reload yaml") {
+            YAML::load(CGI.unescape(yaml))
+        }
+
+        assert_nothing_raised {
+            server.apply(yaml)
+        }
+        assert(FileTest.exists?(file), "File did not get recreated from YAML")
+    end
+end
+
+# $Id: pelement.rb 1129 2006-04-21 19:14:59Z luke $

data/test/server/rights.rb

@@ -0,0 +1,41 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/server/rights'
+require 'test/unit'
+require 'puppettest.rb'
+
+class TestRights < Test::Unit::TestCase
+	include TestPuppet
+
+    def test_rights
+        store = nil
+        assert_nothing_raised {
+            store = Puppet::Server::Rights.new
+        }
+
+        assert(store, "Did not create store")
+
+        assert_raise(ArgumentError, "Did not fail on unknown right") {
+            store.allowed?(:write, "host.madstop.com", "0.0.0.0")
+        }
+
+        assert_nothing_raised {
+            store.newright(:write)
+        }
+
+        assert(! store.allowed?(:write, "host.madstop.com", "0.0.0.0"),
+            "Defaulted to allowing access")
+
+        assert_nothing_raised {
+            store[:write].info "This is a log message"
+        }
+    end
+end
+
+# $Id: rights.rb 1129 2006-04-21 19:14:59Z luke $
+

data/test/server/server.rb

@@ -13,7 +13,7 @@ require 'xmlrpc/client'
 require 'test/unit'
 require 'puppettest.rb'
 
-# $Id: server.rb 816 2006-01-12 21:04:06Z luke $
+# $Id: server.rb 1068 2006-04-04 23:13:55Z luke $
 
 if ARGV.length > 0 and ARGV[0] == "short"
     $short = true
@@ -85,7 +85,7 @@ class TestServer < Test::Unit::TestCase
                     :CA => {}, # so that certs autogenerate
                     :Master => {
                         :UseNodes => false,
-                        :File => file
+                        :Manifest => file
                     },
                     :Status => nil
                 }

data/test/tagging/tagging.rb

@@ -75,6 +75,105 @@ class TestTagging < Test::Unit::TestCase
                 "Incorrect tags")
         }
     end
+
+    # Make sure that specifying tags results in only those objects getting
+    # run.
+    def test_tagspecs
+        a = tempfile()
+        b = tempfile()
+
+        afile = Puppet.type(:file).create(
+            :path => a,
+            :ensure => :file
+        )
+        afile.tag("a")
+
+        bfile = Puppet.type(:file).create(
+            :path => b,
+            :ensure => :file
+        )
+        bfile.tag(:b)
+
+        # First, make sure they get created when no spec'ed tags
+        assert_events([:file_created,:file_created], afile, bfile)
+        assert(FileTest.exists?(a), "A did not get created")
+        assert(FileTest.exists?(b), "B did not get created")
+        File.unlink(a)
+        File.unlink(b)
+
+        # Set the tags to a
+        assert_nothing_raised {
+            Puppet[:tags] = "a"
+        }
+
+        assert_events([:file_created], afile, bfile)
+        assert(FileTest.exists?(a), "A did not get created")
+        assert(!FileTest.exists?(b), "B got created")
+        File.unlink(a)
+
+        # Set the tags to b
+        assert_nothing_raised {
+            Puppet[:tags] = "b"
+        }
+
+        assert_events([:file_created], afile, bfile)
+        assert(!FileTest.exists?(a), "A got created")
+        assert(FileTest.exists?(b), "B did not get created")
+        File.unlink(b)
+
+        # Set the tags to something else
+        assert_nothing_raised {
+            Puppet[:tags] = "c"
+        }
+
+        assert_events([], afile, bfile)
+        assert(!FileTest.exists?(a), "A got created")
+        assert(!FileTest.exists?(b), "B got created")
+
+        # Now set both tags
+        assert_nothing_raised {
+            Puppet[:tags] = "b, a"
+        }
+
+        assert_events([:file_created, :file_created], afile, bfile)
+        assert(FileTest.exists?(a), "A did not get created")
+        assert(FileTest.exists?(b), "B did not get created")
+        File.unlink(a)
+
+    end
+
+    def test_metaparamtag
+        path = tempfile()
+
+        start = %w{some tags}
+        tags = %w{a list of tags}
+
+        obj = nil
+        assert_nothing_raised do
+            obj = Puppet.type(:file).create(
+                :path => path,
+                :ensure => "file",
+                :tag => start
+            )
+        end
+
+
+        assert(obj, "Did not make object")
+
+        start.each do |tag|
+            assert(obj.tagged?(tag), "Object was not tagged with %s" % tag)
+        end
+
+        tags.each do |tag|
+            assert_nothing_raised {
+                obj[:tag] = tag
+            }
+        end
+
+        tags.each do |tag|
+            assert(obj.tagged?(tag), "Object was not tagged with %s" % tag)
+        end
+    end
 end
 
-# $Id: tagging.rb 952 2006-02-27 22:21:44Z luke $
+# $Id: tagging.rb 1099 2006-04-11 15:30:19Z luke $