puppet 0.18.4 → 0.22.4

data/test/ral/types/resources.rb

@@ -0,0 +1,221 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2006-12-12.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+class TestResources < Test::Unit::TestCase
+	include PuppetTest
+	
+	def add_purge_lister
+        # Now define the list method
+        class << @purgetype
+            def list
+                $purgemembers.values
+            end
+        end
+    end
+    
+    def mk_purger(managed = false)
+        @purgenum ||= 0
+        @purgenum += 1
+        obj = @purgetype.create :name => "purger%s" % @purgenum
+        $purgemembers[obj[:name]] = obj
+        if managed
+            obj[:fake] = "testing"
+        end
+        obj
+    end
+	
+	def mkpurgertype
+        # Create a purgeable type
+        $purgemembers = {}
+        @purgetype = Puppet::Type.newtype(:purgetest) do
+            newparam(:name, :namevar => true) {}
+            newproperty(:ensure) do
+                newvalue(:absent) do
+                    $purgemembers[@parent[:name]] = @parent
+                end
+                newvalue(:present) do
+                    $purgemembers.delete(@parent[:name])
+                end
+            end
+            newproperty(:fake) do
+                def sync
+                    :faked
+                end
+            end
+        end
+        cleanup do
+            Puppet::Type.rmtype(:purgetest)
+        end
+    end
+	
+	def setup
+	    super
+	    @type = Puppet::Type.type(:resources)
+    end
+	
+	def test_initialize
+	    assert(@type, "Could not retrieve resources type")
+	    # Make sure we can't create them for types that don't exist
+	    assert_raise(Puppet::Error) do
+	        @type.create :name => "thereisnotypewiththisname"
+        end
+        
+        # Now make sure it works for a normal type
+        usertype = nil
+        assert_nothing_raised do
+            usertype = @type.create :name => "user"
+        end
+        assert(usertype, "did not create user resource type")
+        assert_equal(Puppet::Type.type(:user), usertype.resource_type,
+            "resource_type was not set correctly")
+    end
+    
+    def test_purge
+        # Create a purgeable type
+        mkpurgertype
+        
+        purger = nil
+        assert_nothing_raised do
+            purger = @type.create :name => "purgetest", :noop => true, :loglevel => :warning
+        end
+        assert(purger, "did not get purger manager")
+        
+        # Make sure we throw an error, because the purger type does
+        # not support listing.
+        
+        # It should work when we set it to false
+        assert_nothing_raised do
+            purger[:purge] = false
+        end
+        # but not true
+        assert_raise(ArgumentError) do
+            purger[:purge] = true
+        end
+        add_purge_lister()
+        
+        assert_equal($purgemembers.values.sort, @purgetype.list.sort)
+        
+        # and it should now succeed
+        assert_nothing_raised do
+            purger[:purge] = true
+        end
+        assert(purger.purge?, "purge boolean was not enabled")
+        
+        # Okay, now let's try doing some purging, yo
+        managed = []
+        unmanned = []
+        3.times { managed << mk_purger(true) } # 3 managed
+        3.times { unmanned << mk_purger(false) } # 3 unmanaged
+        
+        managed.each do |m|
+            assert(m.managed?, "managed resource was not considered managed")
+        end
+        unmanned.each do |u|
+            assert(! u.managed?, "unmanaged resource was considered managed")
+        end
+        
+        # First make sure we get nothing back when purge is false
+        genned = nil
+        purger[:purge] = false
+        assert_nothing_raised do
+            genned = purger.generate
+        end
+        assert_equal([], genned, "Purged even when purge is false")
+        
+        # Now make sure we can purge
+        purger[:purge] = true
+        assert_nothing_raised do
+            genned = purger.generate
+        end
+        assert(genned, "Did not get any generated resources")
+
+        genned.each do |res|
+            assert(res.purging, "did not mark resource for purging")
+        end
+        assert(! genned.empty?, "generated resource list was empty")
+        
+        # Now make sure the generate method only finds the unmanaged resources
+        assert_equal(unmanned.collect { |r| r.title }.sort, genned.collect { |r| r.title },
+            "Did not return correct purge list")
+        
+        # Now make sure our metaparams carried over
+        genned.each do |res|
+            [:noop, :loglevel].each do |param|
+                assert_equal(purger[param], res[param], "metaparam %s did not carry over" % param)
+            end
+        end
+    end
+    
+    # Part of #408.
+    def test_check
+        # First check a non-user
+        res = Puppet::Type.type(:resources).create :name => :package
+        assert_nil(res[:unless_system_user], "got bad default for package")
+        
+        
+        assert_nothing_raised {
+            assert(res.check("A String"), "String failed check")
+            assert(res.check(Puppet::Type.newfile(:path => tempfile())), "File failed check")
+            assert(res.check(Puppet::Type.type(:user).create(:name => "yayness")), "User failed check in package")
+        }
+        
+        # Now create a user manager
+        res = Puppet::Type.type(:resources).create :name => :user
+        
+        # Make sure the default is 500
+        assert_equal(500, res[:unless_system_user], "got bad default")
+        
+        # Now make sure root fails the test
+        @user = Puppet::Type.type(:user)
+        assert_nothing_raised {
+            assert(! res.check(@user.create(:name => "root")), "root passed check")
+            assert(! res.check(@user.create(:name => "nobody")), "nobody passed check")
+        }
+        
+        # Now find a user between 0 and the limit
+        low = high = nil
+        Etc.passwd { |entry|
+            if ! low and (entry.uid > 10 and entry.uid < 500)
+                low = entry.name
+            else
+                # We'll reset the limit, since we can't really guarantee that
+                # there are any users with uid > 500
+                if ! high and entry.uid > 100 and ! res.system_users.include?(entry.name)
+                    high = entry.name
+                    break
+                end
+            end
+        }
+        
+        if low
+            assert(! res.check(@user.create(:name => low)), "low user %s passed check" % low)
+        end
+        if high
+            res[:unless_system_user] = 50
+            assert(res.check(@user.create(:name => high)), "high user %s failed check" % high)
+        end
+    end
+    
+    # The other half of #408.
+    def test_check_is_called
+        res = Puppet::Type.type(:resources).create :name => :user, :purge => true
+        
+        list = nil
+        assert_nothing_raised { list = res.generate }
+        
+        assert(! list.empty?, "did not get any users")
+        
+        bad = list.find_all { |u|
+                %w{root bin nobody}.include?(u[:name]) or (u.retrieve and u.is(:uid) < 500)
+            }
+        assert(bad.empty?, "incorrectly passed users %s" % bad.collect { |u| u[:name]}.join(", "))
+    end
+end
+
+# $Id: resources.rb 2286 2007-03-17 23:16:37Z luke $

