puppet 0.23.0 → 0.23.1

data/test/ral/providers/mailalias/aliases.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppettest/fileparsing'
+require 'puppet/type/mailalias'
+
+class TestMailaliasAliasesProvider < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::FileParsing
+
+    def setup
+        super
+        @provider = Puppet.type(:mailalias).provider(:aliases)
+
+        @oldfiletype = @provider.filetype
+
+        @alias = mkalias
+    end
+
+    def teardown
+        Puppet::Util::FileType.filetype(:ram).clear
+        @provider.filetype = @oldfiletype
+        @provider.clear
+        super
+    end
+    
+    def mkalias(name = "me")
+        if defined? @pcount
+            @pcount += 1
+        else
+            @pcount = 1
+        end
+        args = {
+            :name => name,
+            :recipient => %w{here there}
+        }
+
+        fakeresource = fakeresource(:mailalias, args[:name])
+
+        key = @provider.new(fakeresource)
+        args.each do |p,v|
+            key.send(p.to_s + "=", v)
+        end
+
+        return key
+    end
+
+    def test_data_parsing_and_generating
+        fakedata("data/types/mailalias").each { |file|
+            fakedataparse(file)
+        }
+    end
+end
+
+# $Id: aliases.rb 2676 2007-07-10 23:24:34Z luke $

data/test/ral/providers/mount/parsed.rb

@@ -195,13 +195,13 @@ class TestParsedMounts < Test::Unit::TestCase
             obj.unmount
         }
         assert(! obj.mounted?, "FS still mounted")
-        # Check the actual output of df
-        assert(! obj.df().include?(fs), "%s is still listed in df" % fs)
+        # Check the actual output of mountcmd
+        assert(! obj.mountcmd().include?(fs), "%s is still listed in mountcmd" % fs)
         assert_nothing_raised {
             obj.mount
         }
         assert(obj.mounted?, "FS not mounted")
-        assert(obj.df().include?(fs), "%s is not listed in df" % fs)
+        assert(obj.mountcmd().include?(fs), "%s is not listed in mountcmd" % fs)
 
         # Now try remounting
         assert_nothing_raised("Could not remount filesystem") do
@@ -225,4 +225,4 @@ class TestParsedMounts < Test::Unit::TestCase
     end
 end
 
-# $Id: parsed.rb 2624 2007-06-19 01:49:19Z luke $
+# $Id: parsed.rb 2716 2007-07-19 20:01:47Z luke $

data/test/ral/providers/package/apt.rb

@@ -66,6 +66,12 @@ class AptPackageProviderTest < PuppetTest::TestCase
 					        '--purge',
 					        'faff'
 					  ).returns(0)
+		pkg.provider.expects(
+		                 :dpkg
+					  ).with(
+					        '--purge',
+					        'faff'
+					  ).returns(0)
 		
 		pkg.evaluate.each { |state| state.transaction = self; state.forward }
 	end
@@ -134,6 +140,12 @@ class AptPackageProviderTest < PuppetTest::TestCase
 					        '--purge',
 					        'faff'
 					  ).returns(0)
+		pkg.provider.expects(
+		                 :dpkg
+					  ).with(
+					        '--purge',
+					        'faff'
+					  ).returns(0)
 		
 		pkg.evaluate.each { |state| state.transaction = self; state.forward }
 	end
@@ -155,4 +167,4 @@ class AptPackageProviderTest < PuppetTest::TestCase
     end
 end
 
-# $Id: apt.rb 2555 2007-06-08 17:20:00Z luke $
+# $Id: apt.rb 2714 2007-07-19 18:12:20Z luke $

data/test/ral/providers/parsedfile.rb

@@ -197,15 +197,13 @@ class TestParsedFile < Test::Unit::TestCase
         prov.default_target = :default
 
         # Create a couple of demo files
-        prov.target_object(:file1).write "bill b c"
+        prov.target_object(:file1).write "bill b c\njill b d"
 
-        prov.target_object(:file2).write "jill b d"
-
-        prov.target_object(:default).write "will b d"
+        prov.target_object(:default).write "will b d\n"
 
         # Create some resources for some of those demo files
-        resource = mkresource "bill", :target => :file1
-        default = mkresource "will", :target => :default
+        resource = mkresource "bill", :target => :file1, :one => "b", :two => "c"
+        default = mkresource "will", :target => :default, :one => "b", :two => "d"
 
         resources = {"bill" => resource, "will" => default}
 
@@ -215,6 +213,7 @@ class TestParsedFile < Test::Unit::TestCase
 
         # Make sure we prefetched our resources.
         assert_equal("b", resource.provider.one, "did not prefetch resource from file1")
