puppet 0.22.4 → 0.23.0

data/test/ral/manager/attributes.rb

@@ -42,19 +42,14 @@ class TestTypeAttributes < Test::Unit::TestCase
 
             if param == :property
                 assert(inst.property(param), "did not get obj for %s" % param)
-            end
-
-            if param == :property
                 assert_equal(true, inst.should(param),
                     "should value did not get set")
-                inst.is = [:property, true]
+            else
+                assert_equal(true, inst[param],
+                             "did not get correct value for %s from symbol" % param)
+                assert_equal(true, inst[param.to_s],
+                             "did not get correct value for %s from string" % param)
             end
-
-            # Now make sure we can get it back
-            assert_equal(true, inst[param],
-                "did not get correct value for %s from symbol" % param)
-            assert_equal(true, inst[param.to_s],
-                "did not get correct value for %s from string" % param)
         end
     end
 
@@ -232,7 +227,6 @@ class TestTypeAttributes < Test::Unit::TestCase
         type.provide(:testing) {}
         provider = type.attrclass(:provider)
         should = [[name, :param], [provider, :param], [two, :property], [one, :param]]
-
         assert_nothing_raised do
             result = nil
             type.eachattr do |obj, name|
@@ -260,7 +254,7 @@ class TestTypeAttributes < Test::Unit::TestCase
 
         # Now make similar providers
         nope = type.provide(:nope) {}
-        maybe = type.provide(:maybe) { has_features :fone}
+        maybe = type.provide(:maybe) { has_feature :fone}
         yep = type.provide(:yep) { has_features :fone, :ftwo}
 
         attrs = [:none, :one, :two]
@@ -291,6 +285,36 @@ class TestTypeAttributes < Test::Unit::TestCase
             @logs.clear
         end
     end
+
+    # Make sure the 'check' metaparam just ignores non-properties, rather than failing.
+    def test_check_allows_parameters
+        file = Puppet::Type.type(:file)
+        klass = file.attrclass(:check)
+
+        resource = file.create(:path => tempfile)
+        inst = klass.new(:resource => resource)
+
+        {:property => [:owner, :group], :parameter => [:ignore, :recurse], :metaparam => [:require, :subscribe]}.each do |attrtype, attrs|
+            assert_nothing_raised("Could not set check to a single %s value" % attrtype) do
+                inst.value = attrs[0]
+            end
+
+            if attrtype == :property
+                assert(resource.property(attrs[0]), "Check did not create property instance during single check")
+            end
+            assert_nothing_raised("Could not set check to multiple %s values" % attrtype) do
+                inst.value = attrs
+            end
+            if attrtype == :property
+                assert(resource.property(attrs[1]), "Check did not create property instance during multiple check")
+            end
+        end
+
+        # But make sure actually invalid attributes fail
+        assert_raise(Puppet::Error, ":check did not fail on invalid attribute") do
+            inst.value = :nosuchattr
+        end
+    end
 end
 
-# $Id: attributes.rb 2414 2007-04-25 20:59:00Z luke $
+# $Id: attributes.rb 2591 2007-06-15 19:49:26Z luke $

data/test/ral/manager/instances.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2007-06-10.
+#  Copyright (c) 2007. All rights reserved.
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+class TestTypeInstances < Test::Unit::TestCase
+    include PuppetTest
+
+    def setup
+        super
+        @type = Puppet::Type.newtype(:instance_test) do
+            newparam(:name) {}
+            ensurable
+        end
+        cleanup { Puppet::Type.rmtype(:instance_test) }
+    end
+
+    # Make sure the instances class method works as expected.
+    def test_instances
+        # First make sure it throws an error when there are no providers
+        assert_raise(Puppet::DevError, "Did not fail when no providers are present") do
+            @type.instances
+        end
+
+        # Now add a couple of providers
+
+        # The default
+        @type.provide(:default) do
+            defaultfor :operatingsystem => Facter.value(:operatingsystem)
+            mk_resource_methods
+            class << self
+                attr_accessor :names
+            end
+            def self.instance(name)
+                new(:name => name, :ensure => :present)
+            end
+            def self.instances
+                @instances ||= names.collect { |name| instance(name) }
+                @instances
+            end
+
+            @names = [:one]
+        end
+
+        # A provider with the same source
+        @type.provide(:sub, :source => :default, :parent => :default) do
+            @names = [:two]
+        end
+
+        # An unsuitable provider
+        @type.provide(:nope, :parent => :default) do
+            confine :exists => "/no/such/file"
+            @names = [:three]
+        end
+
+        # Another suitable, non-default provider
+        @type.provide(:yep, :parent => :default) do
+            @names = [:four]
+        end
+
+        result = nil
+        assert_nothing_raised("Could not get instance list") do
+            result = @type.instances
+        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 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
+end
+
+# $Id: instances.rb 2551 2007-06-04 20:37:14Z luke $

data/test/ral/manager/provider.rb