data/test/{types → ral/types}/schedule.rb

@@ -1,16 +1,12 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet'
-require 'test/unit'
-require 'puppet/type/schedule'
 require 'puppettest'
+require 'puppet/type/schedule'
 
 class TestSchedule < Test::Unit::TestCase
-    include TestPuppet
+    include PuppetTest
 
     def setup
         super
@@ -291,11 +287,25 @@ class TestSchedule < Test::Unit::TestCase
 
     # Verify that each of our default schedules exist
     def test_defaultschedules
-        Puppet.type(:schedule).mkdefaultschedules
+        assert_nothing_raised do
+            Puppet.type(:schedule).mkdefaultschedules
+        end
+        s = {}
         %w{puppet hourly daily weekly monthly}.each { |period|
-            assert(Puppet.type(:schedule)[period], "Could not find %s schedule" %
+            obj = Puppet.type(:schedule)[period]
+            assert(obj, "Could not find %s schedule" %
                 period)
+            s[period] = obj
         }
+        assert_nothing_raised("Could not rerun mkdefaultschedules") do
+            Puppet.type(:schedule).mkdefaultschedules
+        end
+        s.each do |period, obj|
+            newobj = Puppet.type(:schedule)[period]
+            assert(newobj, "somehow lost schedule for %s" % period)
+            assert_equal(obj.object_id, newobj.object_id,
+                "created a new schedule instead of reusing existing one")
+        end
     end
 
     def test_period_with_repeat
@@ -330,6 +340,18 @@ class TestSchedule < Test::Unit::TestCase
         assert(! s.match?(min("-", 15)), "matched minus 15 minutes with half-hourly")
         assert(s.match?(min("-", 25)), "Did not match minus 25 with half-hourly")
     end
+
+    # #526
+    def test_never_period
+        schedule = nil
+        assert_nothing_raised do
+            schedule = Puppet::Type.type(:schedule).create(
+                :name => "test", :period => :never
+            )
+        end
+
+        assert(! schedule.match?, "schedule matched with period == never")
+    end
 end
 
-# $Id: schedule.rb 897 2006-02-12 18:08:39Z luke $
+# $Id: schedule.rb 2238 2007-02-28 00:14:27Z luke $

data/test/ral/types/service.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'mocha'
+
+class TestServiceType < Test::Unit::TestCase
+	include PuppetTest
+
+    # #199
+    def test_no_refresh_when_starting
+        service = Puppet::Type.type(:service).create :name => "testing",
+            :ensure => :running, :provider => :base
+
+        # First make sure it does not refresh
+        service.provider.expects(:restart).never
+
+        assert_nothing_raised do
+            service.refresh
+        end
+    end
+
+    def test_refresh_normally
+        service = Puppet::Type.type(:service).create :name => "testing",
+            :ensure => :running, :provider => :base
+
+        service.is = [:ensure, :running]
+        service.provider.expects(:restart)
+
+        assert_nothing_raised do
+            service.refresh
+        end
+    end
+end
+
+# $Id: service.rb 2236 2007-02-27 23:57:55Z luke $

data/test/{types → ral/types}/sshkey.rb

@@ -1,37 +1,41 @@
-# Test key job creation, modification, and destruction
+#!/usr/bin/env ruby
 
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
-require 'puppet'
-require 'puppet/type/parsedtype/sshkey'
-require 'test/unit'
+require 'puppet/type/sshkey'
 require 'facter'
 
 class TestSSHKey < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
     def setup
         super
         # god i'm lazy
-        @sshtype = Puppet.type(:sshkey)
-        @oldfiletype = @sshtype.filetype
+        @sshkeytype = Puppet.type(:sshkey)
+
+        @provider = @sshkeytype.defaultprovider
+
+        # Make sure they aren't using something funky like netinfo
+        unless @provider.name == :parsed
+            @sshkeytype.defaultprovider = @sshkeytype.provider(:parsed)
+        end
+
+        cleanup do @sshkeytype.defaultprovider = nil end
+
+        if @provider.respond_to?(:default_target)
+            oldpath = @provider.default_target
+            cleanup do
+                @provider.default_target = oldpath
+            end
+            @provider.default_target = tempfile()
+        end
     end
 
     def teardown
-        Puppet::FileType.filetype(:ram).clear
-        @sshtype.filetype = @oldfiletype
-        Puppet.type(:file).clear
         super
-    end
-
-    # Here we just create a fake key type that answers to all of the methods
-    # but does not modify our actual system.
-    def mkfaketype
-        @sshtype.filetype = Puppet::FileType.filetype(:ram)
+        if @provider.respond_to?(:clear)
+            @provider.clear
+        end
     end
 
     def mkkey
@@ -44,7 +48,7 @@ class TestSSHKey < Test::Unit::TestCase
         end
 
         assert_nothing_raised {
-            key = @sshtype.create(
+            key = @sshkeytype.create(
                 :name => "host%s.madstop.com" % @kcount,
                 :key => "%sAAAAB3NzaC1kc3MAAACBAMnhSiku76y3EGkNCDsUlvpO8tRgS9wL4Eh54WZfQ2lkxqfd2uT/RTT9igJYDtm/+UHuBRdNGpJYW1Nw2i2JUQgQEEuitx4QKALJrBotejGOAWxxVk6xsh9xA0OW8Q3ZfuX2DDitfeC8ZTCl4xodUMD8feLtP+zEf8hxaNamLlt/AAAAFQDYJyf3vMCWRLjTWnlxLtOyj/bFpwAAAIEAmRxxXb4jjbbui9GYlZAHK00689DZuX0EabHNTl2yGO5KKxGC6Esm7AtjBd+onfu4Rduxut3jdI8GyQCIW8WypwpJofCIyDbTUY4ql0AQUr3JpyVytpnMijlEyr41FfIb4tnDqnRWEsh2H7N7peW+8DWZHDFnYopYZJ9Yu4/jHRYAAACAERG50e6aRRb43biDr7Ab9NUCgM9bC0SQscI/xdlFjac0B/kSWJYTGVARWBDWug705hTnlitY9cLC5Ey/t/OYOjylTavTEfd/bh/8FkAYO+pWdW3hx6p97TBffK0b6nrc6OORT2uKySbbKOn0681nNQh4a6ueR3JRppNkRPnTk5c=" % @kcount,
                 :type => "ssh-dss",
@@ -55,56 +59,64 @@ class TestSSHKey < Test::Unit::TestCase
         return key
     end
 
-    def test_simplekey
-        mkfaketype
+    def test_list
         assert_nothing_raised {
-            assert_nil(Puppet.type(:sshkey).retrieve)
+            Puppet.type(:sshkey).defaultprovider.list
         }
 
-        key = mkkey
-
-        assert_apply(key)
-
-        assert_nothing_raised {
-            Puppet.type(:sshkey).store
-        }
+        count = 0
+        @sshkeytype.each do |h|
+            count += 1
+        end
 
-        assert_nothing_raised {
-            assert(
-                Puppet.type(:sshkey).to_file.include?(
-                    Puppet.type(:sshkey).fileobj.read
-                ),
-                "File does not include all of our objects"
-            )
-        }
+        assert_equal(0, count, "Found sshkeys in empty file somehow")
     end
 
-    def test_keysparse
-        fakedata("data/types/sshkey").each { |file|
-            @sshtype.path = file
-            assert_nothing_raised {
-                @sshtype.retrieve
-            }
-            @sshtype.clear
-        }
+    def test_simplekey
+        key = mkkey
+        file = tempfile()
+        key[:target] = file
+        key[:provider] = :parsed
+
+        assert_apply(key)
+        
+        assert_events([], key, "created events on in-sync key")
+        
+        assert(key.provider.exists?, "Key did not get created")
+        
+        # Now create a new key object
+        name = key.name
+        key = nil
+        @sshkeytype.clear
+        
+        key = @sshkeytype.create :name => name, :target => file, :provider => :parsed
+        key.retrieve
+        
+        assert(key.provider.exists?, "key thinks it does not exist")
+        
     end
 
     def test_moddingkey
-        mkfaketype
         key = mkkey()
 
         assert_events([:sshkey_created], key)
 
         key.retrieve
 
-        key[:alias] = %w{madstop kirby yayness}
+        aliases = %w{madstop kirby yayness}
+        key[:alias] = aliases
 
-        Puppet.err :mark
+        params = key.instance_variable_get("@parameters")
         assert_events([:sshkey_changed], key)
+
+        aliases.each do |name|
+            assert_equal(key, key.class[name],
+                "alias was not set")
+        end
     end
 
-    def test_aliasisstate
-        assert_equal(:state, @sshtype.attrtype(:alias))
+    def test_aliasisproperty
+        assert_equal(:property, @sshkeytype.attrtype(:alias))
     end
 
     def test_multivalues
@@ -126,28 +138,24 @@ class TestSSHKey < Test::Unit::TestCase
     end
 
     def test_removal
-        mkfaketype
         sshkey = mkkey()
         assert_nothing_raised {
             sshkey[:ensure] = :present
         }
         assert_events([:sshkey_created], sshkey)
 
-        sshkey.retrieve
-        assert(sshkey.insync?)
+        assert(sshkey.provider.exists?, "key was not created")
         assert_nothing_raised {
             sshkey[:ensure] = :absent
         }
 
         assert_events([:sshkey_removed], sshkey)
-        sshkey.retrieve
+        assert(! sshkey.provider.exists?, "Key was not deleted")
         assert_events([], sshkey)
     end
 
+    # Make sure changes actually modify the file.
     def test_modifyingfile
-        keyfile = tempfile()
-        Puppet.type(:sshkey).path = keyfile
-
         keys = []
         names = []
         3.times {
@@ -164,19 +172,21 @@ class TestSSHKey < Test::Unit::TestCase
         #newkey[:ensure] = :present
         names << newkey.name
         assert_apply(newkey)
-        Puppet.type(:sshkey).clear
+
         # Verify we can retrieve that info
         assert_nothing_raised("Could not retrieve after second write") {
+            newkey.provider.class.prefetch
             newkey.retrieve
         }
 
         # And verify that we have data for everything
         names.each { |name|
-            key = Puppet.type(:sshkey)[name]
-            assert(key)
-            assert(key[:type])
+            key = Puppet.type(:sshkey)[name] ||
+                Puppet.type(:sshkey).create(:name => name)
+            assert(key, "Could not retrieve key for %s" % name)
+            assert(key.provider.exists?, "key %s is missing" % name)
         }
     end
 end
 
-# $Id: sshkey.rb 1421 2006-07-21 23:12:51Z luke $
+# $Id: sshkey.rb 2170 2007-02-07 17:21:52Z luke $