puppet 0.18.4 → 0.22.4

data/test/ral/types/package.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'facter'
+
+$platform = Facter["operatingsystem"].value
+
+class TestPackages < Test::Unit::TestCase
+    include PuppetTest::FileTesting
+    def setup
+        super
+        #@list = Puppet.type(:package).getpkglist
+        Puppet.type(:package).clear
+        @type = Puppet::Type.type(:package)
+    end
+
+    # This is a bare-minimum test and *really* needs to do much more.
+    def test_package_actions
+        @type.provide :fake, :parent => PuppetTest::FakeProvider do
+            apimethods :ensure
+            def install
+                self.ensure = @model.should(:ensure)
+            end
+
+            def uninstall
+                self.ensure = :absent
+            end
+
+            def query
+                case self.ensure
+                when :absent, nil: nil
+                else
+                    {:ensure => self.ensure}
+                end
+            end
+        end
+
+        pkg = nil
+        assert_nothing_raised do
+            pkg = @type.create :name => "testing", :provider => :fake
+        end
+        assert(pkg, "did not create package")
+
+        assert_nothing_raised do
+            pkg.retrieve
+        end
+
+        assert_equal(:absent, pkg.is(:ensure), "package not considered missing")
+        assert_equal(:present, pkg.should(:ensure),
+            "package did not default to installed")
+
+        assert_events([:package_installed], pkg)
+
+        pkg[:ensure] = :absent
+        assert_events([:package_removed], pkg)
+    end
+
+    def test_packagedefaults
+        should = case Facter["operatingsystem"].value
+        when "Debian": :apt
+        when "Darwin": :apple
+        when "RedHat": :up2date
+        when "Fedora": :yum
+        when "FreeBSD": :ports
+        when "OpenBSD": :openbsd
+        when "Solaris": :sun
+        end
+
+        unless default = Puppet.type(:package).defaultprovider
+            $stderr.puts "no default provider for %s" %
+                Facter["operatingsystem"].value
+            return
+        end
+
+
+        if should
+            assert_equal(should, default.name,
+                "Incorrect default package format")
+        end
+    end
+end
+
+# $Id: package.rb 2170 2007-02-07 17:21:52Z luke $

