puppet 0.23.0 → 0.23.1

data/test/network/server/mongrel_test.rb

@@ -60,6 +60,12 @@ class TestMongrelServer < PuppetTest::TestCase
         assert_equal(ip, info.ip, "Did not copy over ip correctly")
         assert_equal(Resolv.getname(ip), info.name, "Did not look up hostname correctly")
     end
+
+    def test_daemonize
+        mongrel = mkserver
+
+        assert(mongrel.respond_to?(:daemonize), "Mongrel server does not respond to daemonize")
+    end
 end
 
-# $Id: mongrel_test.rb 2570 2007-06-13 16:14:52Z luke $
+# $Id: mongrel_test.rb 2659 2007-07-08 23:02:06Z luke $

data/test/other/propertychange.rb

@@ -9,7 +9,7 @@ require 'puppettest'
 
 class TestPropertyChange < Test::Unit::TestCase
 	include PuppetTest
-	class FakeProperty < Puppet::Type::Property
+	class FakeProperty < Puppet::Property
 	    attr_accessor :is, :should, :resource
 	    attr_reader :noop
 	    def change_to_s(currentvalue, newvalue)
@@ -138,4 +138,4 @@ class TestPropertyChange < Test::Unit::TestCase
     end
 end
 
-# $Id: propertychange.rb 2517 2007-05-15 19:22:36Z luke $
+# $Id: propertychange.rb 2647 2007-07-04 22:25:23Z luke $

data/test/other/transactions.rb

@@ -7,15 +7,15 @@ require 'puppettest'
 require 'mocha'
 require 'puppettest/support/resources'
 
-# $Id: transactions.rb 2551 2007-06-04 20:37:14Z luke $
+# $Id: transactions.rb 2678 2007-07-11 19:30:42Z luke $
 
 class TestTransactions < Test::Unit::TestCase
     include PuppetTest::FileTesting
     include PuppetTest::Support::Resources
-    class Fakeprop <Puppet::Type::Property
+    class Fakeprop <Puppet::Property
         attr_accessor :path, :is, :should, :name
-        def should_to_s
-            @should.to_s
+        def should_to_s(value)
+            value.to_s
         end
         def insync?(foo)
             true
@@ -1148,6 +1148,45 @@ class TestTransactions < Test::Unit::TestCase
         assert(FileTest.exists?(paths[1]), "Deleted required purging file")
         assert(! FileTest.exists?(paths[2]), "Did not delete non-purged file")
     end
+
+    def test_flush
+        $state = "absent"
+        $flushed = 0
+        type = Puppet::Type.newtype(:flushtest) do
+            newparam(:name)
+            newproperty(:ensure) do
+                def retrieve
+                    $state
+                end
+                def set(value)
+                    $state = value
+                    :thing_changed
+                end
+            end
+
+            def flush
+                $flushed += 1
+            end
+        end
+
+        cleanup { Puppet::Type.rmtype(:flushtest) }
+
+        obj = type.create(:name => "test", :ensure => "present")
+
+        # first make sure it runs through and flushes
+        assert_apply(obj)
+
+        assert_equal("present", $state, "Object did not make a change")
+        assert_equal(1, $flushed, "object was not flushed")
+
+        # Now run a noop and make sure we don't flush
+        obj[:ensure] = "other"
+        obj[:noop] = true
+
+        assert_apply(obj)
+        assert_equal("present", $state, "Object made a change in noop")
+        assert_equal(1, $flushed, "object was flushed in noop")
+    end
 end
 
-# $Id: transactions.rb 2551 2007-06-04 20:37:14Z luke $
+# $Id: transactions.rb 2678 2007-07-11 19:30:42Z luke $

data/test/puppet/modules.rb

@@ -2,7 +2,6 @@
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
-require 'puppet'
 require 'puppettest'
 
 class TestModules < Test::Unit::TestCase
@@ -56,3 +55,5 @@ class TestModules < Test::Unit::TestCase
         assert_equal(templ_path, mod.template(templ))
     end
 end
+
+# $Id: modules.rb 2655 2007-07-06 22:22:10Z luke $

data/test/rails/ast.rb

@@ -30,15 +30,14 @@ class TestRailsAST < PuppetTest::TestCase
             code = nil
             str = nil
 
-            # We don't support anything but the title in rails right now
+            # We don't support more than one search criteria at the moment.
             retval = nil
             bad = false
             # Figure out if the search is for anything rails will ignore
-            string.scan(/(\w+) [!=]= \w+/) do |s|
-                unless s[0] == "title"
-                    bad = true
-                    break
-                end
+            if string =~ /\band\b|\bor\b/
+                bad = true
+            else
+                bad = false
             end
 
             # And if it is, make sure we throw an error.
