puppet 0.18.4 → 0.22.4

data/test/ral/providers/nameservice.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppet/provider/nameservice'
+require 'facter'
+
+class TestNameServiceProvider < Test::Unit::TestCase
+    include PuppetTest::FileTesting
+
+    def test_option
+        klass = Class.new(Puppet::Provider::NameService)
+        klass.model = Puppet::Type.type(:user)
+
+        val = nil
+        assert_nothing_raised {
+            val = klass.option(:home, :flag)
+        }
+
+        assert_nil(val, "Got an option")
+
+        assert_nothing_raised {
+            klass.options :home, :flag => "-d"
+        }
+        assert_nothing_raised {
+            val = klass.option(:home, :flag)
+        }
+        assert_equal("-d", val, "Got incorrect option")
+    end
+end
+
+# $Id: nameservice.rb 2170 2007-02-07 17:21:52Z luke $

data/test/ral/providers/package.rb

@@ -0,0 +1,253 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'etc'
+
+class TestPackageProvider < Test::Unit::TestCase
+	include PuppetTest
+
+    # Load the testpackages hash.
+    def self.load_test_packages
+        require 'yaml'
+        file = File.join(PuppetTest.datadir(), "providers", "package", "testpackages.yaml")
+        unless FileTest.exists?(file)
+            raise "Could not find file %s" % file
+        end
+        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
+        }
+
+        return 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.downcase.intern] = value.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_equal(:absent, result[:ensure], msg)
+        else
+            raise "dunno how to handle %s" % 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.model.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 %s for testing" % hash[:source]
+                return
+            end
+        end
+        
+        if cleancmd = hash[:cleanup]
+            hash.delete(:cleanup)
+        end
+
+        pkg = nil
+        assert_nothing_raised(
+            "Could not turn %s into a package" % hash.inspect
+        ) do
+            pkg = Puppet::Type.newpackage(hash)
+        end
+
+        # Make any necessary modifications.
+        modpkg(pkg)
+
+        provider = pkg.provider
+
+        assert(provider, "Could not retrieve provider")
+
+        assert_absent(provider)
+
+        if Process.uid != 0
+            $stderr.puts "Run as root for full package tests"
+            return
+        end
+
+        cleanup do
+            if pkg.provider.respond_to?(:uninstall)
+                pkg[:ensure] = :absent
+                assert_apply(pkg)
+            else
+                if cleancmd
+                    system(cleancmd)
+                end
+            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.query
+            assert_nothing_raised("Could not upgrade") do
+                provider.update
+            end
+            new = provider.query
+            assert(current != new, "package was not upgraded: %s did not change" %
+                current.inspect)
+        end
+
+        unless versions.empty?
+            pkg[:ensure] = versions.shift
+            current = provider.query
+            assert_nothing_raised("Could not upgrade") do
+                provider.update
+            end
+            new = provider.query
+            assert(current != new, "package was not upgraded: %s did not change" %
+                current.inspect)
+        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 %s" % mname
+        else
+            define_method(mname) do
+                run_package_installation_test(hash)
+            end
+        end
+    end
+
+    def modpkg(pkg)
+        case pkg[:provider]
+        when :sun:
+            pkg[:adminfile] = "/usr/local/pkg/admin_file"
+        end
+    end
+
+    # Make sure providers throw an error when you tell them to install a
+    # non-existent package.
+    def test_no_such_package
+        Puppet::Type.type(:package).suitableprovider.each do |provider|
+            assert_raise(ArgumentError, Puppet::Error, Puppet::ExecutionFailure,
+                "Successfully installed nonexistent package with %s" % provider.name) {
+                pkg = Puppet::Type.newpackage :name => "nosuch%s" % provider.name.to_s,
+                    :provider => provider.name
+                provider = pkg.provider
+                provider.install
+            }
+        end
+    end
+
+    # Make sure all of the suitable providers on our platform can successfully
+    # list.
+    def test_listing
+        Puppet::Type.type(:package).suitableprovider.each do |provider|
+            result = nil
+            assert_nothing_raised("Could not list %s packages" % provider.name) do
+                result = provider.list
+            end
+            result.each do |pkg|
+                assert_instance_of(Puppet::Type.type(:package), pkg,
+                    "%s returned non-package" % provider.name)
+                assert_equal(provider.name, pkg.provider.class.name,
+                    "%s did not set provider correctly" % provider.name)
+            end
+        end
+    end
+end
+
+# $Id: package.rb 2170 2007-02-07 17:21:52Z luke $

