puppet 0.9.2

data/test/tagging/tagging.rb

@@ -0,0 +1,80 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestTagging < Test::Unit::TestCase
+    include TestPuppet
+
+    # Make sure the scopes are getting the right tags
+    def test_scopetags
+        scope = nil
+        assert_nothing_raised {
+            scope = Puppet::Parser::Scope.new()
+            scope.name = "yayness"
+            scope.type = "solaris"
+        }
+
+        assert_nothing_raised {
+            assert_equal(%w{solaris}, scope.tags, "Incorrect scope tags")
+        }
+    end
+
+    # Test deeper tags, where a scope gets all of its parent scopes' tags
+    def test_deepscopetags
+        scope = nil
+        assert_nothing_raised {
+            scope = Puppet::Parser::Scope.new()
+            scope.name = "yayness"
+            scope.type = "solaris"
+            scope = scope.newscope
+            scope.name = "booness"
+            scope.type = "apache"
+        }
+
+        assert_nothing_raised {
+            # Scopes put their own tags first
+            assert_equal(%w{apache solaris}, scope.tags, "Incorrect scope tags")
+        }
+    end
+
+    # Verify that the tags make their way to the objects
+    def test_objecttags
+        scope = nil
+        assert_nothing_raised {
+            scope = Puppet::Parser::Scope.new()
+            scope.name = "yayness"
+            scope.type = "solaris"
+        }
+
+        assert_nothing_raised {
+            scope.setobject(
+                "file",
+                "/etc/passwd",
+                {"owner" => "root"},
+                "/yay",
+                1
+            )
+        }
+
+        objects = nil
+        assert_nothing_raised {
+            objects = scope.to_trans
+        }
+
+        # There's only one object, so shift it out
+        object = objects.shift
+
+        assert_nothing_raised {
+            assert_equal(%w{solaris}, object.tags,
+                "Incorrect tags")
+        }
+    end
+end
+
+# $Id: tagging.rb 737 2005-10-30 04:07:52Z luke $

data/test/test

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+#------------------------------------------------------------
+# run any or all test suites
+
+basedir = File.dirname(__FILE__)
+$puppetbase = File.expand_path(File.join(basedir, ".."))
+
+$:.unshift basedir
+$:.unshift "#{$puppetbase}/lib"
+
+
+require 'puppettest.rb'
+require 'getoptlong'
+
+	#[ "--size",	"-s",			GetoptLong::REQUIRED_ARGUMENT ],
+result = GetoptLong.new(
+	[ "--debug",	"-d",			GetoptLong::NO_ARGUMENT ],
+	[ "--help",		"-h",			GetoptLong::NO_ARGUMENT ]
+)
+
+usage = "USAGE: %s [--help] <testsuite> <testsuite> .." % $0
+
+result.each { |opt,arg|
+	case opt
+		when "--debug"
+            Puppet[:debug] = true
+		when "--help"
+			puts usage
+			exit
+		else
+			raise "Invalid option '#{opt}'"
+	end
+}
+
+suites = nil
+
+if ARGV.length != 0
+    suites = ARGV
+else
+    suites = PuppetTestSuite.list
+end
+
+suites.each { |suite|
+    PuppetTestSuite.new(suite)
+}
+
+# This damn problem just doesn't seem to want to go away
+system("%s/etc/init.d/sleeper stop 2>/dev/null 1>/dev/null" % $puppetbase)
+
+# $Id: test 750 2005-11-22 05:34:43Z luke $

data/test/types/basic.rb