@@ -54,7 +53,7 @@ class TestRailsAST < PuppetTest::TestCase
             end
             assert_nothing_raised("Could not find resource") do
                 retval = Puppet::Rails::Resource.find(:all,
-                    :include => :param_values,
+                    :include => {:param_values => :param_name},
                     :conditions => str) 
             end
 
@@ -71,4 +70,4 @@ class TestRailsAST < PuppetTest::TestCase
     end
 end
 
-# $Id: ast.rb 2597 2007-06-17 21:41:50Z luke $
+# $Id: ast.rb 2705 2007-07-18 17:32:46Z luke $

data/test/rails/collection.rb

@@ -188,7 +188,7 @@ class TestRailsCollection < PuppetTest::TestCase
         # Make our configuration
         host = Puppet::Rails::Host.new(:name => "myhost")
 
-        host.resources.build(:title => "/tmp/hosttest", :type => "file",
+        host.resources.build(:title => "/tmp/hosttest", :restype => "file",
             :exported => true)
 
         host.save
@@ -211,4 +211,4 @@ class TestRailsCollection < PuppetTest::TestCase
     end
 end
 
-# $Id: collection.rb 2596 2007-06-17 01:02:31Z luke $
+# $Id: collection.rb 2663 2007-07-09 06:00:42Z luke $

data/test/rails/railsresource.rb

@@ -184,6 +184,8 @@ class TestExportedResources < PuppetTest::TestCase
                     "%s was different %s" % [param.name, tail])
             end
         end
+
+        return obj
     end
 
     def test_to_rails
@@ -194,40 +196,54 @@ class TestExportedResources < PuppetTest::TestCase
         res = mkresource :type => "file", :title => "/tmp/testing",
             :source => @source, :scope => @scope,
             :params => {:owner => "root", :source => ["/tmp/A", "/tmp/B"],
-                :mode => "755", :require => [ref1, ref2]}
+                :mode => "755", :require => [ref1, ref2], :subscribe => ref1}
 
         res.line = 50
 
         # We also need a Rails Host to store under
         host = Puppet::Rails::Host.new(:name => Facter.hostname)
 
-        compare_resources(host, res, false, :params => %w{owner source mode})
+        railsres = compare_resources(host, res, false, :params => %w{owner source mode})
 
         # Now make sure our parameters did not change
         assert_instance_of(Array, res[:require], "Parameter array changed")
         res[:require].each do |ref|
             assert_instance_of(Reference, ref, "Resource reference changed")
         end
+        assert_instance_of(Reference, res[:subscribe], "Resource reference changed")
+
+        # And make sure that the rails resource actually has resource references
+        params = railsres.parameters
+        [params["subscribe"], params["require"]].flatten.each do |ref|
+            assert_instance_of(Reference, ref, "Resource reference is no longer a reference")
+        end
 
         # Now make some changes to our resource.  We're removing the mode,
         # changing the source, and adding 'check'.
         res = mkresource :type => "file", :title => "/tmp/testing",
             :source => @source, :scope => @scope,
             :params => {:owner => "bin", :source => ["/tmp/A", "/tmp/C"],
-            :check => "checksum",  :require => [ref1, ref2]}
+            :check => "checksum",  :require => [ref1, ref2], :subscribe => ref2}
 
         res.line = 75
         res.exported = true
 
-        compare_resources(host, res, true, :params => %w{owner source mode check})
+        railsres = compare_resources(host, res, true, :params => %w{owner source mode check})
 
         # Again make sure our parameters did not change
         assert_instance_of(Array, res[:require], "Parameter array changed")
         res[:require].each do |ref|
             assert_instance_of(Reference, ref, "Resource reference changed")
         end
+
+        # Again with the serialization checks
+        params = railsres.parameters
+        [params["subscribe"], params["require"]].flatten.each do |ref|
+            assert_instance_of(Reference, ref, "Resource reference is no longer a reference")
+        end
+
     end
 end
 
-# $Id: railsresource.rb 2597 2007-06-17 21:41:50Z luke $
+# $Id: railsresource.rb 2706 2007-07-18 19:47:09Z luke $
 

data/test/ral/manager/attributes.rb

@@ -6,6 +6,7 @@
 $:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
+require 'mocha'
 
 class TestTypeAttributes < Test::Unit::TestCase
     include PuppetTest
@@ -315,6 +316,37 @@ class TestTypeAttributes < Test::Unit::TestCase
             inst.value = :nosuchattr
         end
     end
