puppet 0.23.1 → 0.23.2

data/test/ral/providers/parsedfile.rb

@@ -35,7 +35,7 @@ class TestParsedFile < Test::Unit::TestCase
 
     # A simple block to skip the complexity of a full transaction.
     def apply(resource)
-        [:one, :two, :ensure].each do |st|
+        [:one, :two, :ensure, :target].each do |st|
             Puppet.info "Setting %s: %s => %s" %
                 [resource[:name], st, resource.should(st)]
             resource.provider.send(st.to_s + "=", resource.should(st))
@@ -202,44 +202,36 @@ class TestParsedFile < Test::Unit::TestCase
         prov.target_object(:default).write "will b d\n"
 
         # Create some resources for some of those demo files
-        resource = mkresource "bill", :target => :file1, :one => "b", :two => "c"
-        default = mkresource "will", :target => :default, :one => "b", :two => "d"
+        bill = mkresource "bill", :target => :file1, :one => "b", :two => "c"
+        will = mkresource "will", :target => :default, :one => "b", :two => "d"
 
-        resources = {"bill" => resource, "will" => default}
+        resources = {"bill" => bill, "will" => will}
+        prov_ids = {"bill" => bill.provider.object_id, "will" => will.provider.object_id}
 
         assert_nothing_raised do
             prov.prefetch(resources)
         end
 
-        # 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")
-
-        # Now list all of them and make sure we get everything back
-        providers = nil
-        assert_nothing_raised do
-            providers = prov.instances
-        end
-
-        providers.each do |provider|
-            assert_instance_of(prov, provider, "'instances' class method did not return providers")
-        end
+        assert(bill.provider.object_id != prov_ids["bill"], "provider was not replaced in resource")
+        assert(will.provider.object_id != prov_ids["will"], "provider was not replaced in resource")
 
-        %w{bill jill will}.each do |name|
-            assert(providers.find { |provider| provider.name == name},
-                "Did not return %s in list" % name)
-        end
+        # Make sure we prefetched our resources.
+        assert_equal("b", bill.provider.one, "did not prefetch resource from file1")
+        assert_equal("c", bill.provider.two, "did not prefetch resource from file1")
+        assert_equal("b", will.provider.one, "did not prefetch resource from default")
+        assert_equal("d", will.provider.two, "did not prefetch resource from default")
 
         # Now modify our resources and write them out, making sure that prefetching
         # hasn't somehow destroyed this ability
-        resource[:one] = "a"
-        default[:one] = "a"
+        bill[:one] = "a"
+        will[:one] = "a"
 
+        assert_apply(bill)
+        assert_apply(will)
 
-        assert_apply(resource)
-        assert_apply(default)
+        prov.prefetch(resources)
+        assert_equal("a", bill.provider.one, "did not prefetch resource from file1")
+        assert_equal("a", will.provider.one, "did not prefetch resource from default")
 
         assert_equal("bill a c\njill b d\n", prov.target_object(:file1).read,
             "Did not write changed resource correctly")
@@ -703,5 +695,5 @@ class TestParsedFile < Test::Unit::TestCase
     end
 end
 
-# $Id: parsedfile.rb 2676 2007-07-10 23:24:34Z luke $
+# $Id: parsedfile.rb 2750 2007-08-06 17:59:37Z luke $
 

data/test/ral/types/cron.rb

@@ -25,10 +25,12 @@ class TestCron < Test::Unit::TestCase
     end
 
     def teardown
+        super
         @crontype.defaultprovider = nil
         if defined? @oldfiletype
             @provider.filetype = @oldfiletype
         end
+        Puppet::Util::FileType.filetype(:ram).clear
     end
 
     def eachprovider
@@ -138,11 +140,17 @@ class TestCron < Test::Unit::TestCase
             property = cron.send(:property, :command)
             cron.provider.command = command
             cron.provider.ensure = :present
+            cron.provider.user = @me
             cron.provider.month = ["4"]
             cron.provider.class.prefetch
             currentvalue = cron.retrieve
 
-            assert(cron.insync?(currentvalue), "command parsing removes trailing whitespace")
+            currentvalue.each do |prop, value|
+                # We're only interested in comparing the command.
+                next unless prop.name.to_s == "command"
+                assert(prop.insync?(value), "Property %s is not considered in sync with value %s" % [prop.name, value.inspect])
+            end
+
             @crontype.clear
         end
     end