data/test/ral/providers/package/apt.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../lib/puppettest'
+
+require 'mocha'
+
+class AptPackageProviderTest < PuppetTest::TestCase
+    confine "Apt package provider missing" =>
+        Puppet::Type.type(:package).provider(:apt).suitable?
+
+	def setup
+        super
+		@type = Puppet::Type.type(:package)
+	end
+	
+	def test_install
+		pkg = @type.create :name => 'faff',
+		                   :provider => :apt,
+		                   :ensure => :present,
+		                   :source => "/tmp/faff.deb"
+
+		pkg.provider.expects(
+		                 :dpkgquery
+					  ).with(
+							  '-W',
+							  '--showformat',
+							  '${Status} ${Package} ${Version}\n',
+							  'faff'
+					  ).returns(
+					        "deinstall ok config-files faff 1.2.3-1\n"
+					  )
+
+		pkg.provider.expects(
+		                 :aptget
+		           ).with(
+		                 '-q',
+		                 '-y',
+		                 '-o',
+		                 'DPkg::Options::=--force-confold',
+		                 :install,
+		                 'faff'
+					  ).returns(0)
+		
+		pkg.evaluate.each { |state| state.transaction = self; state.forward }
+	end
+	
+	def test_purge
+		pkg = @type.create :name => 'faff', :provider => :apt, :ensure => :purged
+
+		pkg.provider.expects(
+		                 :dpkgquery
+					  ).with(
+					        '-W',
+					        '--showformat',
+					        '${Status} ${Package} ${Version}\n',
+					        'faff'
+					  ).returns(
+					        "install ok installed faff 1.2.3-1\n"
+					  )
+		pkg.provider.expects(
+		                 :aptget
+					  ).with(
+					        '-y',
+					        '-q',
+					        'remove',
+					        '--purge',
+					        'faff'
+					  ).returns(0)
+		
+		pkg.evaluate.each { |state| state.transaction = self; state.forward }
+	end
+
+    def test_latest
+		pkg = @type.create :name => 'base-files', :provider => :apt
+
+        assert(pkg, "did not create pkg")
+        status = pkg.provider.query
+        assert(status, "base-files is not installed")
+        assert(status[:ensure] != :absent, "base-files is not installed")
+
+        latest = nil
+        assert_nothing_raised("Could not call latest") do
+            latest = pkg.provider.latest
+        end
+        assert(latest, "Could not get latest value from apt")
+    end
+end
+
+# $Id: apt.rb 2390 2007-04-06 15:49:38Z luke $