+
+    def test_check_ignores_unsupported_params
+        type = Puppet::Type.newtype(:unsupported) do
+            feature :nosuchfeat, "testing"
+            newparam(:name) {}
+            newproperty(:yep) {}
+            newproperty(:nope,  :required_features => :nosuchfeat) {}
+        end
+        $yep = :absent
+        type.provide(:only) do
+            def self.supports_parameter?(param)
+                if param.name == :nope
+                    return false
+                else
+                    return true
+                end
+            end
+
+            def yep
+                $yep
+            end
+            def yep=(v)
+                $yep = v
+            end
+        end
+        cleanup { Puppet::Type.rmtype(:unsupported) }
+
+        obj = type.create(:name => "test", :check => :yep)
+        obj.expects(:newattr).with(:nope).never
+        obj[:check] = :all
+    end
 end
 
-# $Id: attributes.rb 2591 2007-06-15 19:49:26Z luke $
+# $Id: attributes.rb 2684 2007-07-12 16:39:47Z luke $

data/test/ral/manager/instances.rb

@@ -43,40 +43,67 @@ class TestTypeInstances < Test::Unit::TestCase
                 @instances
             end
 
-            @names = [:one]
+            @names = [:one, :five, :six]
         end
 
         # A provider with the same source
         @type.provide(:sub, :source => :default, :parent => :default) do
-            @names = [:two]
+            @names = [:two, :seven, :eight]
         end
 
         # An unsuitable provider
         @type.provide(:nope, :parent => :default) do
             confine :exists => "/no/such/file"
-            @names = [:three]
+            @names = [:three, :nine, :ten]
         end
 
         # Another suitable, non-default provider
         @type.provide(:yep, :parent => :default) do
-            @names = [:four]
+            @names = [:four, :seven, :ten]
         end
 
+        # Now make a couple of instances, so we know we correctly match instead of always
+        # trying to create new ones.
+        one = @type.create(:name => :one, :ensure => :present)
+        three = @type.create(:name => :three, :ensure => :present, :provider => :sub)
+        five = @type.create(:name => :five, :ensure => :present, :provider => :yep)
+
         result = nil
         assert_nothing_raised("Could not get instance list") do
             result = @type.instances
         end
 
+        result.each do |resource|
+            assert_instance_of(@type, resource, "Returned non-resource")
+        end
+
         assert_equal(:one, result[0].name, "Did not get default instances first")
-        assert_equal(@type.provider(:default).instances[0], result[0].provider, "Provider instances were not maintained")
 
         resources = result.inject({}) { |hash, res| hash[res.name] = res; hash }
         assert(resources.include?(:four), "Did not get resources from other suitable providers")
         assert(! resources.include?(:three), "Got resources from unsuitable providers")
 
+        # Now make sure we didn't change the provider type for :five
+        assert_equal(:yep, five.provider.class.name, "Changed provider type when listing resources")
+
         # Now make sure the resources have an 'ensure' property to go with the value in the provider
         assert(resources[:one].send(:instance_variable_get, "@parameters").include?(:ensure), "Did not create ensure property")
     end
+
+    # Make sure resources are entirely deleted.
+    def test_delete
+        aliases = %w{one}
+        obj = @type.create(:name => "testing", :alias => "two")
+        aliases << "two"
+
+        @type.alias("two", obj)
+
+        obj.remove
+        assert_nil(@type["testing"], "Object was not removed from objects hash")
+        assert_nil(@type["one"], "Object's alias was not removed")
+        assert_nil(@type["two"], "Object's second alias was not removed")
+
+    end
 end
 
-# $Id: instances.rb 2551 2007-06-04 20:37:14Z luke $
+# $Id: instances.rb 2718 2007-07-19 22:12:51Z luke $

data/test/ral/manager/type.rb

@@ -316,54 +316,6 @@ class TestType < Test::Unit::TestCase
         end
     end
 
