path: root/test/ral/providers/provider.rb

#!/usr/bin/env ruby

require File.dirname(__FILE__) + '/../../lib/puppettest'

require 'puppettest'
require 'facter'

class TestProvider < Test::Unit::TestCase
    include PuppetTest

    def echo
        echo = Puppet::Util.binary("echo")

        raise "Could not find 'echo' binary; cannot complete test" unless echo

        echo
    end

    def newprovider
        # Create our provider
        provider = Class.new(Puppet::Provider) do
            @name = :fakeprovider
        end
        provider.initvars

        provider
    end

    def setup
        super
        @type = Puppet::Type.newtype(:provider_test) do
            newparam(:name) {}
            ensurable
        end
        cleanup { Puppet::Type.rmtype(:provider_test) }
    end

    def test_confine_defaults_to_suitable

        provider = newprovider
        assert(provider.suitable?, "Marked unsuitable with no confines")
    end

    def test_confine_results
        {
            {:true => true} => true,
            {:true => false} => false,
            {:false => false} => true,
            {:false => true} => false,
            {:operatingsystem => Facter.value(:operatingsystem)} => true,
            {:operatingsystem => :yayness} => false,
            {:nothing => :yayness} => false,
            {:exists => echo} => true,
            {:exists => "/this/file/does/not/exist"} => false,
        }.each do |hash, result|
            provider = newprovider

            # First test :true
            hash.each do |test, val|
                assert_nothing_raised do
                    provider.confine test => val
                end
            end

            assert_equal(result, provider.suitable?, "Failed for #{hash.inspect}")

            provider.initvars
        end
    end

    def test_multiple_confines_do_not_override
        provider = newprovider

        # Make sure multiple confines don't overwrite each other
        provider.confine :true => false
        assert(! provider.suitable?)
        provider.confine :true => true
        assert(! provider.suitable?)
    end

    def test_one_failed_confine_is_sufficient

        provider = newprovider

        # Make sure we test multiple of them, and that a single false wins
        provider.confine :true => true, :false => false
        assert(provider.suitable?)
        provider.confine :true => false
        assert(! provider.suitable?)
    end

    # #1197 - the binary should not be
    def test_command_checks_for_binaries_each_time
        provider = newprovider

        provider.commands :testing => "/no/such/path"

        provider.stubs(:binary).returns "/no/such/path"

        provider.command(:testing)
        assert_equal("/no/such/path", provider.command(:testing), "Did not return correct binary path")
    end

    def test_command
        {:echo => "echo", :echo_with_path => echo, :missing => "nosuchcommand", :missing_qualified => "/path/to/nosuchcommand"}.each do |name, command|
            provider = newprovider
            assert_nothing_raised("Could not define command #{name} with argument #{command} for provider") do
                provider.commands(name => command)
            end

            if name.to_s =~ /missing/
                assert_nil(provider.command(name), "Somehow got a response for missing commands")
                assert(! provider.suitable?, "Provider was considered suitable with missing command")
                next # skip, since we don't do any validity checking here.
            end

            assert_equal(echo, provider.command(name), "Did not get correct path for echo")
            assert(provider.suitable?, "Provider was not considered suitable with 'echo'")

            # Now make sure they both work
            inst = provider.new(nil)
            [provider, inst].each do |thing|
                assert_nothing_raised("Could not call #{command} on #{thing}") do
                    out = thing.send(name, "some", "text")
                    assert_equal("some text\n", out)
                end
            end

            assert(provider.suitable?, "Provider considered unsuitable")

            # Now add an invalid command
            assert_nothing_raised do
                provider.commands :fake => "nosuchcommanddefinitely"
            end
            assert(! provider.suitable?, "Provider considered suitable")

            assert_nil(provider.command(:fake), "Got a value for missing command")
            assert_raise(Puppet::Error) do
                provider.fake
            end

            Puppet[:trace] = false
            assert_raise(Puppet::DevError) do
                provider.command(:nosuchcmd)
            end

            # Lastly, verify that we can find our superclass commands
            newprov = Class.new(provider)
            newprov.initvars

            assert_equal(echo, newprov.command(name))
        end
    end

    def test_default?
        provider = newprovider

        assert(! provider.default?, "Was considered default with no settings")

        assert_nothing_raised do
            provider.defaultfor :operatingsystem => Facter.value(:operatingsystem)
        end

        assert(provider.default?, "Was not considered default")

        # Make sure any true value is sufficient.
        assert_nothing_raised do
            provider.defaultfor :operatingsystem => [
                :yayness, :rahness,
                Facter.value(:operatingsystem)
            ]
        end

        assert(provider.default?, "Was not considered default")

        # Now make sure that a random setting returns false.
        assert_nothing_raised do
            provider.defaultfor :operatingsystem => :yayness
        end

        assert(! provider.default?, "Was considered default")
    end

    # Make sure that failed commands get their output in the error.
    def test_outputonfailure
        provider = newprovider

        dir = tstdir()
        file = File.join(dir, "mycmd")
        sh = Puppet::Util.binary("sh")
        File.open(file, "w") { |f|
            f.puts %{#!#{sh}
            echo A Failure >&2
            exit 2
            }
        }
        File.chmod(0755, file)

        provider.commands :cmd => file

        inst = provider.new(nil)

        assert_raise(Puppet::ExecutionFailure) do
            inst.cmd "some", "arguments"
        end

        out = nil
        begin
            inst.cmd "some", "arguments"
        rescue Puppet::ExecutionFailure => detail
            out = detail.to_s
        end


            assert(
                out =~ /A Failure/,

                "Did not receive command output on failure")


                    assert(
                        out =~ /Execution of/,

                "Did not receive info wrapper on failure")
    end

    def test_mk_resource_methods
        prov = newprovider
        resourcetype = Struct.new(:validproperties, :parameters)
        m = resourcetype.new([:prop1, :prop2], [:param1, :param2])
        prov.resource_type = m

        assert_nothing_raised("could not call mk_resource_methods") do
            prov.mk_resource_methods
        end

        obj = prov.new(nil)

        %w{prop1 prop2 param1 param2}.each do |param|
            assert(prov.public_method_defined?(param), "no getter for #{param}")
            assert(prov.public_method_defined?(param + "="), "no setter for #{param}")


                assert_equal(
                    :absent, obj.send(param),

                    "%s did not default to :absent")
            val = "testing #{param}"
            assert_nothing_raised("Could not call setter for #{param}") do
                obj.send(param + "=", val)
            end

                assert_equal(
                    val, obj.send(param),

                    "did not get correct value for #{param}")
        end
    end

    # Make sure optional commands get looked up but don't affect suitability.
    def test_optional_commands
        type = Puppet::Type.newtype(:optional_commands) {}

        cleanup { Puppet::Type.rmtype(:optional_commands) }

        # Define a provider with mandatory commands
        required = type.provide(:required) {
            commands :missing => "/no/such/binary/definitely"
        }

        # And another with optional commands
        optional = type.provide(:optional) {
            optional_commands :missing => "/no/such/binary/definitely"
        }

        assert(! required.suitable?, "Provider with missing commands considered suitable")
        assert_nil(required.command(:missing), "Provider returned non-nil from missing command")

        assert(optional.suitable?, "Provider with optional commands considered unsuitable")
        assert_nil(optional.command(:missing), "Provider returned non-nil from missing command")

        assert_raise(Puppet::Error, "Provider did not fail when missing command was called") do
            optional.missing
        end
    end

    # Disabling, since I might not keep this interface
    def disabled_test_read_and_each
        # Create a new provider
        provider = @type.provide(:testing)

        assert_raise(Puppet::DevError, "Did not fail when :read was not overridden") do
            provider.read
        end

        children = [:one, :two]
        provider.meta_def(:read) do
            children
        end

        result = []
        assert_nothing_raised("could not call 'each' on provider class") do
            provider.each { |i| result << i }
        end

        assert_equal(children, result, "did not get correct list from each")

        assert_equal(children, provider.collect { |i| i }, "provider does not include enumerable")
    end

    def test_source
        base = @type.provide(:base)

        assert_equal(:base, base.source, "source did not default correctly")
        assert_equal(:base, base.source, "source did not default correctly")

        sub = @type.provide(:sub, :parent => :base)

        assert_equal(:sub, sub.source, "source did not default correctly for sub class")
        assert_equal(:sub, sub.source, "source did not default correctly for sub class")

        other = @type.provide(:other, :parent => :base, :source => :base)

        assert_equal(:base, other.source, "source did not override")
        assert_equal(:base, other.source, "source did not override")
    end

    # Make sure we can initialize with either a resource or a hash, or none at all.
    def test_initialize
        test = @type.provide(:test)

        inst = @type.new :name => "boo"
        prov = nil
        assert_nothing_raised("Could not init with a resource") do
            prov = test.new(inst)
        end
        assert_equal(prov.resource, inst, "did not set resource correctly")
        assert_equal(inst.name, prov.name, "did not get resource name")

        params = {:name => :one, :ensure => :present}
        assert_nothing_raised("Could not init with a hash") do
            prov = test.new(params)
        end
        assert_equal(params, prov.send(:instance_variable_get, "@property_hash"), "did not set resource correctly")
        assert_equal(:one, prov.name, "did not get name from hash")

        assert_nothing_raised("Could not init with no argument") do
            prov = test.new()
        end

        assert_raise(Puppet::DevError, "did not fail when no name is present") do
            prov.name
        end
    end