+        assert_equal("c", resource.provider.two, "did not prefetch resource from file1")
         assert_equal("b", default.provider.one, "did not prefetch resource from default")
         assert_equal("d", default.provider.two, "did not prefetch resource from default")
 
@@ -232,6 +231,20 @@ class TestParsedFile < Test::Unit::TestCase
             assert(providers.find { |provider| provider.name == name},
                 "Did not return %s in list" % name)
         end
+
+        # Now modify our resources and write them out, making sure that prefetching
+        # hasn't somehow destroyed this ability
+        resource[:one] = "a"
+        default[:one] = "a"
+
+
+        assert_apply(resource)
+        assert_apply(default)
+
+        assert_equal("bill a c\njill b d\n", prov.target_object(:file1).read,
+            "Did not write changed resource correctly")
+        assert_equal("will a d\n", prov.target_object(:default).read,
+            "Did not write changed default resource correctly")
     end
 
     # Make sure we can correctly prefetch on a target.
@@ -690,5 +703,5 @@ class TestParsedFile < Test::Unit::TestCase
     end
 end
 
-# $Id: parsedfile.rb 2551 2007-06-04 20:37:14Z luke $
+# $Id: parsedfile.rb 2676 2007-07-10 23:24:34Z luke $
 

data/test/ral/types/cron.rb

@@ -487,7 +487,23 @@ class TestCron < Test::Unit::TestCase
                 "target did not default to user with crontab")
         end
     end
+
+    # #705 - make sure extra spaces don't screw things up
+    def test_spaces_in_command
+        string = "echo   multiple  spaces"
+        cron = @crontype.create(:name => "testing", :command => string)
+        assert_apply(cron)
+
+        cron.class.clear
+        cron = @crontype.create(:name => "testing", :command => string)
+        # Now make sure that it's correctly in sync
+        cron.provider.class.prefetch("testing" => cron)
+        properties = cron.retrieve
+        command, result = properties.find { |prop, value| prop.name == :command }
+        assert_equal(string, result, "Cron did not pick up extra spaces in command")
+        assert(command.insync?(string), "Command changed with multiple spaces")
+    end
 end
 
 
-# $Id: cron.rb 2551 2007-06-04 20:37:14Z luke $
+# $Id: cron.rb 2697 2007-07-14 21:13:04Z luke $

data/test/ral/types/mailalias.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'mocha'
+
+class TestMailAlias < Test::Unit::TestCase
+	include PuppetTest
+
+    def setup
+        super
+        @type = Puppet::Type.type(:mailalias)
+
+        @provider = @type.defaultprovider
+
+        # Make sure they aren't using something funky like netinfo
+        unless @provider.name == :aliases
+            @type.defaultprovider = @type.provider(:aliases)
+        end
+
+        cleanup do @type.defaultprovider = nil end
+
+        if @provider.respond_to?(:default_target=)
+            @default_file = @provider.default_target
+            cleanup do
+                @provider.default_target = @default_file
+            end
+            @target = tempfile()
+            @provider.default_target = @target
+        end
+    end
+
+    # This isn't much of a test, but then, it's not much of a type.
+    def test_recipient_arrays
+        resource = @type.create(:name => "luke", :recipient => "yay", :target => tempfile)
+        resource.provider.expects(:recipient).returns([:absent])
+        values = nil
+        assert_nothing_raised("Could not retrieve mailalias") do
+            values = resource.retrieve.inject({}) { |hash, a| hash[a[0].name] = a[1]; hash }
+        end
+        assert_equal([:absent], values[:recipient])
+        resource.property(:recipient).expects(:set).with(%w{yay})
+        assert_nothing_raised("Could not sync mailalias") do
+            resource.property(:recipient).sync
+        end
+    end
+end
+
+# $Id: mailalias.rb 2676 2007-07-10 23:24:34Z luke $

data/test/ral/types/mount.rb

@@ -3,9 +3,10 @@
 $:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
+require 'mocha'
 
 unless Facter.value(:operatingsystem) == "Darwin"
-class TestMounts < Test::Unit::TestCase
+class TestMounts < PuppetTest::TestCase
 	include PuppetTest
 
     p = Puppet::Type.type(:mount).provide :fake, :parent => PuppetTest::FakeParsedProvider do
@@ -323,7 +324,39 @@ class TestMounts < Test::Unit::TestCase
 
         assert_nil(mount.should(:ensure), "Found default for ensure")
     end
