puppet 0.13.6 → 0.16.0

data/test/types/parameter.rb

@@ -0,0 +1,107 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet/type'
+require 'puppettest'
+require 'test/unit'
+
+class TestParameter < Test::Unit::TestCase
+	include TestPuppet
+    
+    def newparam(name = :fakeparam)
+        assert_nothing_raised {
+            param = Class.new(Puppet::Parameter) do
+                @name = :fakeparam
+            end
+            param.initvars
+
+            return param
+        }
+    end
+
+    def newinst(param)
+        assert_nothing_raised {
+            return param.new
+        }
+    end
+
+    # Test the basic newvalue stuff.
+    def test_newvalue
+        param = newparam()
+
+        # Try it with both symbols and strings.
+        assert_nothing_raised {
+            param.newvalues(:one, "two")
+        }
+
+        inst = newinst(param)
+
+        assert_nothing_raised {
+            inst.value = "one"
+        }
+
+        assert_equal(:one, inst.value)
+
+        assert_nothing_raised {
+            inst.value = :two
+        }
+        assert_equal(:two, inst.value)
+
+        assert_raise(ArgumentError) {
+            inst.value = :three
+        }
+        assert_equal(:two, inst.value)
+    end
+
+    # Test using regexes.
+    def test_regexvalues
+        param = newparam
+
+        assert_nothing_raised {
+            param.newvalues(/^\d+$/)
+        }
+        assert(param.match?("14"))
+        assert(param.match?(14))
+
+        inst = newinst(param)
+
+        assert_nothing_raised {
+            inst.value = 14
+        }
+
+        assert_nothing_raised {
+            inst.value = "14"
+        }
+
+        assert_raise(ArgumentError) {
+            inst.value = "a14"
+        }
+    end
+
+    # Test using both.  Equality should beat matching.
+    def test_regexesandnormals
+        param = newparam
+
+        assert_nothing_raised {
+            param.newvalues(:one, /^\w+$/)
+        }
+
+        inst = newinst(param)
+
+        assert_nothing_raised {
+            inst.value = "one"
+        }
+
+        assert_equal(:one, inst.value, "Value used regex instead of equality")
+
+        assert_nothing_raised {
+            inst.value = "two"
+        }
+        assert_equal("two", inst.value, "Matched value didn't take")
+    end
+end
+
+# $Id: parameter.rb 1000 2006-03-10 05:41:01Z luke $

data/test/types/port.rb

@@ -182,6 +182,7 @@ class TestPort < Test::Unit::TestCase
         port.delete(:alias)
         assert(! port.state(:alias))
         assert_events([:port_changed], port)
+
         assert_nothing_raised {
             port.retrieve
         }
@@ -197,4 +198,4 @@ class TestPort < Test::Unit::TestCase
     end
 end
 
-# $Id: port.rb 915 2006-02-15 21:56:54Z luke $
+# $Id: port.rb 1050 2006-04-01 20:31:47Z luke $

data/test/types/service.rb