end

class TestProviderFeatures < Test::Unit::TestCase
    include PuppetTest

    def setup
        super
        @type = Puppet::Type.newtype(:feature_test) do
            newparam(:name) {}
            ensurable
        end
        cleanup { Puppet::Type.rmtype(:feature_test) }

        @features = {:numeric => [:one, :two], :alpha => [:a, :b]}

        @features.each do |name, methods|
            assert_nothing_raised("Could not define features") do
                @type.feature(name, "boo", :methods => methods)
            end
        end
    end

    # Give them the basic run-through.
    def test_method_features
        @providers = {:numbers => @features[:numeric], :letters => @features[:alpha]}
        @providers[:both] = @features[:numeric] + @features[:alpha]
        @providers[:mixed] = [:one, :b]
        @providers[:neither] = [:something, :else]

        @providers.each do |name, methods|
            assert_nothing_raised("Could not create provider #{name}") do
                @type.provide(name) do
                    methods.each do |name|
                        define_method(name) {}
                    end
                end
            end
        end

        resource = @type.new(:name => "foo")
        {:numbers => [:numeric], :letters => [:alpha], :both => [:numeric, :alpha], :mixed => [], :neither => []}.each do |name, should|
            should.sort! { |a,b| a.to_s <=> b.to_s }
            provider = @type.provider(name)
            assert(provider, "Could not find provider #{name}")
            assert_equal(should, provider.features, "Provider #{name} has incorrect features")

            inst = provider.new(resource)
            # Make sure the boolean methods work on both the provider and
            # instance.
            @features.keys.each do |feature|
                method = feature.to_s + "?"
                assert(inst.respond_to?(method), "No boolean instance method for #{name} on #{feature}")
                assert(provider.respond_to?(method), "No boolean class method for #{name} on #{feature}")

                if should.include?(feature)
                    assert(provider.feature?(feature), "class missing feature? #{feature}")
                    assert(inst.feature?(feature), "instance missing feature? #{feature}")
                    assert(provider.send(method), "class missing feature #{feature}")
                    assert(inst.send(method), "instance missing feature #{feature}")
                    assert(inst.satisfies?(feature), "instance.satisfy #{feature} returned false")
                    else
                        assert(! provider.feature?(feature), "class has feature? #{feature}")
                        assert(! inst.feature?(feature), "instance has feature? #{feature}")
                        assert(! provider.send(method), "class has feature #{feature}")
                        assert(! inst.send(method), "instance has feature #{feature}")
                        assert(! inst.satisfies?(feature), "instance.satisfy #{feature} returned true")
                    end
                end

            end

        Puppet[:trace] = true
        Puppet::Type.loadall
        Puppet::Type.eachtype do |type|
            assert(type.respond_to?(:feature), "No features method defined for #{type.name}")
        end
    end

    def test_has_feature
        # Define a new feature that has no methods
        @type.feature(:nomeths, "desc")

        # Define a provider with nothing
        provider = @type.provide(:nothing) {}


            assert(
                provider.respond_to?(:has_features),

            "Provider did not get 'has_features' method added")

                assert(
                    provider.respond_to?(:has_feature),

            "Provider did not get the 'has_feature' alias method")

        # One with the numeric methods and nothing else
        @type.provide(:numbers) do
            define_method(:one) {}
            define_method(:two) {}
        end

        # Another with the numbers and a declaration
        @type.provide(:both) do
            define_method(:one) {}
            define_method(:two) {}

            has_feature :alpha
        end

        # And just the declaration
        @type.provide(:letters) do
            has_feature :alpha
        end

        # And a provider that declares it has our methodless feature.
        @type.provide(:none) do
            has_feature :nomeths
        end

        should = {:nothing => [], :both => [:numeric, :alpha],
            :letters => [:alpha], :numbers => [:numeric],
            :none => [:nomeths]}

        should.each do |name, features|
            provider_class = @type.provider(name)
            provider = provider_class.new({})

            assert(provider, "did not get provider named #{name}")
            features.sort! { |a,b| a.to_s <=> b.to_s }
            assert_equal(features, provider.features, "Got incorrect feature list for provider instance #{name}")
            assert_equal(features, provider_class.features, "Got incorrect feature list for provider class #{name}")
            features.each do |feat|
                assert(provider.feature?(feat), "Provider instance #{name} did not have feature #{feat}")
                assert(provider_class.feature?(feat), "Provider class #{name} did not have feature #{feat}")
            end
        end
    end

    def test_supports_parameter?
        # Make some parameters for each setting
        @type.newparam(:neither) {}
        @type.newparam(:some, :required_features => :alpha)
        @type.newparam(:both, :required_features => [:alpha, :numeric])

        # and appropriate providers
        nope = @type.provide(:nope) {}
        maybe = @type.provide(:maybe) { has_feature(:alpha) }
        yep = @type.provide(:yep) { has_features(:alpha, :numeric) }

        # Now make sure our providers answer correctly.
        [nope, maybe, yep].each do |prov|
            assert(prov.respond_to?(:supports_parameter?), "#{prov.name} does not respond to :supports_parameter?")
            case prov.name
            when :nope
                supported = [:neither]
                un = [:some, :both]
            when :maybe
                supported = [:neither, :some]
                un = [:both]
            when :yep
                supported = [:neither, :some, :both]
                un = []
            end

            supported.each do |param|
                assert(prov.supports_parameter?(param), "#{param} was not supported by #{prov.name}")
            end
            un.each do |param|
                assert(! prov.supports_parameter?(param), "#{param} was incorrectly supported by #{prov.name}")
            end
        end
    end
end