@@ -232,14 +240,18 @@ class TestCron < Test::Unit::TestCase
                 )
             }
 
-            #minute = cron.send(:property, :minute)
+
             cron.provider.ensure = :present
             cron.provider.command = '/bin/date > /dev/null'
             cron.provider.minute = %w{0 30}
             cron.provider.class.prefetch
             currentvalue = cron.retrieve
 
-            assert(cron.insync?(currentvalue), "minute is out of sync with %s" % provider.name)
+            currentvalue.each do |prop, value|
+                # We're only interested in comparing minutes.
+                next unless prop.name.to_s == "minute"
+                assert(prop.insync?(value), "Property %s is not considered in sync with value %s" % [prop.name, value.inspect])
+            end
             @crontype.clear
         end
     end
@@ -309,23 +321,6 @@ class TestCron < Test::Unit::TestCase
         end
     end
 
-    # Disabled, since we no longer have naming requirements.
-    def disabled_test_names
-        cron = mkcron("nametest")
-
-        ["bad name", "bad.name"].each do |name|
-            assert_raise(ArgumentError) do
-                cron[:name] = name
-            end
-        end
-
-        ["good-name", "good-name", "AGoodName"].each do |name|
-            assert_nothing_raised do
-                cron[:name] = name
-            end
-        end
-    end
-
     def test_divisionnumbers
         cron = mkcron("divtest")
         cron[:minute] = "*/5"
@@ -468,7 +463,7 @@ class TestCron < Test::Unit::TestCase
     end
 
     # Make sure the user stuff defaults correctly.