+
+    def disabled_test_retrieving_a_single_mount
+        @mount.defaultprovider = nil
+
+        provider = @mount.defaultprovider
+        assert(provider, "Could not retrieve default provider")
+
+        mount = Puppet::Type.type(:mount).create(:name => "/", :check => :all)
+        values = nil
+        assert_nothing_raised("Could not retrieve values for /") do
+            values = mount.retrieve
+        end
+        values.each do |property, value|
+            assert(value != :absent, "Got :absent for %s" % property.name)
+        end
+    end
+
+    # #726 - when filesystems are mounted but absent, Puppet does not write them out.
+    def test_mounted_but_absent
+        mount = @mount.create(:name => "/testing", :ensure => :mounted, :provider => :fake, :device => "/dev/something")
+
+        class << mount.provider
+            def mounted?
+                true
+            end
+        end
+
+        mount.provider.destroy
+        mount.provider.expects(:create)
+        mount.provider.expects(:mount).never
+        assert_apply(mount)
+    end
 end
 end
 
-# $Id: mount.rb 2563 2007-06-11 22:30:00Z luke $
+# $Id: mount.rb 2723 2007-07-20 16:46:54Z luke $

data/test/ral/types/package.rb

@@ -70,7 +70,7 @@ class TestPackages < Test::Unit::TestCase
         when "Solaris": :sun
         end
 
-        unless default = Puppet.type(:package).defaultprovider
+        unless default = Puppet::Type.type(:package).defaultprovider
             $stderr.puts "no default provider for %s" %
                 Facter["operatingsystem"].value
             return
@@ -137,6 +137,14 @@ class TestPackages < Test::Unit::TestCase
             end
         end
     end
+
+    # #716
+    def test_purge_is_not_installed
+        package = @type.create(:ensure => :installed, :name => "whatever")
+
+        property = package.property(:ensure)
+        assert(! property.insync?(:purged), "Package in state 'purged' was considered in sync")
+    end
 end
 
-# $Id: package.rb 2555 2007-06-08 17:20:00Z luke $
+# $Id: package.rb 2709 2007-07-19 00:14:15Z luke $

data/test/ral/types/parameter.rb

@@ -123,7 +123,7 @@ class TestParameter < Test::Unit::TestCase
         assert(obj, "did not get alias parameter")
         assert(obj.shadow, "shadow was not created for alias param")
 
