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

#!/usr/bin/env ruby

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

require 'puppettest'
require 'etc'

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

    def setup
        super
        Puppet.info @method_name
    end

    # Load the testpackages hash.
    def self.load_test_packages
        require 'yaml'
        file = File.join(PuppetTest.datadir(), "providers", "package", "testpackages.yaml")
        raise "Could not find file #{file}" unless FileTest.exists?(file)
        array = YAML::load(File.read(file)).collect { |hash|
            # Stupid ruby 1.8.1.  YAML is sometimes broken such that
            # symbols end up being strings with the : in them.
            hash.each do |name, value|
                if name.is_a?(String) and name =~ /^:/
                    hash.delete(name)
                    name = name.sub(/^:/, '').intern
                    hash[name] = value
                end
                if value.is_a?(String) and value =~ /^:/
                    hash[name] = value.sub(/^:/, '').intern
                end
            end
        }

        array
    end

    def self.suitable_test_packages
        list = load_test_packages
        providers = {}
        Puppet::Type.type(:package).suitableprovider.each do |provider|
            providers[provider.name] = provider
        end
        facts = {}
        Facter.to_hash.each do |fact, value|
            facts[fact.to_s.downcase.intern] = value.to_s.downcase.intern
        end
        list.find_all { |hash| # First find the matching providers
            hash.include?(:provider) and providers.include?(hash[:provider])
        }.reject { |hash| # Then find matching fact sets
            facts.detect do |fact, value|
                # We're detecting unmatched facts, but we also want to
                # delete the facts so they don't show up later.
                if fval = hash[fact]
                    hash.delete(fact)
                    fval = [fval] unless fval.is_a?(Array)
                    fval = fval.collect { |v| v.downcase.intern }
                    ! fval.include?(value)
                end
            end
        }
    end

    def assert_absent(provider, msg = "package not absent")
        result = nil
        assert_nothing_raised("Could not query provider") do
            result = provider.query
        end
        if result.nil?
            assert_nil(result)
        elsif result.is_a?(Hash)
            assert (result[:ensure] == :absent or result[:ensure] == :purged), msg
        else
            raise "dunno how to handle #{result.inspect}"
        end
    end

    def assert_not_absent(provider, msg = "package not installed")
        result = nil
        assert_nothing_raised("Could not query provider") do
            result = provider.query
        end
        assert((result == :listed or result.is_a?(Hash)), "query did not return hash or :listed")
        if result == :listed
            assert(provider.resource.is(:ensure) != :absent, msg)
        else
            assert(result[:ensure] != :absent, msg)
        end
    end

    # Run a package through all of its paces.  FIXME This should use the
    # provider, not the package, duh.
    def run_package_installation_test(hash)
        # Turn the hash into a package
        if files = hash[:files]
            hash.delete(:files)
            if files.is_a?(Array)
                hash[:source] = files.shift
            else
                hash[:source] = files
                files = []
            end
        else
            files = []
        end

        if versions = hash[:versions]
            hash.delete(:versions)
        else
            versions = []
        end

        # Start out by just making sure it's installed
        if versions.empty?
            hash[:ensure] = :present
        else
            hash[:ensure] = versions.shift
        end

        if hash[:source]
            unless FileTest.exists?(hash[:source])
                $stderr.puts "Create a package at #{hash[:source]} for testing"
                return
            end
        end

        if cleancmd = hash[:cleanup]
            hash.delete(:cleanup)
        end

        pkg = nil
        assert_nothing_raised(
            "Could not turn #{hash.inspect} into a package"
        ) do
            pkg = Puppet::Type.newpackage(hash)
        end

        # Make any necessary modifications.
        modpkg(pkg)

        provider = pkg.provider

        assert(provider, "Could not retrieve provider")

        return if result = provider.query and ! [:absent, :purged].include?(result[:ensure])

        assert_absent(provider)

        if Process.uid != 0
            Puppet.info "Run as root for full package tests"
            return
        end

        cleanup do
            if pkg.provider.respond_to?(:uninstall)
                pkg.provider.flush
                if pkg.provider.properties[:ensure] != :absent
                    assert_nothing_raised("Could not clean up package") do
                        pkg.provider.uninstall
                    end
                end
            else
                system(cleancmd) if cleancmd
            end
        end

        # Now call 'latest' after the package is installed
        if provider.respond_to?(:latest)
            assert_nothing_raised("Could not call 'latest'") do
                provider.latest
            end
        end

        assert_nothing_raised("Could not install package") do
            provider.install
        end

        assert_not_absent(provider, "package did not install")

        # If there are any remaining files, then test upgrading from there
        unless files.empty?
            pkg[:source] = files.shift
            current = provider.properties
            assert_nothing_raised("Could not upgrade") do
                provider.update
            end
            provider.flush
            new = provider.properties
            assert(current != new, "package was not upgraded: #{current.inspect} did not change")
        end

        unless versions.empty?
            pkg[:ensure] = versions.shift
            current = provider.properties
            assert_nothing_raised("Could not upgrade") do
                provider.update
            end
            provider.flush
            new = provider.properties
            assert(current != new, "package was not upgraded: #{current.inspect} did not change")
        end

        # Now call 'latest' after the package is installed
        if provider.respond_to?(:latest)
            assert_nothing_raised("Could not call 'latest'") do
                provider.latest
            end
        end

        # Now remove the package
        if provider.respond_to?(:uninstall)
            assert_nothing_raised do
                provider.uninstall
            end

            assert_absent(provider)
        end
    end

    # Now create a separate test method for each package
    suitable_test_packages.each do |hash|
        mname = ["test", hash[:name].to_s, hash[:provider].to_s].join("_").intern

        if method_defined?(mname)
            warn "Already a test method defined for #{mname}"
        else
            define_method(mname) do
                run_package_installation_test(hash)
            end
        end
    end

    def test_dont_complain_if_theres_nothing_to_test
        assert("sometimes the above metaprogramming fails to find anything to test and the runner complains")
    end

    def modpkg(pkg)
        case pkg[:provider]
        when :sun
            pkg[:adminfile] = "/usr/local/pkg/admin_file"
        end
    end
end