-    def test_loadplugins
-        names = %w{loadedplugin1 loadplugin2 loadplugin3}
-        dirs = []
-        3.times { dirs << tempfile() }
-        # Set plugindest to something random
-        Puppet[:plugindest] = tempfile()
-
-        Puppet[:pluginpath] = dirs.join(":")
-
-        names.each do |name|
-            dir = dirs.shift
-            Dir.mkdir(dir)
-
-            # Create an extra file for later
-            [name, name + "2ness"].each do |n|
-                file = File.join(dir, n + ".rb")
-                File.open(file, "w") do |f|
-                    f.puts %{Puppet::Type.newtype('#{n}') do
-    newparam(:argument) do
-        isnamevar
-    end
-end
-}
-                end
-            end
-
-            assert(Puppet::Type.type(name),
-                "Did not get loaded plugin")
-
-            assert_nothing_raised {
-                Puppet::Type.type(name).create(
-                    :name => "myname"
-                )
-            }
-        end
-
-        # Now make sure the plugindest got added to our pluginpath
-        assert(Puppet[:pluginpath].split(":").include?(Puppet[:plugindest]),
-            "Plugin dest did not get added to plugin path")
-
-        # Now make sure it works with just a single path, using the extra files
-        # created above.
-        Puppet[:pluginpath] = Puppet[:pluginpath].split(":")[0]
-        assert(Puppet::Type.type("loadedplugin12ness"),
-            "Did not get loaded plugin")
-
-    end
-
     def test_newtype_methods
         assert_nothing_raised {
             Puppet::Type.newtype(:mytype) do
@@ -835,6 +787,34 @@ end
 
         obj.evaluate
     end
+
+    # Partially test #704, but also cover the rest of the schedule management bases.
+    def test_schedule
+        Puppet::Type.type(:schedule).create(:name => "maint")
+
+        {"maint" => true, nil => false, :fail => :fail}.each do |name, should|
+            args = {:name => tempfile, :ensure => :file}
+            if name
+                args[:schedule] = name
+            end
+            resource = Puppet::Type.type(:file).create(args)
+
+            if should == :fail
+                assert_raise(Puppet::Error, "Did not fail on missing schedule") do
+                    resource.schedule
+                end
+            else
+                sched = nil
+                assert_nothing_raised("Failed when schedule was %s" % sched) do
+                    sched = resource.schedule
+                end
+
+                if should
+                    assert_equal(name, sched.name, "did not get correct schedule back")
+                end
+            end
+        end
+    end
 end
 
-# $Id: type.rb 2500 2007-05-09 22:05:32Z luke $
+# $Id: type.rb 2683 2007-07-12 16:04:34Z luke $

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

@@ -6,7 +6,6 @@ require 'puppettest'
 require 'mocha'
 require 'puppettest/fileparsing'
 require 'puppet/type/cron'
-require 'puppet/provider/cron/crontab'
 
 class TestCronParsedProvider < Test::Unit::TestCase
 	include PuppetTest
@@ -254,27 +253,76 @@ class TestCronParsedProvider < Test::Unit::TestCase
     # Test that a specified cron job will be matched against an existing job
     # with no name, as long as all fields match
     def test_matchcron
-        str = "0,30 * * * * date\n"
+        mecron = "0,30 * * * * date
+
+        * * * * * funtest
+        # a comment
+        0,30 * * 1 * date
+        "
+
+        youcron = "0,30 * * * * date
+
+        * * * * * yaytest
+        # a comment
+        0,30 * * 1 * fooness
+        "
         setme
         @provider.filetype = :ram
+        you = "you"
 
-        cron = nil
-        assert_nothing_raised {
-            cron = @type.create(
+        # Write the same tab to multiple targets
+        @provider.target_object(@me).write(mecron.gsub(/^\s+/, ''))
+        @provider.target_object(you).write(youcron.gsub(/^\s+/, ''))
+
+        # Now make some crons that should match
+        matchers = [
+            @type.create(
                 :name => "yaycron",
                 :minute => [0, 30],
                 :command => "date",
                 :user => @me
+            ),
+            @type.create(
+                :name => "youtest",
+                :command => "yaytest",
+                :user => you
             )
-        }
+        ]
+
+        nonmatchers = [
+            @type.create(
+                :name => "footest",
+                :minute => [0, 30],
+                :hour => 1,
+                :command => "fooness",
+                :user => @me # wrong target
+            ),
+            @type.create(
+                :name => "funtest2",
+                :command => "funtest",
+                :user => you # wrong target for this cron
+            )
+        ]
+
+        # Create another cron so we prefetch two of them
+        @type.create(:name => "testing", :minute => 30, :command => "whatever", :user => "you")
+
+        assert_nothing_raised("Could not prefetch cron") do
+            @provider.prefetch([matchers, nonmatchers].flatten.inject({}) { |crons, cron| crons[cron.name] = cron; crons })
+        end
 
-        hash = @provider.parse_line(str)
-        hash[:user] = @me
+        matchers.each do |cron|
+            assert_equal(:present, cron.provider.ensure, "Cron %s was not matched" % cron.name)
+            if value = cron.value(:minute) and value == "*"
+                value = :absent
+            end
+            assert_equal(value, cron.provider.minute, "Minutes were not retrieved, so cron was not matched")
+            assert_equal(cron.value(:target), cron.provider.target, "Cron %s was matched from the wrong target" % cron.name)
+        end
 
-        instance = @provider.match(hash, "yaycron" => cron)
-        assert(instance, "did not match cron")
-        assert_equal(cron, instance,
-            "Did not match cron job")
+        nonmatchers.each do |cron|
+            assert_equal(:absent, cron.provider.ensure, "Cron %s was incorrectly matched" % cron.name)
+        end
     end
 
     def test_data
@@ -395,4 +443,4 @@ class TestCronParsedProvider < Test::Unit::TestCase
     end
 end
 
-# $Id: crontab.rb 2624 2007-06-19 01:49:19Z luke $
+# $Id: crontab.rb 2680 2007-07-12 04:27:04Z luke $