-    def  test_default_user
+    def test_default_user
         crontab = @crontype.provider(:crontab)
         if crontab.suitable?
             inst = @crontype.create(
@@ -491,11 +486,12 @@ class TestCron < Test::Unit::TestCase
     # #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)
+        cron = @crontype.create(:name => "space testing", :command => string)
         assert_apply(cron)
 
         cron.class.clear
-        cron = @crontype.create(:name => "testing", :command => string)
+        cron = @crontype.create(:name => "space testing", :command => string)
+
         # Now make sure that it's correctly in sync
         cron.provider.class.prefetch("testing" => cron)
         properties = cron.retrieve
@@ -506,4 +502,4 @@ class TestCron < Test::Unit::TestCase
 end
 
 
-# $Id: cron.rb 2697 2007-07-14 21:13:04Z luke $
+# $Id: cron.rb 2750 2007-08-06 17:59:37Z luke $

data/test/ral/types/interface.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'mocha'
+
+class TestInterfaceType < PuppetTest::TestCase
+    confine "Could not find suitable interface provider" => Puppet::Type.type(:interface).suitableprovider.length > 0
+
+    def setup
+        super
+        @type = Puppet::Type.type(:interface)
+    end
+
+    def test_prefetch
+        interface = @type.create(:name => "127.0.0.1", :interface => "lo0", :check => :all)
+
+        @type.suitableprovider.each do |provider|
+            assert_nothing_raised("Could not prefetch interfaces from %s provider" % provider.name) do
+                provider.prefetch("eth0" => interface)
+            end
+        end
+    end
+
+    def test_instances
+        @type.suitableprovider.each do |provider|
+            list = nil
+            assert_nothing_raised("Could not get instance list from %s" % provider.name) do
+                list = provider.instances
+            end
+            assert(list.length > 0, "Did not get any instances from %s" % provider.name)
+            list.each do |interface|
+                assert_instance_of(provider, interface, "%s provider returned something other than a provider instance" % provider.name)
+            end
+        end
+    end
+end
+
+# $Id: interface.rb 2750 2007-08-06 17:59:37Z luke $

data/test/ral/types/package.rb

@@ -86,7 +86,11 @@ class TestPackages < Test::Unit::TestCase
     # Make sure we can prefetch and retrieve packages
     def test_package_instances
         providers = []
-        @type.instances.each do |resource|
+        instances = nil
+        assert_nothing_raised("Could not get package instances") do
+            instances = @type.instances
+        end
+        instances.each do |resource|
             # Just do one of each type
             next if providers.include?(resource.provider.class)
             providers << resource.provider.class
@@ -147,4 +151,4 @@ class TestPackages < Test::Unit::TestCase
     end
 end
 
-# $Id: package.rb 2709 2007-07-19 00:14:15Z luke $
+# $Id: package.rb 2753 2007-08-07 02:38:45Z luke $

data/test/util/config.rb

@@ -3,9 +3,8 @@
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'mocha'
-require 'puppet'
-require 'puppet/util/config'
 require 'puppettest'
+require 'puppet/util/config'
 require 'puppettest/parsertesting'
 
 class TestConfig < Test::Unit::TestCase
@@ -17,6 +16,22 @@ class TestConfig < Test::Unit::TestCase
         @config = mkconfig
     end
 
+    def set_configs(config = nil)
+        config ||= @config
+        config.setdefaults("main",
+            :one => ["a", "one"],
+            :two => ["a", "two"],
+            :yay => ["/default/path", "boo"],
+            :mkusers => [true, "uh, yeah"],
+            :name => ["testing", "a"]
+        )
+
+        config.setdefaults("section1",
+            :attr => ["a", "one"],
+            :attrdir => ["/another/dir", "two"],
+            :attr3 => ["$attrdir/maybe", "boo"]
+        )
+    end
 
     def check_for_users
         count = Puppet::Type.type(:user).inject(0) { |c,o|
@@ -25,10 +40,11 @@ class TestConfig < Test::Unit::TestCase
         assert(count > 0, "Found no users")
     end
 
-    def check_to_transportable(config)
+    def test_to_transportable
+        set_configs
         trans = nil
         assert_nothing_raised("Could not convert to a transportable") {
-            trans = config.to_transportable
+            trans = @config.to_transportable
         }
 
         comp = nil
@@ -36,17 +52,16 @@ class TestConfig < Test::Unit::TestCase
             comp = trans.to_type
         }
 
-        check_for_users()
-
         assert_nothing_raised("Could not retrieve transported config") {
             comp.retrieve
         }
     end
 
-    def check_to_manifest(config)
+    def test_to_manifest
+        set_configs
         manifest = nil
         assert_nothing_raised("Could not convert to a manifest") {
-            manifest = config.to_manifest
+            manifest = @config.to_manifest
         }
 
         Puppet[:parseonly] = true
@@ -63,32 +78,51 @@ class TestConfig < Test::Unit::TestCase
         assert_nothing_raised("Could not instantiate objects") {
             trans.to_type
         }
-        check_for_users()
     end
 
-    def check_to_comp(config)
+    def test_to_comp
+        set_configs
         comp = nil
         assert_nothing_raised("Could not convert to a component") {
-            comp = config.to_component
+            comp = @config.to_component
         }
 
         assert_nothing_raised("Could not retrieve component") {
             comp.retrieve
         }
-
-        check_for_users()
     end
 
-    def check_to_config(config)
-        newc = config.dup
+    def test_to_config
+        set_configs
+
+        newc = mkconfig
+        set_configs(newc)
+
+        # Reset all of the values, so we know they're changing.
+        newc.each do |name, obj|
+            next if name == :name
+            newc[name] = true
+        end
 
         newfile = tempfile()
-        File.open(newfile, "w") { |f| f.print config.to_config }
+        File.open(newfile, "w") { |f|
+            @config.to_config.split("\n").each do |line|
+                # Uncomment the settings, so they actually take.
+                if line =~ / = /
+                    f.puts line.sub(/^\s*#/, '')
+                else
+                    f.puts line
+                end
+            end
+        }
+
         assert_nothing_raised("Could not parse generated configuration") {
             newc.parse(newfile)
         }
 
-        assert_equal(config, newc, "Configurations are not equal")
+        @config.each do |name, object|
+            assert_equal(@config[name], newc[name], "Parameter %s is not the same" % name)
+        end
     end
 
     def mkconfig
@@ -316,28 +350,28 @@ yay = /a/path
         assert_nothing_raised("Could not create transportable config") {
             @config.to_transportable
         }
-
-        check_to_comp(@config)
-        Puppet::Type.allclear
-        check_to_manifest(@config)
-        Puppet::Type.allclear
-        check_to_config(@config)
-        Puppet::Type.allclear
-        check_to_transportable(@config)
     end
 
     def test_parse
         result = {
-            :main => {:main => "main", :bad => "invalid"},
-            :puppet => {:other => "puppet"},
-            :puppetd => {:other => "puppetd"}
+            :main => {:main => "main", :bad => "invalid", :cliparam => "reset"},
+            :puppet => {:other => "puppet", :cliparam => "reset"},
+            :puppetd => {:other => "puppetd", :cliparam => "reset"}
         }
         # Set our defaults, so they're valid. Don't define 'bad', since we want to test for failures.
         @config.setdefaults(:main,
             :main => ["whatever", "a"],
+            :cliparam => ["default", "y"],
             :other => ["a", "b"],
             :name => ["puppet", "b"] # our default name
         )
+        @config.setdefaults(:other,
+            :one => ["whatever", "a"],
+            :two => ["default", "y"],
+            :apple => ["a", "b"],
+            :shoe => ["puppet", "b"] # our default name
+        )
+        @config.handlearg("--cliparam", "changed")
         @config.expects(:parse_file).returns(result).times(2)
 
         # First do it with our name being 'puppet'
@@ -349,9 +383,10 @@ yay = /a/path
 
         assert_equal("main", @config[:main], "Did not get main value")
         assert_equal("puppet", @config[:other], "Did not get name value")
+        assert_equal("changed", @config[:cliparam], "CLI values were overridden by config")
 
         # Now switch names and make sure the parsing switches, too.
-        @config.clear
+        @config.clear(true)
         @config[:name] = :puppetd
         assert_nothing_raised("Could not handle parse results") do
             @config.parse(tempfile)
@@ -360,6 +395,7 @@ yay = /a/path
 
         assert_equal("main", @config[:main], "Did not get main value")
         assert_equal("puppetd", @config[:other], "Did not get name value")
+        assert_equal("changed", @config[:cliparam], "CLI values were overridden by config")
     end
 
     # Make sure we can extract file options correctly.
@@ -1167,6 +1203,46 @@ inttest = 27
         assert_equal("oneval/twoval/oneval/twoval", @config[:three],
             "Did not interpolate curlied variables")
     end
+
+    # Discovered from #734
+    def test_set_parameter_hash
+        @config.setdefaults(:section,
+            :unchanged => ["unval", "yay"],
+            :normal => ["normalval", "yay"],
+            :cliparam => ["clival", "yay"],
+            :file => ["/my/file", "yay"]
+        )
+
+        # Set the cli param using the cli method
+        @config.handlearg("--cliparam", "other")
+
+        # Make sure missing params just throw warnings, not errors
+        assert_nothing_raised("Could not call set_parameter_hash with an invalid option") do
+            @config.send(:set_parameter_hash, :missing => "something")
+        end
+
+        # Make sure normal values get set
+        assert_nothing_raised("Could not call set_parameter_hash with a normal value") do
+            @config.send(:set_parameter_hash, :normal => "abnormal")
+        end
+        assert_equal("abnormal", @config[:normal], "Value did not get set")
+        
+        # Make sure cli-set values don't get overridden
+        assert_nothing_raised("Could not call set_parameter_hash with an override of a cli value") do
+            @config.send(:set_parameter_hash, :cliparam => "something else")
+        end
+        assert_equal("other", @config[:cliparam], "CLI value was overridden by config value")
+
+        # Make sure the meta stuff works
+        assert_nothing_raised("Could not call set_parameter_hash with meta info") do
+            @config.send(:set_parameter_hash, :file => "/other/file", :_meta => {:file => {:mode => "0755"}})
+        end
+        assert_equal("/other/file", @config[:file], "value with meta info was overridden by config value")
+        assert_equal("0755", @config.element(:file).mode, "Did not set mode from meta info")
+
+        # And make sure other params are unchanged
+        assert_equal("unval", @config[:unchanged], "Unchanged value has somehow changed")
+    end
 end
 
-# $Id: config.rb 2464 2007-05-06 05:42:53Z luke $
+# $Id: config.rb 2743 2007-08-04 00:36:47Z luke $