@@ -8,47 +8,85 @@ require 'mocha'
 class TestTypeProviders < Test::Unit::TestCase
 	include PuppetTest
 
-    # Make sure default providers behave correctly
-    def test_defaultproviders
-        # Make a fake type
-        type = Puppet::Type.newtype(:defaultprovidertest) do
-            newparam(:name) do end
+    def setup
+        super
+        @type = Puppet::Type.newtype(:provider_test) do
+            newparam(:name) {}
+            ensurable
         end
+        cleanup { Puppet::Type.rmtype(:provider_test) }
+    end
 
-        cleanup { Puppet::Type.rmtype(:defaultprovidertest) }
-
-        basic = type.provide(:basic) do
+    # Make sure default providers behave correctly
+    def test_defaultproviders
+        basic = @type.provide(:basic) do
             defaultfor :operatingsystem => :somethingelse,
                 :operatingsystemrelease => :yayness
         end
 
-        assert_equal(basic, type.defaultprovider)
-        type.defaultprovider = nil
+        assert_equal(basic, @type.defaultprovider)
+        @type.defaultprovider = nil
 
-        greater = type.provide(:greater) do
+        greater = @type.provide(:greater) do
             defaultfor :operatingsystem => Facter.value("operatingsystem")
         end
 
-        assert_equal(greater, type.defaultprovider)
+        assert_equal(greater, @type.defaultprovider)
     end
 
     # Make sure the provider is always the first parameter created.
     def test_provider_sorting
-        type = Puppet::Type.newtype(:sorttest) do
-            newparam(:name) {}
-            ensurable
-        end
-        cleanup { Puppet::Type.rmtype(:sorttest) }
-
         should = [:name, :ensure]
-        assert_equal(should, type.allattrs.reject { |p| ! should.include?(p) },
+        assert_equal(should, @type.allattrs.reject { |p| ! should.include?(p) },
             "Got wrong order of parameters")
 
-        type.provide(:yay) { }
+        @type.provide(:yay) { }
         should = [:name, :provider, :ensure]
-        assert_equal(should, type.allattrs.reject { |p| ! should.include?(p) },
+        assert_equal(should, @type.allattrs.reject { |p| ! should.include?(p) },
             "Providify did not reorder parameters")
     end
+
+    # Make sure that provider instances can be passed in directly.
+    def test_name_or_provider
+        provider = @type.provide(:testing) do
+        end
+
+        # first make sure we can pass the name in
+        resource = nil
+        assert_nothing_raised("Could not create provider instance by name") do
+            resource = @type.create :name => "yay", :provider => :testing
+        end
+
+        assert_instance_of(provider, resource.provider, "Did not create provider instance")
+
+        # Now make sure we can pass in an instance
+        provinst = provider.new(:name => "foo")
+        assert_nothing_raised("Could not pass in provider instance") do
+            resource = @type.create :name => "foo", :provider => provinst
+        end
+
+        assert_equal(provinst, resource.provider, "Did not retain provider instance")
+        assert_equal(provider.name, resource[:provider], "Provider value was set to the provider instead of its name")
+
+        # Now make sure unsuitable provider instances still throw errors
+        provider = @type.provide(:badprov) do
+            confine :exists => "/no/such/file"
+        end
+
+        inst = provider.new(:name => "bar")
+        assert_raise(Puppet::Error, "Did not fail on unsuitable provider instance") do
+            resource = @type.create :name => "bar", :provider => inst
+        end
+
+        # And make sure the provider must be a valid provider type for this resource
+        pkgprov = Puppet::Type.type(:package).create(:name => "yayness").provider
+        assert(provider, "did not get package provider")
+
+        assert_raise(Puppet::Error, "Did not fail on invalid provider instance") do
+            resource = @type.create :name => "bar", :provider => pkgprov
+        end
+
+    end
 end
 
-# $Id: provider.rb 2428 2007-04-28 01:18:23Z luke $
+# $Id: provider.rb 2552 2007-06-05 01:17:00Z luke $

data/test/ral/manager/type.rb

@@ -285,7 +285,7 @@ class TestType < Test::Unit::TestCase
     def test_object_recursion
         comp = Puppet.type(:component).create(:name => "top")
 
-        file = Puppet.type(:file).create(:path => tempfile, :ensure => :file)
+        file = Puppet.type(:component).create(:name => "middle")
 
         assert_raise(Puppet::DevError) do
             comp.push(comp)
@@ -414,6 +414,9 @@ end
     def test_newproperty_options
         # Create a type with a fake provider
         providerclass = Class.new do
+            def self.supports_parameter?(prop)
+                return true
+            end
             def method_missing(method, *args)
                 return method
             end
@@ -441,7 +444,7 @@ end
         # Now create an instance
         obj = type.create(:name => :myobj)
 
-        inst = property.new(:parent => obj)
+        inst = property.new(:resource => obj)
 
         # And make sure it's correctly setting @is
         ret = nil
@@ -449,7 +452,7 @@ end
             ret = inst.retrieve
         }
 
-        assert_equal(:noopts, inst.is)
+        assert_equal(:noopts, inst.retrieve)
 
         # Now create a property with a different way of doing it
         property = nil
@@ -457,7 +460,7 @@ end
             property = type.newproperty(:setretrieve, :retrieve => :yayness)
         end
 
-        inst = property.new(:parent => obj)
+        inst = property.new(:resource => obj)
 
         # And make sure it's correctly setting @is
         ret = nil
@@ -465,7 +468,7 @@ end
             ret = inst.retrieve
         }
 
