puppet 0.18.4 → 0.22.4

data/test/rails/rails.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/rails'
+require 'puppet/parser/interpreter'
+require 'puppet/parser/parser'
+require 'puppet/network/client'
+require 'puppettest'
+require 'puppettest/parsertesting'
+require 'puppettest/resourcetesting'
+require 'puppettest/railstesting'
+
+class TestRails < Test::Unit::TestCase
+    include PuppetTest::ParserTesting
+    include PuppetTest::ResourceTesting
+    include PuppetTest::RailsTesting
+
+    def test_includerails
+        assert_nothing_raised {
+            require 'puppet/rails'
+        }
+    end
+end
+
+# $Id: rails.rb 2179 2007-02-08 01:39:39Z luke $

data/test/rails/railsparameter.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/rails'
+require 'puppettest'
+require 'puppettest/railstesting'
+
+# Don't do any tests w/out this class
+if defined? ActiveRecord::Base
+class TestRailsParameter < Test::Unit::TestCase
+    include PuppetTest::RailsTesting
+    
+    # Create a resource param from a rails parameter
+    def test_to_resourceparam
+        railsinit
+
+        # Now create a source
+        interp = mkinterp
+        source = interp.newclass "myclass"
+        
+        #FIXME Need to re-add file/line support
+
+        # Use array and non-array values, to make sure we get things back in
+        # the same form.
+        {"myname" => "myval", "multiple" => %w{one two three}}.each do |name, value|
+            param = Puppet::Rails::ParamName.new(:name => name)
+            if value.is_a? Array
+                values = value
+            else
+                values = [value]
+            end
+            valueobjects = values.collect do |v|
+                obj = Puppet::Rails::ParamValue.new(:value => v)
+                assert_nothing_raised do
+                    param.param_values << obj
+                end
+            end
+
+            assert(param, "Did not create rails parameter")
+
+            # The id doesn't get assigned until we save
+            param.save
+
+            # And try to convert our parameter
+            pp = nil
+            assert_nothing_raised do
+                pp = param.to_resourceparam(source)
+            end
+
+            assert_instance_of(Puppet::Parser::Resource::Param, pp)
+            assert_equal(name.to_sym, pp.name, "parameter name was not equal")
+            assert_equal(value,  pp.value, "value was not equal for %s" % value.inspect)
+        end
+    end
+end
+else
+    $stderr.puts "Install Rails for Rails and Caching tests"
+end
+
+# $Id: railsparameter.rb 2206 2007-02-17 01:52:59Z shadoi $

data/test/rails/railsresource.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppet'
+require 'puppet/rails'
+require 'puppettest'
+require 'puppettest/railstesting'
+require 'puppettest/resourcetesting'
+
+# Don't do any tests w/out this class
+if Puppet.features.rails?
+class TestRailsResource < Test::Unit::TestCase
+    include PuppetTest::RailsTesting
+    include PuppetTest::ResourceTesting
+
+    def setup
+        super
+        railsinit
+    end
+
+    def teardown
+        railsteardown
+        super
+    end
+
+    def mktest_resource
+        # We need a host for resources
+        host = Puppet::Rails::Host.new(:name => "myhost")
+
+        # Now build a resource
+        resource = host.resources.create(
+            :title => "/tmp/to_resource", 
+            :restype => "file",
+            :exported => true)
+
+        # Now add some params
+        params.each do |param, value|
+            pn = resource.param_names.find_or_create_by_name(param)
+            pv = pn.param_values.find_or_create_by_value(value)
+            resource.param_names << pn
+        end
+
+        host.save
+
+        return resource
+    end
+    
+    def params
+        {"owner" => "root", "mode" => "644"}
+    end
+
+    # Create a resource param from a rails parameter
+    def test_to_resource
+        resource = mktest_resource
+
+        # We need a scope
+        interp, scope, source = mkclassframing
+
+        # Find the new resource and include all it's parameters.
+        resource = Puppet::Rails::Resource.find_by_id(resource.id, :include => [ :param_names, :param_values ])
+
+        # Now, try to convert our resource to a real resource
+        res = nil
+        assert_nothing_raised do
+            res = resource.to_resource(scope)
+        end
+        assert_instance_of(Puppet::Parser::Resource, res)
+        assert_equal("root", res[:owner])
+        assert_equal("644", res[:mode])
+        assert_equal("/tmp/to_resource", res.title)
+        assert_equal(source, res.source)
+    end
+
+    def test_parameters
+        resource = mktest_resource
+
+        setparams = nil
+        assert_nothing_raised do
+            setparams = resource.parameters
+        end
+        assert_equal(params, setparams,
+            "Did not get the right answer from #parameters")
+    end
+
+    # Make sure we can retrieve individual parameters by name.
+    def test_parameter
+        resource = mktest_resource
+
+        params.each do |p,v|
+            assert_equal(v, resource.parameter(p), "%s is not correct" % p)
+        end
+    end
+end
+else
+    $stderr.puts "Install Rails for Rails and Caching tests"
+end
+
+# $Id: railsresource.rb 2206 2007-02-17 01:52:59Z shadoi $
+