data/test/ral/types/parameter.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+class TestParameter < Test::Unit::TestCase
+	include PuppetTest
+    
+    def newparam(name = :fakeparam)
+        assert_nothing_raised {
+            param = Class.new(Puppet::Parameter) do
+                @name = :fakeparam
+            end
+            param.initvars
+
+            return param
+        }
+    end
+
+    def newinst(param)
+        assert_nothing_raised {
+            return param.new(:parent => "yay")
+        }
+    end
+
+    # Test the basic newvalue stuff.
+    def test_newvalue
+        param = newparam()
+
+        # Try it with both symbols and strings.
+        assert_nothing_raised {
+            param.newvalues(:one, "two")
+        }
+
+        inst = newinst(param)
+
+        assert_nothing_raised {
+            inst.value = "one"
+        }
+
+        assert_equal(:one, inst.value)
+
+        assert_nothing_raised {
+            inst.value = :two
+        }
+        assert_equal(:two, inst.value)
+
+        assert_raise(ArgumentError) {
+            inst.value = :three
+        }
+        assert_equal(:two, inst.value)
+    end
+
+    # Test using regexes.
+    def test_regexvalues
+        param = newparam
+
+        assert_nothing_raised {
+            param.newvalues(/^\d+$/)
+        }
+        assert(param.match?("14"))
+        assert(param.match?(14))
+
+        inst = newinst(param)
+
+        assert_nothing_raised {
+            inst.value = 14
+        }
+
+        assert_nothing_raised {
+            inst.value = "14"
+        }
+
+        assert_raise(ArgumentError) {
+            inst.value = "a14"
+        }
+    end
+
+    # Test using both.  Equality should beat matching.
+    def test_regexesandnormals
+        param = newparam
+
+        assert_nothing_raised {
+            param.newvalues(:one, /^\w+$/)
+        }
+
+        inst = newinst(param)
+
+        assert_nothing_raised {
+            inst.value = "one"
+        }
+
+        assert_equal(:one, inst.value, "Value used regex instead of equality")
+
+        assert_nothing_raised {
+            inst.value = "two"
+        }
+        assert_equal("two", inst.value, "Matched value didn't take")
+    end
+
+    def test_shadowing
+        type = Puppet::Type.newtype(:faketype) { newparam(:name) {} }
+
+        cleanup { Puppet::Type.rmtype(:faketype) }
+
+        param = nil
+        assert_nothing_raised do
+            param = type.newproperty(:alias)
+        end
+
+        assert(param, "did not create param")
+
+        inst = type.create(:name => "test")
+
+        assert_nothing_raised("Could not create shadowed param") {
+            inst[:alias] = "foo"
+        }
+
+        # Get the parameter hash from the instance so we can check the shadow
+        params = inst.instance_variable_get("@parameters")
+        obj = params[:alias]
+        assert(obj, "did not get alias parameter")
+        assert(obj.shadow, "shadow was not created for alias param")
+
+        assert(obj.is_a?(Puppet::Type::Property),
+            "alias instance is not a property")
+        assert_instance_of(param, obj, "alias is an instance of the wrong class")
+
+        # Make sure the alias got created
+        assert(type["foo"], "Did not retrieve object by its alias")
+        
+        # Now try it during initialization
+        other = nil
+        assert_nothing_raised("Could not create instance with shadow") do
+            other = type.create(:name => "rah", :alias => "one")
+        end
+        params = other.instance_variable_get("@parameters")
+        obj = params[:alias]
+        assert(obj, "did not get alias parameter")
+        assert(obj.shadow, "shadow was not created for alias param")
+
+        assert_instance_of(param, obj, "alias is an instance of the wrong class")
+        assert(obj.is_a?(Puppet::Type::Property),
+            "alias instance is not a property")
+
+        # Now change the alias and make sure it works out well
+        assert_nothing_raised("Could not modify shadowed alias") do
+            other[:alias] = "two"
+        end
+
+        obj = params[:alias]
+        assert(obj, "did not get alias parameter")
+        assert_instance_of(param, obj, "alias is now an instance of the wrong class")
+        assert(obj.is_a?(Puppet::Type::Property),
+            "alias instance is now not a property")
+    end
+
+    # Make sure properties can correctly require features and behave appropriately when
+    # those features are missing.
+    def test_requires_features
+        param = newparam(:feature_tests)
+
+        assert_nothing_raised("could not add feature requirements to property") do
+            param.required_features = "testing"
+        end
+
+        assert_equal([:testing], param.required_features, "required features value was not arrayfied and interned")
+    end
+end
+
+# $Id: parameter.rb 2413 2007-04-25 20:04:59Z luke $