@@ -236,7 +236,6 @@ class TestLocalService < Test::Unit::TestCase
     else
         def test_servicestartstop
             mktestsvcs.each { |svc|
-                svc[:check] = :enable
                 startstate = nil
                 assert_nothing_raised("Could not get status") {
                     startstate = svc.status
@@ -253,6 +252,7 @@ class TestLocalService < Test::Unit::TestCase
         def test_serviceenabledisable
             mktestsvcs.each { |svc|
                 startstate = nil
+                svc[:check] = :enable
                 assert_nothing_raised("Could not get status") {
                     startstate = svc.enabled?
                 }
@@ -264,8 +264,43 @@ class TestLocalService < Test::Unit::TestCase
                 Puppet.type(:component).clear
             }
         end
+
+        def test_serviceenableandrun
+            mktestsvcs.each do |svc|
+                startenable = nil
+                startensure = nil
+                svc[:check] = [:ensure, :enable]
+                svc.retrieve
+                assert_nothing_raised("Could not get status") {
+                    startenable = svc.state(:enable).is
+                    startensure = svc.state(:ensure).is
+                }
+
+                svc[:enable] = false
+                svc[:ensure] = :stopped
+                assert_apply(svc)
+
+                sleep 1
+                svc.retrieve
+                assert(svc.insync?, "Service did not sync both states")
+
+                svc[:enable] = true
+                svc[:ensure] = :running
+                assert_apply(svc)
+
+                sleep 1
+                svc.retrieve
+                assert(svc.insync?, "Service did not sync both states")
+
+                svc[:enable] = startenable
+                svc[:ensure] = startensure
+                assert_apply(svc)
+                Puppet.type(:service).clear
+                Puppet.type(:component).clear
+            end
+        end
     end
 end
 end
 
-# $Id: service.rb 938 2006-02-24 20:01:01Z luke $
+# $Id: service.rb 1033 2006-03-14 20:00:20Z luke $

data/test/types/state.rb

@@ -0,0 +1,92 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet/type'
+require 'puppettest'
+require 'test/unit'
+
+class TestState < Test::Unit::TestCase
+	include TestPuppet
+
+    def newinst(state)
+        inst = nil
+        assert_nothing_raised {
+            return state.new(:parent => nil)
+        }
+    end
+    
+    def newstate(name = :fakestate)
+        assert_nothing_raised {
+            state = Class.new(Puppet::State) do
+                @name = :fakeparam
+            end
+            state.initvars
+
+            return state
+        }
+    end
+
+    def test_newvalue
+        state = newstate()
+
+        assert_nothing_raised {
+            state.newvalue(:one) do
+                @is = 1
+            end
+        }
+
+        assert_nothing_raised {
+            state.newvalue("two") do
+                @is = 2
+            end
+        }
+
+        inst = newinst(state)
+
+        assert_nothing_raised {
+            inst.should = "one"
+        }
+
+        assert_equal(:one, inst.should)
+        assert_nothing_raised { inst.set_one }
+        assert_equal(1, inst.is)
+
+        assert_nothing_raised {
+            inst.should = :two
+        }
+
+        assert_equal(:two, inst.should)
+        assert_nothing_raised { inst.set_two }
+        assert_equal(2, inst.is)
+    end
+
+    def test_newstatevaluewithregexes
+        state = newstate()
+
+        assert_nothing_raised {
+            state.newvalue(/^\w+$/) do
+                @is = self.should.upcase
+                return :regex_matched
+            end
+        }
+
+        inst = newinst(state)
+
+        assert_nothing_raised {
+            inst.should = "yayness"
+        }
+
+        assert_equal("yayness", inst.should)
+
+        assert_nothing_raised {
+            inst.sync
+        }
+
+        assert_equal("yayness".upcase, inst.is)
+    end
+end
+
+# $Id: state.rb 1000 2006-03-10 05:41:01Z luke $

data/test/types/symlink.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: symlink.rb 905 2006-02-13 21:49:25Z luke $
+# $Id: symlink.rb 1015 2006-03-12 03:19:53Z luke $
 
 class TestSymlink < Test::Unit::TestCase
 	include FileTesting
@@ -77,15 +77,43 @@ class TestSymlink < Test::Unit::TestCase
         cycle(comp)
 
         path = link.name
+        assert(FileTest.directory?(path), "Did not make %s" % path)
         list = file_list(path)
         FileUtils.cd(path) {
             list.each { |file|
                 unless FileTest.directory?(file)
-                    assert(FileTest.symlink?(file))
+                    assert(FileTest.symlink?(file), "file %s is not a symlink" %
+                        file)
                     target = File.readlink(file)
                     assert_equal(target,File.join(source,file.sub(/^\.\//,'')))
                 end
             }
         }
     end
+
+    def disabled_test_createdrecursion
+        source = tempfile()
+        file = File.join(source, "file")
+        dest = tempfile()
+        link = File.join(dest, "file")
+
+        objects = []
+        objects << Puppet.type(:file).create(
+            :path => source,
+            :ensure => "directory"
+        )
+        objects << Puppet.type(:file).create(
+            :path => file,
+            :ensure => "file"
+        )
+        objects << Puppet.type(:symlink).create(
+            :path => dest,
+            :ensure => source,
+            :recurse => true
+        )
+
+        assert_apply(*objects)
+
+        assert(FileTest.symlink?(link), "Link was not created")
+    end
 end

data/test/types/tidy.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: tidy.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: tidy.rb 984 2006-03-06 18:07:41Z luke $
 
 class TestTidy < Test::Unit::TestCase
 	include FileTesting
@@ -65,25 +65,13 @@ class TestTidy < Test::Unit::TestCase
             :recurse => true
         )
 
-        comp = newcomp("tidytesting", tidy)
 
         sleep(2)
-        trans = nil
-        assert_nothing_raised {
-            trans = comp.evaluate
-        }
-        event = nil
-        assert_nothing_raised {
-            event = trans.evaluate.collect { |e| e.event }
-        }
+        assert_events([:file_tidied, :file_tidied], tidy)
 
         assert(!FileTest.exists?(file), "Tidied %s still exists" % file)
         assert(!FileTest.exists?(dir), "Tidied %s still exists" % dir)
 
-        assert_equal(2, event.length, "Got %s events instead of %s on tidy" %
-            [event.length, 2])
-        assert_equal([:file_tidied, :file_tidied], event,
-            "Got incorrect events on tidy")
     end
 
     def disabled_test_recursion

data/test/types/type.rb

@@ -251,6 +251,40 @@ class TestType < Test::Unit::TestCase
         # and make sure managed objects start with them
         assert(user.state(:ensure), "User did not get an ensure state")
     end
+
+    # Make sure removal works
+    def test_remove
+        objects = {}
+        top = Puppet.type(:component).create(:name => "top")
+        objects[top.class] = top
+
+        base = tempfile()
+
+        # now make a two-tier, 5 piece tree
+        %w{a b}.each do |letter|
+            name = "comp%s" % letter
+            comp = Puppet.type(:component).create(:name => name)
+            top.push comp
+            objects[comp.class] = comp
+
+            5.times do |i|
+                file = base + letter + i.to_s
+
+                obj = Puppet.type(:file).create(:name => file, :ensure => "file")
+
+                comp.push obj
+                objects[obj.class] = obj
+            end
+        end
+
+        assert_nothing_raised do
+            top.remove
+        end
+
+        objects.each do |klass, obj|
+            assert_nil(klass[obj.name], "object %s was not removed" % obj.name)
+        end
+    end
 end
 
-# $Id: type.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: type.rb 1053 2006-04-02 23:39:02Z luke $

data/test/types/user.rb

@@ -4,7 +4,7 @@ if __FILE__ == $0
     $puppetbase = "../../../../language/trunk"
 end
 
-# $Id: user.rb 966 2006-03-02 17:12:26Z luke $
+# $Id: user.rb 1042 2006-03-22 21:56:49Z luke $
 
 require 'etc'
 require 'puppet/type'
@@ -145,6 +145,7 @@ class TestUser < Test::Unit::TestCase
     end
 
     def attrtest_comment(user)
+        user.retrieve
         old = user.is(:comment)
         user[:comment] = "A different comment"
 
@@ -295,6 +296,114 @@ class TestUser < Test::Unit::TestCase
         assert_equal(old, current?(:uid, user[:name]), "UID was not reverted")
     end
 
+    def attrtest_groups(user)
+        Etc.setgrent
+        max = 0
+        while group = Etc.getgrent
+            if group.gid > max and group.gid < 5000
+                max = group.gid
+            end
+        end
+
+        groups = []
+        main = []
+        extra = []
+        5.times do |i|
+            i += 1
+            name = "pptstgr%s" % i
+            groups << Puppet.type(:group).create(
+                :name => name,
+                :gid => max + i
+            )
+
+            if i < 3
+                main << name
+            else
+                extra << name
+            end
+        end
+
+        # Create our test groups
+        assert_apply(*groups)
+
+        assert(user[:membership] == :minimum, "Membership did not default correctly")
+
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        # Now add some of them to our user
+        assert_nothing_raised {
+            user[:groups] = extra
+        }
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        assert(user.state(:groups).is, "Did not retrieve group list")
+
+        assert(!user.insync?, "User is incorrectly in sync")
+
+        assert_events([:user_modified], user)
+
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        list = user.state(:groups).is
+        assert_equal(extra.sort, list.sort, "Group list is not equal")
+
+        # Now set to our main list of groups
+        assert_nothing_raised {
+            user[:groups] = main
+        }
+
+        assert_equal((main + extra).sort.join(","), user.state(:groups).should)
+
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        assert(!user.insync?, "User is incorrectly in sync")
+
+        assert_events([:user_modified], user)
+
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        # We're not managing inclusively, so it should keep the old group
+        # memberships and add the new ones
+        list = user.state(:groups).is
+        assert_equal((main + extra).sort, list.sort, "Group list is not equal")
+
+        assert_nothing_raised {
+            user[:membership] = :inclusive
+        }
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        assert(!user.insync?, "User is incorrectly in sync")
+
+        assert_events([:user_modified], user)
+        assert_nothing_raised {
+            user.retrieve
+        }
+
+        list = user.state(:groups).is
+        assert_equal(main.sort, list.sort, "Group list is not equal")
+
+        # Now delete our groups
+        groups.each do |group|
+            group[:ensure] = :absent
+        end
+
+        user.delete(:groups)
+
+        assert_apply(*groups)
+    end
+
     # Disabled, because this is testing too much internal implementation
     def disabled_test_eachmethod
         obj = Etc.getpwuid(Process.uid)