@@ -0,0 +1,119 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestBasic < Test::Unit::TestCase
+	include TestPuppet
+    # hmmm
+    # this is complicated, because we store references to the created
+    # objects in a central store
+    def setup
+        super
+        @component = nil
+        @configfile = nil
+        @sleeper = nil
+
+        Puppet[:loglevel] = :debug if __FILE__ == $0
+
+        assert_nothing_raised() {
+            @component = Puppet::Type::Component.create(
+                :name => "yaytest",
+                :type => "testing"
+            )
+        }
+
+        assert_nothing_raised() {
+            @filepath = tempfile()
+            @@tmpfiles << @filepath
+            @configfile = Puppet::Type::PFile.create(
+                :path => @filepath,
+                :create => true,
+                :checksum => "md5"
+            )
+        }
+        assert_nothing_raised() {
+            @sleeper = Puppet::Type::Service.create(
+                :name => "sleeper",
+                :type => "init",
+                :path => File.join($puppetbase,"examples/root/etc/init.d"),
+                :hasstatus => true,
+                :running => 1
+            )
+        }
+        assert_nothing_raised() {
+            @component.push(
+                @configfile,
+                @sleeper
+            )
+        }
+        
+        #puts "Component is %s, id %s" % [@component, @component.object_id]
+        #puts "ConfigFile is %s, id %s" % [@configfile, @configfile.object_id]
+    end
+
+    def test_name_calls
+        [@sleeper,@configfile].each { |obj|
+            Puppet.debug "obj is %s" % obj
+            assert_nothing_raised(){
+                obj.name
+            }
+        }
+    end
+
+    def test_name_equality
+        #puts "Component is %s, id %s" % [@component, @component.object_id]
+        assert_equal(
+            @filepath,
+            @configfile.name
+        )
+
+        assert_equal(
+            "sleeper",
+            @sleeper.name
+        )
+    end
+
+    def test_object_retrieval
+        [@sleeper,@configfile].each { |obj|
+            assert_equal(
+                obj.class[obj.name].object_id,
+                obj.object_id
+            )
+        }
+    end
+
+    def test_transaction
+        transaction = nil
+        assert_nothing_raised() {
+            transaction = @component.evaluate
+        }
+        assert_nothing_raised() {
+            transaction.evaluate
+        }
+        assert_nothing_raised() {
+            @sleeper[:running] = 0
+        }
+        assert_nothing_raised() {
+            transaction = @component.evaluate
+        }
+        assert_nothing_raised() {
+            transaction.evaluate
+        }
+    end
+
+    def test_paths
+        [@configfile,@sleeper,@component].each { |obj|
+            assert_nothing_raised {
+                assert_instance_of(String, obj.path)
+            }
+        }
+    end
+end
+
+# $Id: basic.rb 737 2005-10-30 04:07:52Z luke $

data/test/types/component.rb