data/test/ral/types/port.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+#require 'facter'
+#
+#class TestPort < Test::Unit::TestCase
+#	include PuppetTest
+#
+#    def setup
+#        super
+#        @porttype = Puppet.type(:port)
+#
+#        @provider = @porttype.defaultprovider
+#
+#        # Make sure they aren't using something funky like netinfo
+#        unless @provider.name == :parsed
+#            @porttype.defaultprovider = @porttype.provider(:parsed)
+#        end
+#
+#        cleanup do @porttype.defaultprovider = nil end
+#
+#        if @provider.respond_to?(:default_target)
+#            oldpath = @provider.default_target
+#            cleanup do
+#                @provider.default_target = oldpath
+#            end
+#            @provider.default_target = tempfile()
+#        end
+#    end
+#
+#    def mkport
+#        port = nil
+#
+#        if defined? @pcount
+#            @pcount += 1
+#        else
+#            @pcount = 1
+#        end
+#        assert_nothing_raised {
+#            port = Puppet.type(:port).create(
+#                :name => "puppet%s" % @pcount,
+#                :number => "813%s" % @pcount,
+#                :protocols => "tcp",
+#                :description => "The port that Puppet runs on",
+#                :alias => "coolness%s" % @pcount
+#            )
+#        }
+#
+#        return port
+#    end
+#
+#    def test_list
+#        assert_nothing_raised {
+#            Puppet.type(:port).list
+#        }
+#
+#        count = 0
+#        @porttype.each do |h|
+#            count += 1
+#        end
+#
+#        assert_equal(0, count, "Found hosts in empty file somehow")
+#
+#        dns = @porttype["domain"]
+#        assert(dns, "Did not retrieve dns service")
+#    end
+#
+#    def test_simpleport
+#        host = nil
+#
+#        port = mkport
+#
+#        assert_apply(port)
+#        assert_nothing_raised {
+#            port.retrieve
+#        }
+#
+#        assert(port.provider.exists?, "Port did not get created")
+#    end
+#
+#    def test_moddingport
+#        port = nil
+#        port = mkport
+#
+#        assert_events([:port_created], port)
+#
+#        port.retrieve
+#
+#        port[:protocols] = %w{tcp udp}
+#
+#        assert_events([:port_changed], port)
+#    end
+#
+#    def test_multivalues
+#        port = mkport
+#        assert_raise(Puppet::Error) {
+#            port[:protocols] = "udp tcp"
+#        }
+#        assert_raise(Puppet::Error) {
+#            port[:alias] = "puppetmasterd yayness"
+#        }
+#    end
+#
+#    def test_removal
+#        port = mkport()
+#        assert_nothing_raised {
+#            port[:ensure] = :present
+#        }
+#        assert_events([:port_created], port)
+#        assert_events([], port)
+#
+#        assert(port.provider.exists?, "port was not created")
+#        assert_nothing_raised {
+#            port[:ensure] = :absent
+#        }
+#
+#        assert_events([:port_removed], port)
+#        assert(! port.provider.exists?, "port was not removed")
+#        assert_events([], port)
+#    end
+#
+#    def test_addingproperties
+#        port = mkport()
+#        assert_events([:port_created], port)
+#
+#        port.delete(:alias)
+#        assert(! port.property(:alias))
+#        assert_events([:port_changed], port)
+#
+#        assert_nothing_raised {
+#            port.retrieve
+#        }
+#
+#        assert_equal(:present, port.is(:ensure))
+#
+#        assert_equal(:absent, port.is(:alias))
+#
+#        port[:alias] = "yaytest"
+#        assert_events([:port_changed], port)
+#        port.retrieve
+#        assert(port.property(:alias).is == ["yaytest"])
+#    end
+#end
+
+# $Id: port.rb 2170 2007-02-07 17:21:52Z luke $

data/test/ral/types/property.rb