data/test/ral/providers/package/aptitude.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../lib/puppettest'
+
+require 'mocha'
+
+class AptitudePackageProviderTest < PuppetTest::TestCase
+    confine "Aptitude package provider missing" =>
+        Puppet::Type.type(:package).provider(:aptitude).suitable?
+
+	def setup
+        super
+		@type = Puppet::Type.type(:package)
+	end
+	
+	def test_install
+		pkg = @type.create :name => 'faff',
+		                   :provider => :aptitude,
+		                   :ensure => :present,
+		                   :source => "/tmp/faff.deb"
+
+		pkg.provider.expects(
+		                 :dpkgquery
+					  ).with(
+							  '-W',
+							  '--showformat',
+							  '${Status} ${Package} ${Version}\n',
+							  'faff'
+					  ).returns(
+					        "deinstall ok config-files faff 1.2.3-1\n"
+					  )
+
+		pkg.provider.expects(
+		                 :aptitude
+		           ).with(
+		                 '-y',
+		                 '-o',
+		                 'DPkg::Options::=--force-confold',
+		                 :install,
+		                 'faff'
+					  ).returns(0)
+		
+		pkg.evaluate.each { |state| state.transaction = self; state.forward }
+	end
+	
+	def test_purge
+		pkg = @type.create :name => 'faff', :provider => :aptitude, :ensure => :purged
+
+		pkg.provider.expects(
+		                 :dpkgquery
+					  ).with(
+					        '-W',
+					        '--showformat',
+					        '${Status} ${Package} ${Version}\n',
+					        'faff'
+					  ).returns(
+					        "install ok installed faff 1.2.3-1\n"
+					  )
+		pkg.provider.expects(
+		                 :aptitude
+					  ).with(
+					        '-y',
+					        'purge',
+					        'faff'
+					  ).returns(0)
+		
+		pkg.evaluate.each { |state| state.transaction = self; state.forward }
+	end
+end

data/test/ral/providers/package/aptrpm.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../lib/puppettest'
+
+require 'mocha'
+
+class AptrpmPackageProviderTest < PuppetTest::TestCase
+    confine "Apt package provider missing" =>
+        Puppet::Type.type(:package).provider(:aptrpm).suitable?
+
+    def setup
+        super
+        @type = Puppet::Type.type(:package)
+    end
+    
+    def test_install
+        pkg = @type.create :name => 'faff',
+                           :provider => :aptrpm,
+                           :ensure => :present,
+                           :source => "/tmp/faff.rpm"
+
+        pkg.provider.expects(
+                            :rpm
+                      ).with(
+                            '-q',
+                            'faff',
+                            '--nosignature',
+                            '--nodigest',
+                            '--qf',
+                            "%{NAME}-%{VERSION}-%{RELEASE} %{VERSION}-%{RELEASE}\n"
+                      ).raises(Puppet::ExecutionFailure, "couldn't find rpm")
+
+        pkg.provider.expects(
+                         :aptget
+                    ).with(
+                         '-q',
+                         '-y',
+                         "install",
+                         'faff'
+                    ).returns(0)
+        
+        pkg.evaluate.each { |state| state.transaction = self; state.forward }
+    end
+    
+    def test_uninstall
+        pkg = @type.create :name => 'faff', :provider => :aptrpm, :ensure => :absent
+
+        pkg.provider.expects(
+                         :rpm
+                    ).with(
+                        '-q',
+                        'faff',
+                        '--nosignature',
+                        '--nodigest',
+                        '--qf',
+                        "%{NAME}-%{VERSION}-%{RELEASE} %{VERSION}-%{RELEASE}\n"
+                    ).returns(
+                        "faff-1.2.3-1 1.2.3-1\n"
+                    )
+        pkg.provider.expects(
+                        :aptget
+                    ).with(
+                        '-y',
+                        '-q',
+                        'remove',
+                        'faff'
+                    ).returns(0)
+        
+        pkg.evaluate.each { |state| state.transaction = self; state.forward }
+    end
+
+    # LAK: I don't know where this test will ever return true..
+    def disabled_test_latest
+        pkg = @type.create :name => 'ssh', :provider => :aptrpm
+
+        assert(pkg, "did not create pkg")
+        status = pkg.provider.query
+        assert(status, "ssh is not installed")
+        assert(status[:ensure] != :absent, "ssh is not installed")
+
+        latest = nil
+        assert_nothing_raised("Could not call latest") do
+            latest = pkg.provider.latest
+        end
+        assert(latest, "Could not get latest value from apt")
+    end
+end
+
+# $Id: aptrpm.rb 2430 2007-04-30 15:19:23Z luke $