puppet 0.23.1 → 0.23.2

data/test/lib/puppettest/parsertesting.rb

@@ -46,7 +46,7 @@ module PuppetTest::ParserTesting
     end
 
     def mkparser
-        Puppet::Parser::Parser.new(mkinterp)
+        Puppet::Parser::Parser.new()
     end
 
     def mkscope(hash = {})
@@ -389,4 +389,4 @@ module PuppetTest::ParserTesting
     end
 end
 
-# $Id: parsertesting.rb 2198 2007-02-16 06:06:10Z luke $
+# $Id: parsertesting.rb 2742 2007-08-03 23:49:53Z luke $

data/test/lib/puppettest/support/collection.rb

@@ -18,7 +18,7 @@ module PuppetTest::Support::Collection
                 query = nil
 
                 assert_nothing_raised("Could not parse '#{str}'") do
-                    query = parser.parse(code)[0].query
+                    query = parser.parse(code).classes[""].code[0].query
                 end
 
                 yield str, res, query
@@ -27,4 +27,4 @@ module PuppetTest::Support::Collection
     end
 end
 
-# $Id: collection.rb 2705 2007-07-18 17:32:46Z luke $
+# $Id: collection.rb 2742 2007-08-03 23:49:53Z luke $

data/test/network/server/mongrel_test.rb

@@ -3,6 +3,7 @@
 $:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
+require 'mocha'
 
 class TestMongrelServer < PuppetTest::TestCase
     confine "Missing mongrel" => Puppet.features.mongrel?
@@ -25,14 +26,34 @@ class TestMongrelServer < PuppetTest::TestCase
 
         ip = Facter.value(:ipaddress)
         params["REMOTE_ADDR"] = ip
+        params[Puppet[:ssl_client_header]] = ""
+        params[Puppet[:ssl_client_verify_header]] = "failure"
+        info = nil
+        Resolv.expects(:getname).with(ip).returns("host.domain.com").times(3)
+        assert_nothing_raised("Could not call client_info") do
+            info = mongrel.send(:client_info, obj)
+        end
+        assert(! info.authenticated?, "Client info object was marked valid even though headers were missing")
+        assert_equal(ip, info.ip, "Did not copy over ip correctly")
+
+        assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
+
+        # Now add a valid auth header.
         params[Puppet[:ssl_client_header]] = "/CN=host.domain.com"
+        assert_nothing_raised("Could not call client_info") do
+            info = mongrel.send(:client_info, obj)
+        end
+        assert(! info.authenticated?, "Client info object was marked valid even though the verify header was fals")
+        assert_equal(ip, info.ip, "Did not copy over ip correctly")
+        assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
 
-        info = nil
+        # Now change the verify header to be true
+        params[Puppet[:ssl_client_verify_header]] = "SUCCESS"
         assert_nothing_raised("Could not call client_info") do
             info = mongrel.send(:client_info, obj)
         end
 
-        assert(info.authenticated?, "Client info object was not marked valid even though the header was present")
+        assert(info.authenticated?, "Client info object was not marked valid even though all headers were correct")
         assert_equal(ip, info.ip, "Did not copy over ip correctly")
         assert_equal("host.domain.com", info.name, "Did not copy over hostname correctly")
 
@@ -68,4 +89,4 @@ class TestMongrelServer < PuppetTest::TestCase
     end
 end
 
-# $Id: mongrel_test.rb 2659 2007-07-08 23:02:06Z luke $
+# $Id: mongrel_test.rb 2752 2007-08-06 20:05:28Z luke $

data/test/rails/collection.rb

@@ -209,6 +209,39 @@ class TestRailsCollection < PuppetTest::TestCase
 
         assert(ret.empty?, "Found exports from our own host")
     end