@@ -0,0 +1,272 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../../../../language/trunk"
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+# $Id: component.rb 742 2005-11-16 17:12:11Z luke $
+
+class TestComponent < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        @@used = {}
+    end
+
+    def randnum(limit)
+        num = nil
+        looped = 0
+        loop do
+            looped += 1
+            if looped > 1000
+                raise "Reached limit of looping"
+                break
+            end
+            num = rand(limit)
+            unless @@used.include?(num)
+                @@used[num] = true
+                break
+            end
+        end
+
+        num
+    end
+
+    def mkfile(num = nil)
+        unless num
+            num = randnum(1000)
+        end
+        name = "/tmp/componentrandfile" + num.to_s
+
+        file = Puppet::Type::PFile.create(
+            :path => name,
+            :checksum => "md5"
+        )
+        @@tmpfiles << name
+        file
+    end
+
+    def mkcomp
+        Puppet::Type::Component.create(:name => "component_" + randnum(1000).to_s)
+    end
+
+    def mkrandcomp(numfiles, numdivs)
+        comp = mkcomp
+        hash = {}
+        found = 0
+
+        divs = {}
+
+        numdivs.times { |i|
+            num = i + 2
+            divs[num] = nil
+        }
+        while found < numfiles
+            num = randnum(numfiles)
+            found += 1
+            f = mkfile(num)
+            hash[f.name] = f
+            reqd = []
+            divs.each { |n,obj|
+                if rand(50) % n == 0
+                    if obj
+                        unless reqd.include?(obj.object_id)
+                            f[:require] = [[obj.class.name, obj.name]]
+                            reqd << obj.object_id
+                        end
+                    end
+                end
+
+                divs[n] = f
+            }
+        end
+
+        hash.each { |name, obj|
+            comp.push obj
+        }
+
+        comp
+    end
+
+    def test_ordering
+        list = nil
+        comp = mkrandcomp(30,5)
+        assert_nothing_raised {
+            list = comp.flatten
+        }
+
+        list.each_with_index { |obj, index|
+            obj.eachdependency { |dep|
+                assert(list.index(dep) < index)
+            }
+        }
+    end
+
+    def test_correctsorting
+        tmpfile = "/tmp/comptesting"
+        @@tmpfiles.push tmpfile
+        trans = nil
+        cmd = nil
+        File.open(tmpfile, File::WRONLY|File::CREAT|File::TRUNC) { |of|
+            of.puts rand(100)
+        }
+        file = Puppet::Type::PFile.create(
+            :path => tmpfile,
+            :checksum => "md5"
+        )
+        assert_nothing_raised {
+            cmd = Puppet::Type::Exec.create(
+                :command => "pwd",
+                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
+                :subscribe => [[file.class.name,file.name]],
+                :refreshonly => true
+            )
+        }
+
+        order = nil
+        assert_nothing_raised {
+            order = Puppet::Type::Component.sort([file, cmd])
+        }
+
+        [cmd, file].each { |obj|
+            assert_equal(1, order.find_all { |o| o.name == obj.name }.length)
+        }
+    end
+
+    def test_correctflattening
+        tmpfile = "/tmp/comptesting"
+        @@tmpfiles.push tmpfile
+        trans = nil
+        cmd = nil
+        File.open(tmpfile, File::WRONLY|File::CREAT|File::TRUNC) { |of|
+            of.puts rand(100)
+        }
+        file = Puppet::Type::PFile.create(
+            :path => tmpfile,
+            :checksum => "md5"
+        )
+        assert_nothing_raised {
+            cmd = Puppet::Type::Exec.create(
+                :command => "pwd",
+                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
+                :subscribe => [[file.class.name,file.name]],
+                :refreshonly => true
+            )
+        }
+
+        comp = Puppet::Type::Component.create(:name => "RefreshTest")
+        [cmd, file].each { |obj|
+            comp.push obj
+        }
+        objects = nil
+        assert_nothing_raised {
+            objects = comp.flatten
+        }
+
+        [cmd, file].each { |obj|
+            assert_equal(1, objects.find_all { |o| o.name == obj.name }.length)
+        }
+
+        assert(objects[0] == file, "File was not first object")
+        assert(objects[1] == cmd, "Exec was not second object")
+    end
+
+    def test_deepflatten
+        tmpfile = tempfile()
+        @@tmpfiles.push tmpfile
+        trans = nil
+        cmd = nil
+        File.open(tmpfile, File::WRONLY|File::CREAT|File::TRUNC) { |of|
+            of.puts rand(100)
+        }
+        file = Puppet::Type::PFile.create(
+            :path => tmpfile,
+            :checksum => "md5"
+        )
+        assert_nothing_raised {
+            cmd = Puppet::Type::Exec.create(
+                :command => "pwd",
+                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
+                :refreshonly => true
+            )
+        }
+
+        fcomp = newcomp("fflatten", file)
+        ecomp = newcomp("eflatten", cmd)
+
+        # this subscription can screw up the sorting
+        ecomp[:subscribe] = [[fcomp.class.name,fcomp.name]]
+
+        comp = newcomp("bflatten", ecomp, fcomp)
+        objects = nil
+        assert_nothing_raised {
+            objects = comp.flatten
+        }
+
+        assert_equal(objects.length, 2, "Did not get two sorted objects")
+        objects.each { |o|
+            assert(o.is_a?(Puppet::Type), "Object %s is not a Type" % o.class)
+        }
+
+        assert(objects[0] == file, "File was not first object")
+        assert(objects[1] == cmd, "Exec was not second object")
+    end
+
+    def test_deepflatten2
+        tmpfile = tempfile()
+        @@tmpfiles.push tmpfile
+        trans = nil
+        cmd = nil
+        File.open(tmpfile, File::WRONLY|File::CREAT|File::TRUNC) { |of|
+            of.puts rand(100)
+        }
+        file = Puppet::Type::PFile.create(
+            :path => tmpfile,
+            :checksum => "md5"
+        )
+        assert_nothing_raised {
+            cmd = Puppet::Type::Exec.create(
+                :command => "pwd",
+                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
+                :refreshonly => true
+            )
+        }
+
+        ocmd = nil
+        assert_nothing_raised {
+            ocmd = Puppet::Type::Exec.create(
+                :command => "echo true",
+                :path => "/usr/bin:/bin:/usr/sbin:/sbin",
+                :refreshonly => true
+            )
+        }
+
+        fcomp = newcomp("fflatten", file)
+        ecomp = newcomp("eflatten", cmd)
+        ocomp = newcomp("oflatten", ocmd)
+
+        # this subscription can screw up the sorting
+        cmd[:subscribe] = [[fcomp.class.name,fcomp.name]]
+        ocmd[:subscribe] = [[cmd.class.name,cmd.name]]
+
+        comp = newcomp("bflatten", ocomp, ecomp, fcomp)
+        objects = nil
+        assert_nothing_raised {
+            objects = comp.flatten
+        }
+
+        assert_equal(objects.length, 3, "Did not get three sorted objects")
+
+        objects.each { |o|
+            assert(o.is_a?(Puppet::Type), "Object %s is not a Type" % o.class)
+        }
+
+        assert(objects[0] == file, "File was not first object")
+        assert(objects[1] == cmd, "Exec was not second object")
+        assert(objects[2] == ocmd, "Other exec was not second object")
+    end
+end