data/test/ral/manager/attributes.rb

@@ -0,0 +1,296 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2007-02-05.
+#  Copyright (c) 2007. All rights reserved.
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+class TestTypeAttributes < Test::Unit::TestCase
+    include PuppetTest
+
+    def mktype
+        type = Puppet::Type.newtype(:faketype) {}
+        cleanup { Puppet::Type.rmtype(:faketype) }
+        type
+    end
+
+    def test_bracket_methods
+        type = mktype
+
+        # make a namevar
+        type.newparam(:name) {}
+
+        # make a property
+        type.newproperty(:property) {}
+
+        # and a param
+        type.newparam(:param)
+
+        inst = type.create(:name => "yay")
+
+        # Make sure we can set each of them, including a metaparam
+        [:param, :property, :noop].each do |param|
+            assert_nothing_raised("Failed to set symbol") do
+                inst[param] = true
+            end
+
+            assert_nothing_raised("Failed to set string") do
+                inst[param.to_s] = true
+            end
+
+            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]
+            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
+
+    def test_properties
+        type = mktype
+
+        # make a namevar
+        type.newparam(:name) {}
+
+        # make a couple of properties
+        props = [:one, :two, :three]
+        props.each do |prop|
+            type.newproperty(prop) {}
+        end
+
+        inst = type.create(:name => "yay")
+
+        inst[:one] = "boo"
+        one = inst.property(:one)
+        assert(one, "did not get obj for one")
+        assert_equal([one], inst.send(:properties), "got wrong properties")
+
+        inst[:three] = "rah"
+        three = inst.property(:three)
+        assert(three, "did not get obj for three")
+        assert_equal([one, three], inst.send(:properties), "got wrong properties")
+
+        inst[:two] = "whee"
+        two = inst.property(:two)
+        assert(two, "did not get obj for two")
+        assert_equal([one, two, three], inst.send(:properties), "got wrong properties")
+    end
+
+    def attr_check(type)
+        @num ||= 0
+        @num += 1
+        name = "name%s" % @num
+        inst = type.create(:name => name)
+        [:meta, :param, :prop].each do |name|
+            klass = type.attrclass(name)
+            assert(klass, "did not get class for %s" % name)
+            obj = yield inst, klass
+            assert_instance_of(klass, obj, "did not get object back")
+            assert_equal("value", inst.value(klass.name),
+                "value was not correct from value method")
+            assert_equal("value", obj.value, "value was not correct")
+        end
+    end
+
+    def test_newattr
+        type = mktype
+        type.newparam(:name) {}
+
+        # Make one of each param type
+        {
+            :meta => :newmetaparam, :param => :newparam, :prop => :newproperty
+        }.each do |name, method|
+            assert_nothing_raised("Could not make %s of type %s" % [name, method]) do
+                type.send(method, name) {}
+            end
+        end
+
+        # Now set each of them
+        attr_check(type) do |inst, klass|
+            inst.newattr(klass.name, :value => "value")
+        end
+
+        # Now try it passing the class in
+        attr_check(type) do |inst, klass|
+            inst.newattr(klass, :value => "value")
+        end
+
+        # Lastly, make sure we can create and then set, separately
+        attr_check(type) do |inst, klass|
+            obj = inst.newattr(klass.name)
+            assert_nothing_raised("Could not set value after creation") do
+                obj.value = "value"
+            end
+
+            # Make sure we can't create a new param object
+            assert_raise(Puppet::Error,
+                "Did not throw an error when replacing attr") do
+                    inst.newattr(klass.name, :value => "yay")
+            end
+            obj
+        end
+    end
+
+    def test_setdefaults
+        type = mktype
+        type.newparam(:name) {}
+        
+        # Make one of each param type
+        {
+            :meta2 => :newmetaparam, :param2 => :newparam, :prop2 => :newproperty
+        }.each do |name, method|
+            assert_nothing_raised("Could not make %s of type %s" % [name, method]) do
+                type.send(method, name) do
+                    defaultto "testing"
+                end
+            end
+        end
+
+        inst = type.create(:name => 'yay')
+        assert_nothing_raised do
+            inst.setdefaults
+        end
+
+        [:meta2, :param2, :prop2].each do |name|
+            assert(inst.value(name), "did not get a value for %s" % name)
+        end
+
+        # Try a default of "false"
+        type.newparam(:falsetest) do
+            defaultto false
+        end
+
+        assert_nothing_raised do
+            inst.setdefaults
+        end
+        assert_equal(false, inst[:falsetest], "false default was not set")
+    end
+
+    def test_alias_parameter
+        type = mktype
+        type.newparam(:name) {}
+        type.newparam(:one) {}
+        type.newproperty(:two) {}
+        
+        aliases = {
+            :three => :one,
+            :four => :two
+        }
+        aliases.each do |new, old|
+            assert_nothing_raised("Could not create alias parameter %s" % new) do
+                type.set_attr_alias new => old
+            end
+        end
+
+        aliases.each do |new, old|
+            assert_equal(old, type.attr_alias(new), "did not return alias info for %s" %
+                new)
+        end
+
+        assert_nil(type.attr_alias(:name), "got invalid alias info for name")
+
+        inst = type.create(:name => "my name")
+        assert(inst, "could not create instance")
+
+        aliases.each do |new, old|
+            val = "value %s" % new
+            assert_nothing_raised do
+                inst[new] = val
+            end
+
+            case old
+            when :one: # param
+                assert_equal(val, inst[new],
+                    "Incorrect alias value for %s in []" % new)
+            else
+                assert_equal(val, inst.should(new),
+                    "Incorrect alias value for %s in should" % new)
+            end
+            assert_equal(val, inst.value(new), "Incorrect alias value for %s" % new)
+            assert_equal(val, inst.value(old), "Incorrect orig value for %s" % old)
+        end
+    end
+
+    # Make sure eachattr is called in the parameter order.
+    def test_eachattr
+        type = mktype
+        name = type.newparam(:name) {}
+        one = type.newparam(:one) {}
+        two = type.newproperty(:two) {}
+        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|
+                result = [obj, name]
+                shouldary = should.shift
+                assert_equal(shouldary, result, "Did not get correct parameter")
+                break if should.empty?
+            end
+        end
+        assert(should.empty?, "Did not get all of the parameters.")
+    end
+
+    # Make sure newattr handles required features correctly.
+    def test_newattr_and_required_features
+        # Make a type with some features
+        type = mktype
+        type.feature :fone, "Something"
+        type.feature :ftwo, "Something else"
+        type.newparam(:name) {}
+
+        # Make three properties: one with no requirements, one with one, and one with two
+        none = type.newproperty(:none) {}
+        one = type.newproperty(:one, :required_features => :fone) {}
+        two = type.newproperty(:two, :required_features => [:fone, :ftwo]) {}
+
+        # Now make similar providers
+        nope = type.provide(:nope) {}
+        maybe = type.provide(:maybe) { has_features :fone}
+        yep = type.provide(:yep) { has_features :fone, :ftwo}
+
+        attrs = [:none, :one, :two]
+
+        # Now make sure that we get warnings and no properties in those cases where our providers do not support the features requested
+        [nope, maybe, yep].each_with_index do |prov, i|
+            resource = type.create(:provider => prov.name, :name => "test%s" % i, :none => "a", :one => "b", :two => "c")
+
+            case prov.name
+            when :nope:
+                yes = [:none]
+                no = [:one, :two]
+            when :maybe:
+                yes = [:none, :one]
+                no = [:two]
+            when :yep:
+                yes = [:none, :one, :two]
+                no = []
+            end
+            yes.each { |a| assert(resource.should(a), "Did not get value for %s in %s" % [a, prov.name]) }
+            no.each do |a|
+                assert_nil(resource.should(a), "Got value for unsupported %s in %s" % [a, prov.name])
+                if Puppet::Util::Log.sendlevel?(:info)
+                    assert(@logs.find { |l| l.message =~ /not managing attribute #{a}/ and l.level == :info }, "No warning about failed %s" % a)
+                end
+            end
+
+            @logs.clear
+        end
+    end
+end
+
+# $Id: attributes.rb 2414 2007-04-25 20:59:00Z luke $