-        assert_equal(:yayness, inst.is)
+        assert_equal(:yayness, ret)
     end
 
     def test_name_vs_title
@@ -834,4 +837,4 @@ end
     end
 end
 
-# $Id: type.rb 2275 2007-03-08 21:18:43Z luke $
+# $Id: type.rb 2500 2007-05-09 22:05:32Z luke $

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

@@ -58,6 +58,7 @@ class TestCronParsedProvider < Test::Unit::TestCase
         files = Dir.glob("%s/crontab.*" % crondir)
 
         setme
+        @provider.default_target = @me
         target = @provider.target_object(@me)
         files.each do |file|
             str = args = nil
@@ -82,7 +83,7 @@ class TestCronParsedProvider < Test::Unit::TestCase
             end
             target.write(str)
             assert_nothing_raised("could not parse %s" % file) do
-                @provider.prefetch_target(@me)
+                @provider.prefetch
             end
             records = @provider.send(:instance_variable_get, "@records")
 
@@ -90,6 +91,7 @@ class TestCronParsedProvider < Test::Unit::TestCase
                 # Make the values a bit more equal.
                 should[:target] = @me
                 should[:ensure] = :present
+                #should[:environment] ||= []
                 should[:on_disk] = true
                 is = sis.dup
                 sis.dup.each do |p,v|
@@ -150,7 +152,7 @@ class TestCronParsedProvider < Test::Unit::TestCase
         target = @provider.target_object(user)
         target.write(str)
         assert_nothing_raised {
-            @provider.prefetch_target(user)
+            @provider.prefetch
         }
 
         assert_nothing_raised {
@@ -236,7 +238,7 @@ class TestCronParsedProvider < Test::Unit::TestCase
             assert_equal(str, target.read,
                 "Did not write correctly")
             assert_nothing_raised("Could not prefetch with %s" % str.inspect) do
-                @provider.prefetch_target(@me)
+                @provider.prefetch
             end
             assert_nothing_raised("Could not flush with %s" % str.inspect) do
                 @provider.flush_target(@me)
@@ -269,7 +271,7 @@ class TestCronParsedProvider < Test::Unit::TestCase
         hash = @provider.parse_line(str)
         hash[:user] = @me
 
-        instance = @provider.match(hash)
+        instance = @provider.match(hash, "yaycron" => cron)
         assert(instance, "did not match cron")
         assert_equal(cron, instance,
             "Did not match cron job")
@@ -284,7 +286,7 @@ class TestCronParsedProvider < Test::Unit::TestCase
             target.write(text)
 
             assert_nothing_raised("Could not parse %s" % file) do
-                @provider.prefetch_target(@me)
+                @provider.prefetch
             end
             # mark the provider modified
             @provider.modified(@me)
@@ -324,7 +326,7 @@ class TestCronParsedProvider < Test::Unit::TestCase
             assert_equal(str, target.read,
                 "Did not write correctly")
             assert_nothing_raised("Could not prefetch with %s" % str.inspect) do
-                @provider.prefetch_target(@me)
+                @provider.prefetch
             end
             records = @provider.send(:instance_variable_get, "@records")
             records.each do |r|
@@ -341,6 +343,56 @@ class TestCronParsedProvider < Test::Unit::TestCase
             @provider.clear
         end
     end
+
+    def test_prefetch
+        cron = @type.create :command => "/bin/echo yay", :name => "test", :hour => 4
+
+        assert_nothing_raised("Could not prefetch cron") do
+            cron.provider.class.prefetch("test" => cron)
+        end
+    end
+
+    # Testing #669.
+    def test_environment_settings
+        @provider.filetype = :ram
+        setme
+
+        target = @provider.target_object(@me)
+
+        # First with no env settings
+        cron = @type.create :command => "/bin/echo yay", :name => "test", :hour => 4
+
+        assert_apply(cron)
+
+        props = cron.retrieve.inject({}) { |hash, ary| hash[ary[0]] = ary[1]; hash }
+
+        # Now set the env
+        cron[:environment] = "TEST=foo"
+        assert_apply(cron)
+
+        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")
+
+        # Modify it
+        cron[:environment] = ["TEST=foo", "BLAH=yay"]
+        assert_apply(cron)
+
+        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")
+
+        # 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")
+
+    end
 end
 
-# $Id: crontab.rb 2334 2007-03-19 23:04:32Z luke $
+# $Id: crontab.rb 2624 2007-06-19 01:49:19Z luke $