+
+    # #731 -- we're collecting all resources, not just exported resources.
+    def test_only_collecting_exported_resources
+        railsinit
+
+        # Make our configuration
+        host = Puppet::Rails::Host.new(:name => "myhost")
+
+        host.resources.build(:title => "/tmp/exporttest1", :restype => "file",
+            :exported => true)
+        host.resources.build(:title => "/tmp/exporttest2", :restype => "file",
+            :exported => false)
+
+        host.save
+
+        @scope.host = "otherhost"
+
+        # Now make a collector
+        coll = nil
+        assert_nothing_raised do
+            coll = Puppet::Parser::Collector.new(@scope, "file", nil, nil, :exported)
+        end
+
+        # And make sure we get nada back
+        ret = nil
+        assert_nothing_raised do
+            ret = coll.collect_exported
+        end
+
+        names = ret.collect { |res| res.title }
+
+        assert_equal(%w{/tmp/exporttest1}, names, "Collected incorrect resource list")
+    end
 end
 
-# $Id: collection.rb 2663 2007-07-09 06:00:42Z luke $
+# $Id: collection.rb 2746 2007-08-05 17:57:31Z luke $

data/test/ral/providers/cron/crontab.rb

@@ -11,11 +11,41 @@ class TestCronParsedProvider < Test::Unit::TestCase
 	include PuppetTest
 	include PuppetTest::FileParsing
 
+
+    FIELDS = {
+        :crontab => %w{command minute hour month monthday weekday}.collect { |o| o.intern },
+        :freebsd_special => %w{special command}.collect { |o| o.intern },
+        :environment => [:line],
+        :blank => [:line],
+        :comment => [:line],
+    }
+
+    # These are potentially multi-line records; there's no one-to-one map, but they model
+    # a full cron job.  These tests assume individual record types will always be correctly
+    # parsed, so all they 
+    def sample_crons
+        unless defined? @sample_crons
+            @sample_crons = YAML.load(File.read(File.join(@crondir, "crontab_collections.yaml")))
+        end
+        @sample_crons
+    end
+
+    # These are simple lines that can appear in the files; there is a one to one
+    # mapping between records and lines.  We have plenty of redundancy here because
+    # we use these records to build up our complex, multi-line cron jobs below.
+    def sample_records
+        unless defined? @sample_records
+            @sample_records = YAML.load(File.read(File.join(@crondir, "crontab_sample_records.yaml")))
+        end
+        @sample_records
+    end
+
     def setup
         super
         @type = Puppet::Type.type(:cron)
         @provider = @type.provider(:crontab)
         @provider.initvars
+        @crondir = datadir(File.join(%w{providers cron}))
 
         @oldfiletype = @provider.filetype
     end
@@ -27,31 +57,160 @@ class TestCronParsedProvider < Test::Unit::TestCase
         super
     end
 