@@ -0,0 +1,343 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+class TestProperty < Test::Unit::TestCase
+	include PuppetTest
+
+    def newinst(property, parent = nil)
+        inst = nil
+        unless parent
+            parent = "fakeparent"
+            parent.meta_def(:pathbuilder) do [self.to_s] end
+        end
+        assert_nothing_raised {
+            return property.new(:parent => parent)
+        }
+    end
+    
+    def newproperty(name = :fakeproperty)
+        property = Class.new(Puppet::Property) do
+            @name = name
+        end
+        Object.const_set("FakeProperty", property)
+        property.initvars
+        cleanup do
+            Object.send(:remove_const, "FakeProperty")
+        end
+
+        return property
+    end
+
+    def newmodel(name)
+        # Create an object that responds to myproperty as an attr
+        provklass = Class.new { attr_accessor name
+            def pathbuilder
+                ["provklass"]
+            end
+        }
+        prov = provklass.new
+
+        klass = Class.new { attr_accessor :provider, :path
+            def pathbuilder
+                ["instklass"]
+            end
+        }
+        klassinst = klass.new
+        klassinst.path = "instpath"
+        klassinst.provider = prov
+
+        return prov, klassinst
+    end
+
+    # Make sure we correctly look up names.
+    def test_value_name
+        property = newproperty()
+
+        property.newvalue(:one)
+        property.newvalue(/\d+/)
+
+        name = nil
+        ["one", :one].each do |value|
+            assert_nothing_raised do
+                name = property.value_name(value)
+            end
+            assert_equal(:one, name)
+        end
+        ["42"].each do |value|
+            assert_nothing_raised do
+                name = property.value_name(value)
+            end
+            assert_equal(/\d+/, name)
+        end
+        ["two", :three].each do |value|
+            assert_nothing_raised do
+                name = property.value_name(value)
+            end
+            assert_nil(name)
+        end
+    end
+
+    # Test that we correctly look up options for values.
+    def test_value_option
+        property = newproperty()
+
+        options = {
+            :one => {:event => :yay, :call => :before},
+            /\d+/ => {:event => :fun, :call => :instead}
+        }
+        property.newvalue(:one, options[:one])
+        property.newvalue(/\d+/, options[/\d+/])
+
+        options.each do |name, opts|
+            opts.each do |param, value|
+                assert_equal(value, property.value_option(name, param))
+            end
+        end
+    end
+
+    def test_newvalue
+        property = newproperty()
+
+        # These are bogus because they don't define events. :/
+        assert_nothing_raised {
+            property.newvalue(:one) do
+                @is = 1
+            end
+        }
+
+        assert_nothing_raised {
+            property.newvalue("two") do
+                @is = 2
+            end
+        }
+
+        # Make sure we default to using the block instead
+        assert_equal(:instead, property.value_option(:one, :call),
+            ":call was not set to :instead when a block was provided")
+
+        inst = newinst(property)
+
+        assert_nothing_raised {
+            inst.should = "one"
+        }
+
+        assert_equal(:one, inst.should)
+        ret = nil
+        assert_nothing_raised { inst.set_one }
+        assert_equal(1, inst.is)
+
+        assert_nothing_raised {
+            inst.should = :two
+        }
+
+        assert_equal(:two, inst.should)
+        assert_nothing_raised { inst.set_two }
+        assert_equal(2, inst.is)
+    end
+
+    def test_newpropertyvaluewithregexes
+        property = newproperty()
+
+        assert_nothing_raised {
+            property.newvalue(/^\w+$/) do
+                @is = self.should.upcase
+                return :regex_matched
+            end
+        }
+
+        inst = newinst(property)
+
+        assert_nothing_raised {
+            inst.should = "yayness"
+        }
+
+        assert_equal("yayness", inst.should)
+
+        assert_nothing_raised {
+            inst.sync
+        }
+
+        assert_equal("yayness".upcase, inst.is)
+    end
+
+    def test_newvalue_event_option
+        property = newproperty()
+
+        assert_nothing_raised do
+            property.newvalue(:myvalue, :event => :fake_valued) do
+                @is = :valued
+            end
+            property.newvalue(:other, :event => "fake_other") do
+                @is = :valued
+            end
+        end
+        inst = newinst(property)
+
+        assert_nothing_raised {
+            inst.should = :myvalue
+        }
+
+        ret = nil
+        assert_nothing_raised {
+            ret = inst.sync
+        }
+
+        assert_equal(:fake_valued, ret,
+                     "Event did not get returned correctly")
+
+        assert_nothing_raised {
+            inst.should = :other
+        }
+
+        assert_nothing_raised {
+            ret = inst.sync
+        }
+
+        assert_equal(:fake_other, ret,
+                     "Event did not get returned correctly")
+    end
+
+    # We want to support values with no blocks, either regexes or strings.
+    # If there's no block provided, then we should call the provider mechanism
+    # like we would normally.
+    def test_newvalue_with_no_block
+        property = newproperty(:myproperty)
+
+        assert_nothing_raised {
+            property.newvalue(:value, :event => :matched_value)
+        }
+        assert_nothing_raised {
+            property.newvalue(/^\d+$/, :event => :matched_number)
+        }
+
+        assert_equal(:none, property.value_option(:value, :call),
+            ":call was not set to none when no block is provided")
+
+        prov, klassinst = newmodel(:myproperty)
+
+        inst = newinst(property, klassinst)
+
+        # Now make sure we can set the values, they get validated as normal,
+        # and they set the values on the parent rathe than trying to call
+        # a method
+        {:value => :matched_value, "27" => :matched_number}.each do |value, event|
+            assert_nothing_raised do
+                inst.should = value
+            end
+            ret = nil
+            assert_nothing_raised do
+                ret = inst.sync
+            end
+            assert_equal(event, ret, "Did not return correct event for %s" % value)
+            assert_equal(value, prov.myproperty, "%s was not set right" % value)
+        end
+
+        # And make sure we still fail validations
+        assert_raise(ArgumentError) do
+            inst.should = "invalid"
+        end
+    end
+
+    def test_tags
+        obj = "yay"
+        metaobj = class << obj; self; end
+
+        metaobj.send(:attr_accessor, :tags)
+
+        tags = [:some, :tags, :for, :testing]
+        obj.tags = tags
+
+        propertyklass = newproperty
+ 
+        inst = nil
+        assert_nothing_raised do
+            inst = propertyklass.new(:parent => obj)
+        end
+
+        assert_nothing_raised do
+            assert_equal(tags + [inst.name], inst.tags)
+        end
+    end
+
+    def test_failure
+        s = Struct.new(:line, :file, :path, :pathbuilder)
+        p = s.new(1, "yay", "rah", "struct")
+        myproperty = Class.new(Puppet::Property)
+        myproperty.initvars
+
+        myproperty.newvalue :mkfailure do
+            raise "It's all broken"
+        end
+        property = myproperty.new(:parent => p)
+
+        assert_raise(Puppet::Error) do
+            property.set(:mkfailure)
+        end
+    end
+
+    # Make sure 'set' behaves correctly WRT to call order.  This tests that the
+    # :call value is handled correctly in all cases.
+    def test_set
+        property = newproperty(:myproperty)
+
+        $setting = []
+
+        newval = proc do |name, call|
+            options = {}
+            if call
+                options[:call] = name
+                block = proc { $setting << name }
+            end
+            assert_nothing_raised("Could not create %s value" % name) {
+                if block
+                    property.newvalue(name, options, &block)
+                else
+                    property.newvalue(name, options)
+                end
+            }
+        end
+
+        newval.call(:none, false)
+
+        # Create a value with no block; it should default to :none
+        newval.call(:before, true)
+
+        # One with a block but after
+        newval.call(:after, true)
+
+        # One with an explicit instead
+        newval.call(:instead, true)
+
+        # And one with an implicit instead
+        assert_nothing_raised do
+            property.newvalue(:implicit) do
+                $setting << :implicit
+            end
+        end
+
+        # Now create a provider
+        prov, model = newmodel(:myproperty)
+        inst = newinst(property, model)
+
+        # Mark when we're called
+        prov.meta_def(:myproperty=) do |value| $setting << :provider end
+
+        # Now run through the list and make sure everything is correct
+        {:before => [:before, :provider],
+            :after => [:provider, :after],
+            :instead => [:instead],
+            :none => [:provider],
+            :implicit => [:implicit]
+        }.each do |name, result|
+            inst.set(name)
+
+            assert_equal(result, $setting, "%s was not handled right" % name)
+            $setting.clear
+        end
+    end
+end
+
+# $Id: property.rb 2170 2007-02-07 17:21:52Z luke $