-        assert(obj.is_a?(Puppet::Type::Property),
+        assert(obj.is_a?(Puppet::Property),
             "alias instance is not a property")
         assert_instance_of(param, obj, "alias is an instance of the wrong class")
 
@@ -141,7 +141,7 @@ class TestParameter < Test::Unit::TestCase
         assert(obj.shadow, "shadow was not created for alias param")
 
         assert_instance_of(param, obj, "alias is an instance of the wrong class")
-        assert(obj.is_a?(Puppet::Type::Property),
+        assert(obj.is_a?(Puppet::Property),
             "alias instance is not a property")
 
         # Now change the alias and make sure it works out well
@@ -152,7 +152,7 @@ class TestParameter < Test::Unit::TestCase
         obj = params[:alias]
         assert(obj, "did not get alias parameter")
         assert_instance_of(param, obj, "alias is now an instance of the wrong class")
-        assert(obj.is_a?(Puppet::Type::Property),
+        assert(obj.is_a?(Puppet::Property),
             "alias instance is now not a property")
     end
 
@@ -169,4 +169,4 @@ class TestParameter < Test::Unit::TestCase
     end
 end
 
-# $Id: parameter.rb 2500 2007-05-09 22:05:32Z luke $
+# $Id: parameter.rb 2647 2007-07-04 22:25:23Z luke $

data/test/ral/types/property.rb

@@ -345,6 +345,44 @@ class TestProperty < Test::Unit::TestCase
             $setting.clear
         end
     end
+
+    # Make sure we can specify that we want to use the whole array, rather
+    # than just individual values.
+    def test_array_handling
+        property = newproperty(:arraytests)
+
+        prov, model = newmodel(:array_testing)
+        inst = newinst(property, model)
+
+        # Make sure it defaults to first
+        assert_equal(:first, property.array_matching, "Property did not default to matching first value in an array")
+        assert(! inst.match_all?, "match_all? returned true when array_matching is :first")
+
+        vals = %w{one two three}
+        inst.should = vals
+
+        # Make sure we only get the first value back
+        assert_equal("one", inst.should, "Returned wrong value when array_matching == first")
+
+        # And make sure any of these values is considered in sync
+        vals.each do |value|
+            assert(inst.insync?(value), "#{value} was not considered in sync when array_matching == first")
+        end
+
+        # Now change it to all
+        property.array_matching = :all
+        assert_equal(:all, property.array_matching, "Property did not change value of array_matching")
+        assert(inst.match_all?, "match_all? returned false when array_matching is :all")
+
+        # Make sure we only get the first value back
+        assert_equal(vals, inst.should, "Returned wrong value when array_matching == all")
+
+        # And make sure any of these values is considered in sync
+        %w{one two three}.each do |value|
+            assert(! inst.insync?(value), "individual value #{value} was considered in sync when array_matching == all")
+        end
+        assert(inst.insync?(vals), "value array was not considered in sync when array_matching == all")
+    end
 end
 
-# $Id: property.rb 2500 2007-05-09 22:05:32Z luke $
+# $Id: property.rb 2674 2007-07-10 19:30:39Z luke $

data/test/util/autoload.rb

@@ -30,12 +30,7 @@ TestAutoload.newthing(:#{name.to_s})
         end
     end
 
-    def teardown
-        super
-        self.class.clear
-    end
-
-    def test_load
+    def mk_loader(name)
         dir = tempfile()
         $: << dir
         cleanup do
@@ -44,19 +39,26 @@ TestAutoload.newthing(:#{name.to_s})
 
         Dir.mkdir(dir)
 
-        rbdir = File.join(dir, "yayness")
+        rbdir = File.join(dir, name.to_s)
 
         Dir.mkdir(rbdir)
 
-        # An object for specifying autoload
-        klass = self.class
-
         loader = nil
         assert_nothing_raised {
-            loader = Puppet::Util::Autoload.new(klass, :yayness)
+            loader = Puppet::Util::Autoload.new(self.class, name)
         }
+        return rbdir, loader
+    end
+
+    def teardown
+        super
+        Puppet::Util::Autoload.clear
+    end
+
+    def test_load
+        dir, loader = mk_loader(:yayness)
 
-        assert_equal(loader.object_id, Puppet::Util::Autoload[klass].object_id,
+        assert_equal(loader.object_id, Puppet::Util::Autoload[self.class].object_id,
                     "Did not retrieve loader object by class")
 
         # Make sure we don't fail on missing files
@@ -66,9 +68,9 @@ TestAutoload.newthing(:#{name.to_s})
         }
 
         # Now create a couple of files for testing
-        path = File.join(rbdir, "mything.rb")
+        path = File.join(dir, "mything.rb")
         mkfile(:mything, path)
-        opath = File.join(rbdir, "othing.rb")
+        opath = File.join(dir, "othing.rb")
         mkfile(:othing, opath)
 
         # Now try to actually load it.
@@ -79,12 +81,12 @@ TestAutoload.newthing(:#{name.to_s})
 
         assert(loader.loaded?(:mything), "Not considered loaded")
 
-        assert(klass.thing?(:mything),
+        assert(self.class.thing?(:mything),
                 "Did not get loaded thing")
 
         # Now clear everything, and test loadall
         assert_nothing_raised {
-            loader.clear
+            Puppet::Util::Autoload.clear
         }
 
         self.class.clear
@@ -95,10 +97,23 @@ TestAutoload.newthing(:#{name.to_s})
 
         [:mything, :othing].each do |thing|
             assert(loader.loaded?(thing), "#{thing.to_s} not considered loaded")
+            assert(loader.loaded?("%s.rb" % thing), "#{thing.to_s} not considered loaded with .rb")
+            assert(Puppet::Util::Autoload.loaded?("yayness/%s" % thing), "%s not considered loaded by the main class" % thing)
+            assert(Puppet::Util::Autoload.loaded?("yayness/%s.rb" % thing), "%s not considered loaded by the main class with .rb" % thing)
 
-            assert(klass.thing?(thing),
+            loaded = Puppet::Util::Autoload.loaded?("yayness/%s.rb" % thing)
+            assert_equal("%s/%s.rb" % [dir, thing], loaded[:file], "File path was not set correctly in loaded store")
+            assert_equal(self.class, loaded[:autoloader], "Loader was not set correctly in loaded store")
+
+            assert(self.class.thing?(thing),
                     "Did not get loaded #{thing.to_s}")
         end
+
+        Puppet::Util::Autoload.clear
+        [:mything, :othing].each do |thing|
+            assert(! loader.loaded?(thing), "#{thing.to_s} considered loaded after clear")
+            assert(! Puppet::Util::Autoload.loaded?("yayness/%s" % thing), "%s considered loaded by the main class after clear" % thing)
+        end
     end
 
     # Make sure that autoload dynamically modifies $: with the libdir as
@@ -112,4 +127,4 @@ TestAutoload.newthing(:#{name.to_s})
     end
 end
 
-# $Id: autoload.rb 2518 2007-05-16 00:00:47Z luke $
+# $Id: autoload.rb 2668 2007-07-10 04:00:28Z luke $