-    def test_parse_record
-        fields = [:month, :weekday, :monthday, :hour, :command, :minute]
-        {
-            "* * * * * /bin/echo" => {:command => "/bin/echo"},
-            "10 * * * * /bin/echo test" => {:minute => ["10"],
-                :command => "/bin/echo test"}
-        }.each do |line, should|
+    # Make sure a cron job matches up.  Any non-passed fields are considered absent.
+    def assert_cron_equal(msg, cron, options)
+        assert_instance_of(@provider, cron, "not an instance of provider in %s" % msg)
+        options.each do |param, value|
+            assert_equal(value, cron.send(param), "%s was not equal in %s" % [param, msg])
+        end
+        %w{command environment minute hour month monthday weekday}.each do |var|
+            unless options.include?(var.intern)
+                assert_equal(:absent, cron.send(var), "%s was not parsed absent in %s" % [var, msg])
+            end
+        end
+    end
+
+    # Make sure a cron record matches.  This only works for crontab records.
+    def assert_record_equal(msg, record, options)
+        unless options.include?(:record_type)
+            raise ArgumentError, "You must pass the required record type"
+        end
+        assert_instance_of(Hash, record, "not an instance of a hash in %s" % msg)
+        options.each do |param, value|
+            assert_equal(value, record[param], "%s was not equal in %s" % [param, msg])
+        end
+        FIELDS[record[:record_type]].each do |var|
+            unless options.include?(var)
+                assert_equal(:absent, record[var], "%s was not parsed absent in %s" % [var, msg])
+            end
+        end
+    end
+
+    def assert_header(file)
+        header = []
+        file.gsub! /^(# HEADER: .+$)\n/ do
+            header << $1
+            ''
+        end
+        assert_equal(4, header.length, "Did not get four header lines")
+    end
+
+    # This handles parsing every possible iteration of cron records.  Note that this is only
+    # single-line stuff and doesn't include multi-line values (e.g., with names and/or envs).
+    # Those have separate tests.
+    def test_parse_line
+        # First just do each sample record one by one
+        sample_records.each do |name, options|
+            result = nil
+            assert_nothing_raised("Could not parse %s: '%s'" % [name, options[:text]]) do
+                result = @provider.parse_line(options[:text])
+            end
+            assert_record_equal("record for %s" % name, result, options[:record])
+        end
+
+        # Then do them all at once.
+        records = []
+        text = ""
+        sample_records.each do |name, options|
+            records << options[:record]
+            text += options[:text] + "\n"
+        end
+
+        result = nil
+        assert_nothing_raised("Could not match all records in one file") do
+            result = @provider.parse(text)
+        end
+
+        records.zip(result).each do |should, record|
+            assert_record_equal("record for %s in full match" % should.inspect, record, should)
+        end
+    end
+
+    # Here we test that each record generates to the correct text.
+    def test_generate_line
+        # First just do each sample record one by one
+        sample_records.each do |name, options|
             result = nil
-            assert_nothing_raised("Could not parse %s" % line.inspect) do
-                result = @provider.parse_line(line)
+            assert_nothing_raised("Could not generate %s: '%s'" % [name, options[:record]]) do
+                result = @provider.to_line(options[:record])
             end
-            should[:record_type] = :crontab
-            fields.each do |field|
-                if should[field]
-                    assert_equal(should[field], result[field],
-                        "Did not parse %s in %s correctly" % [field, line.inspect])
-                else
-                    assert_equal(:absent, result[field],
-                        "Did not set %s absent in %s" % [field, line.inspect])
+            assert_equal(options[:text], result, "Did not generate correct text for %s" % name)
+        end
+
+        # Then do them all at once.
+        records = []
+        text = ""
+        sample_records.each do |name, options|
+            records << options[:record]
+            text += options[:text] + "\n"
+        end
+
+        result = nil
+        assert_nothing_raised("Could not match all records in one file") do
+            result = @provider.to_file(records)
+        end
+
+        assert_header(result)
+
+        assert_equal(text, result, "Did not generate correct full crontab")
+    end
+
+    # Test cronjobs that are made up from multiple records.
+    def test_multi_line_cronjobs
+        fulltext = ""
+        all_records = []
+        sample_crons.each do |name, record_names|
+            records = record_names.collect do |record_name|
+                unless record = sample_records[record_name]
+                    raise "Could not find sample record %s" % record_name
                 end
+                record
+            end
+
+            text = records.collect { |r| r[:text] }.join("\n") + "\n"
+            record_list = records.collect { |r| r[:record] }
+
+            # Add it to our full collection
+            all_records += record_list
+            fulltext += text
+
+            # First make sure we generate each one correctly
+            result = nil
+            assert_nothing_raised("Could not generate multi-line cronjob %s" % [name]) do
+                result = @provider.to_file(record_list)
+            end
+            assert_header(result)
+            assert_equal(text, result, "Did not generate correct text for multi-line cronjob %s" % name)
+
+            # Now make sure we parse each one correctly
+            assert_nothing_raised("Could not parse multi-line cronjob %s" % [name]) do
+                result = @provider.parse(text)
+            end
+            record_list.zip(result).each do |should, record|
+                assert_record_equal("multiline cronjob %s" % name, record, should)
             end
         end
+
+        # Make sure we can generate it all correctly
+        result = nil
+        assert_nothing_raised("Could not generate all multi-line cronjobs") do
+            result = @provider.to_file(all_records)
+        end
+        assert_header(result)
+        assert_equal(fulltext, result, "Did not generate correct text for all multi-line cronjobs")
+
+        # Now make sure we parse them all correctly
+        assert_nothing_raised("Could not parse multi-line cronjobs") do
+            result = @provider.parse(fulltext)
+        end
+        all_records.zip(result).each do |should, record|
+            assert_record_equal("multiline cronjob %s", record, should)
+        end
     end
 
-    def test_parse_and_generate
+    # Take our sample files, and make sure we can entirely parse them,
+    # then that we can generate them again and we get the same data.
+    def test_parse_and_generate_sample_files
         @provider.filetype = :ram
         crondir = datadir(File.join(%w{providers cron}))
         files = Dir.glob("%s/crontab.*" % crondir)
@@ -408,39 +567,38 @@ class TestCronParsedProvider < Test::Unit::TestCase
         target = @provider.target_object(@me)
 
         # First with no env settings
-        cron = @type.create :command => "/bin/echo yay", :name => "test", :hour => 4
+        resource = @type.create :command => "/bin/echo yay", :name => "test", :hour => 4
+        cron = resource.provider
 
-        assert_apply(cron)
+        cron.ensure = :present
+        cron.command = "/bin/echo yay"
+        cron.hour = %w{4}
+        cron.flush
 
-        props = cron.retrieve.inject({}) { |hash, ary| hash[ary[0]] = ary[1]; hash }
+        result = target.read
+        assert_equal("# Puppet Name: test\n* 4 * * * /bin/echo yay\n", result, "Did not write cron out correctly")
 
         # Now set the env
-        cron[:environment] = "TEST=foo"
-        assert_apply(cron)
+        cron.environment = "TEST=foo"
+        cron.flush
 
-        props = cron.retrieve.inject({}) { |hash, ary| hash[ary[0]] = ary[1]; hash }
-        assert(target.read.include?("TEST=foo"), "Did not get environment setting")
-        #assert_equal(["TEST=foo"], props[:environment], "Did not get environment setting")
+        result = target.read
+        assert_equal("# Puppet Name: test\nTEST=foo\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
 
         # Modify it
-        cron[:environment] = ["TEST=foo", "BLAH=yay"]
-        assert_apply(cron)
+        cron.environment = ["TEST=foo", "BLAH=yay"]
+        cron.flush
 
-        props = cron.retrieve.inject({}) { |hash, ary| hash[ary[0]] = ary[1]; hash }
-        assert(target.read.include?("TEST=foo"), "Did not keep environment setting")
-        assert(target.read.include?("BLAH=yay"), "Did not get second environment setting")
-        #assert_equal(["TEST=foo", "BLAH=yay"], props[:environment], "Did not modify environment setting")
+        result = target.read
+        assert_equal("# Puppet Name: test\nTEST=foo\nBLAH=yay\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
 
         # And remove it
-        cron[:environment] = :absent
-        assert_apply(cron)
-
-        props = cron.retrieve.inject({}) { |hash, ary| hash[ary[0]] = ary[1]; hash }
-        assert(! target.read.include?("TEST=foo"), "Did not remove environment setting")
-        assert(! target.read.include?("BLAH=yay"), "Did not remove second environment setting")
-        #assert_nil(props[:environment], "Did not modify environment setting")
+        cron.environment = :absent
+        cron.flush
 
+        result = target.read
+        assert_equal("# Puppet Name: test\n* 4 * * * /bin/echo yay\n", result, "Did not write out environment setting")
     end
 end
 
-# $Id: crontab.rb 2680 2007-07-12 04:27:04Z luke $
+# $Id: crontab.rb 2750 2007-08-06 17:59:37Z luke $

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

@@ -2,11 +2,12 @@
 
 $:.unshift("../../../lib") if __FILE__ =~ /\.rb$/
 
+require 'mocha'
 require 'puppettest'
 require 'puppettest/fileparsing'
 require 'facter'
 
-class TestParsedMounts < Test::Unit::TestCase
+module MountTesting
 	include PuppetTest
 	include PuppetTest::FileParsing
 
@@ -25,6 +26,20 @@ class TestParsedMounts < Test::Unit::TestCase
         super
     end
 
+    def fake_fstab
+        os = Facter['operatingsystem']
+        if os == "Solaris"
+            name = "solaris.fstab"
+        elsif os == "FreeBSD"
+            name = "freebsd.fstab"
+        else
+            # Catchall for other fstabs
+            name = "linux.fstab"
+        end
+        oldpath = @provider.default_target
+        return fakefile(File::join("data/types/mount", name))
+    end
+
     def mkmountargs
         mount = nil
 
@@ -67,6 +82,10 @@ class TestParsedMounts < Test::Unit::TestCase
     def mkfaketype
         @provider.filetype = Puppet::Util::FileType.filetype(:ram)
     end
+end
+
+class TestParsedMounts < Test::Unit::TestCase
+    include MountTesting
 
     def test_default_target
         should = case Facter.value(:operatingsystem)
@@ -113,45 +132,64 @@ class TestParsedMounts < Test::Unit::TestCase
         assert_equal(5, mount.dump, "did not flush change to disk")
     end
 
-    unless Facter["operatingsystem"].value == "Darwin"
-        def test_mountsparse
-            tab = fake_fstab
-            fakedataparse(tab) do
-                # Now just make we've got some mounts we know will be there
-                hashes = @provider.target_records(tab).find_all { |i| i.is_a? Hash }
-                assert(hashes.length > 0, "Did not create any hashes")
-                root = hashes.find { |i| i[:name] == "/" }
-                assert(root, "Could not retrieve root mount")
-
-                assert_nothing_raised("Could not rewrite file") do
-                    @provider.to_file(hashes)
-                end
+    # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
+    def test_flush_when_mounting_absent_fs
+        @provider.filetype = :ram
+        mount = mkmount
+
+        mount.expects(:flush)
+        mount.expects(:mountcmd) # just so we don't actually try to mount anything
+        mount.mount
+    end
+end
+
+class TestParsedMountsNonDarwin < PuppetTest::TestCase
+    confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
+    include MountTesting
+
+    def test_mountsparse
+        tab = fake_fstab
+        fakedataparse(tab) do
+            # Now just make we've got some mounts we know will be there
+            hashes = @provider.target_records(tab).find_all { |i| i.is_a? Hash }
+            assert(hashes.length > 0, "Did not create any hashes")
+            root = hashes.find { |i| i[:name] == "/" }
+            assert(root, "Could not retrieve root mount")
+
+            assert_nothing_raised("Could not rewrite file") do
+                @provider.to_file(hashes)
             end
         end
+    end
 
-        def test_rootfs
-            fs = nil
-            type = @mount.create :name => "/"
+    def test_rootfs
+        fs = nil
+        type = @mount.create :name => "/"
 
-            provider = type.provider
+        provider = type.provider
 
-            assert(FileTest.exists?(@provider.default_target),
-                "FSTab %s does not exist" % @provider.default_target)
+        assert(FileTest.exists?(@provider.default_target),
+            "FSTab %s does not exist" % @provider.default_target)
 
-            assert_nothing_raised do
-                @provider.prefetch("/" => type)
-            end
+        assert_nothing_raised do
+            @provider.prefetch("/" => type)
+        end
 
-            assert_equal(:present, type.provider.property_hash[:ensure],
-                "Could not find root fs with provider %s" % provider.class.name)
+        assert_equal(:present, type.provider.property_hash[:ensure],
+            "Could not find root fs with provider %s" % provider.class.name)
 
-            assert_nothing_raised {
-                assert(provider.mounted?, "Root is considered not mounted")
-            }
-        end
+        assert_nothing_raised {
+            assert(provider.mounted?, "Root is considered not mounted")
+        }
     end
+end
+
+class TestParsedMountsNonDarwinAsRoot < PuppetTest::TestCase
+    confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
+    confine "Not running as root" => Puppet.features.root?
+
+    include MountTesting
 
-    if Puppet.features.root? and Facter.value(:operatingsystem) != "Darwin"
     def test_mountfs
         fs = nil
         case Facter.value(:hostname)
@@ -208,21 +246,6 @@ class TestParsedMounts < Test::Unit::TestCase
             obj.remount
         end
     end
-    end
-
-    def fake_fstab
-        os = Facter['operatingsystem']
-        if os == "Solaris"
-            name = "solaris.fstab"
-        elsif os == "FreeBSD"
-            name = "freebsd.fstab"
-        else
-            # Catchall for other fstabs
-            name = "linux.fstab"
-        end
-        oldpath = @provider.default_target
-        return fakefile(File::join("data/types/mount", name))
-    end
 end
 
-# $Id: parsed.rb 2716 2007-07-19 20:01:47Z luke $
+# $Id: parsed.rb 2745 2007-08-05 17:49:23Z luke $