puppet 0.25.5 → 2.6.0

data/test/ral/providers/mailalias/aliases.rb

@@ -6,50 +6,50 @@ require 'puppettest'
 require 'puppettest/fileparsing'
 
 class TestMailaliasAliasesProvider < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::FileParsing
-
-    def setup
-        super
-        @provider = Puppet::Type.type(:mailalias).provider(:aliases)
-
-        @oldfiletype = @provider.filetype
-
-        @alias = mkalias
+  include PuppetTest
+  include PuppetTest::FileParsing
+
+  def setup
+    super
+    @provider = Puppet::Type.type(:mailalias).provider(:aliases)
+
+    @oldfiletype = @provider.filetype
+
+    @alias = mkalias
+  end
+
+  def teardown
+    Puppet::Util::FileType.filetype(:ram).clear
+    @provider.filetype = @oldfiletype
+    @provider.clear
+    super
+  end
+
+  def mkalias(name = "me")
+    if defined?(@pcount)
+      @pcount += 1
+    else
+      @pcount = 1
     end
+    args = {
+      :name => name,
+      :recipient => %w{here there}
+    }
 
-    def teardown
-        Puppet::Util::FileType.filetype(:ram).clear
-        @provider.filetype = @oldfiletype
-        @provider.clear
-        super
-    end
+    fakeresource = fakeresource(:mailalias, args[:name])
 
-    def mkalias(name = "me")
-        if defined? @pcount
-            @pcount += 1
-        else
-            @pcount = 1
-        end
-        args = {
-            :name => name,
-            :recipient => %w{here there}
-        }
-
-        fakeresource = fakeresource(:mailalias, args[:name])
-
-        key = @provider.new(fakeresource)
-        args.each do |p,v|
-            key.send(p.to_s + "=", v)
-        end
-
-        return key
+    key = @provider.new(fakeresource)
+    args.each do |p,v|
+      key.send(p.to_s + "=", v)
     end
 
-    def test_data_parsing_and_generating
-        fakedata("data/types/mailalias").each { |file|
-            fakedataparse(file)
-        }
-    end
+    key
+  end
+
+  def test_data_parsing_and_generating
+    fakedata("data/types/mailalias").each { |file|
+      fakedataparse(file)
+    }
+  end
 end
 

data/test/ral/providers/nameservice.rb

@@ -7,26 +7,26 @@ require 'puppet/provider/nameservice'
 require 'facter'
 
 class TestNameServiceProvider < Test::Unit::TestCase
-    include PuppetTest::FileTesting
-
-    def test_option
-        klass = Class.new(Puppet::Provider::NameService)
-        klass.resource_type = 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
+  include PuppetTest::FileTesting
+
+  def test_option
+    klass = Class.new(Puppet::Provider::NameService)
+    klass.resource_type = 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
 

data/test/ral/providers/package.rb

@@ -6,247 +6,240 @@ require 'puppettest'
 require 'etc'
 
 class TestPackageProvider < Test::Unit::TestCase
-    include PuppetTest
-
-    def setup
-        super
-        Puppet.info @method_name
+  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
-
-    # 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.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 %s" % result.inspect
-        end
+    facts = {}
+    Facter.to_hash.each do |fact, value|
+      facts[fact.to_s.downcase.intern] = value.to_s.downcase.intern
     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
+    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
 
-    # 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
+  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 hash[:source]
-            unless FileTest.exists?(hash[:source])
-                $stderr.puts "Create a package at %s for testing" % hash[:source]
-                return
-            end
-        end
+    if versions = hash[:versions]
+      hash.delete(:versions)
+    else
+      versions = []
+    end
 
-        if cleancmd = hash[:cleanup]
-            hash.delete(:cleanup)
-        end
+    # Start out by just making sure it's installed
+    if versions.empty?
+      hash[:ensure] = :present
+    else
+      hash[:ensure] = versions.shift
+    end
 
-        pkg = nil
-        assert_nothing_raised(
-            "Could not turn %s into a package" % hash.inspect
-        ) do
-            pkg = Puppet::Type.newpackage(hash)
-        end
+    if hash[:source]
+      unless FileTest.exists?(hash[:source])
+        $stderr.puts "Create a package at #{hash[:source]} for testing"
+        return
+      end
+    end
 
-        # Make any necessary modifications.
-        modpkg(pkg)
+    if cleancmd = hash[:cleanup]
+      hash.delete(:cleanup)
+    end
 
-        provider = pkg.provider
+    pkg = nil
+    assert_nothing_raised(
+      "Could not turn #{hash.inspect} into a package"
+    ) do
+      pkg = Puppet::Type.newpackage(hash)
+    end
 
-        assert(provider, "Could not retrieve provider")
+    # Make any necessary modifications.
+    modpkg(pkg)
 
-        return if result = provider.query and ! [:absent, :purged].include?(result[:ensure])
+    provider = pkg.provider
 
-        assert_absent(provider)
+    assert(provider, "Could not retrieve provider")
 
-        if Process.uid != 0
-            Puppet.info "Run as root for full package tests"
-            return
-        end
+    return if result = provider.query and ! [:absent, :purged].include?(result[:ensure])
 
-        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
-                if cleancmd
-                    system(cleancmd)
-                end
-            end
-        end
+    assert_absent(provider)
 
-        # 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
+    if Process.uid != 0
+      Puppet.info "Run as root for full package tests"
+      return
+    end
 
-        assert_nothing_raised("Could not install package") do
-            provider.install
-        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
 
-        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: %s did not change" %
-                current.inspect)
-        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
 
-        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: %s did not change" %
-                current.inspect)
-        end
+    assert_nothing_raised("Could not install package") do
+      provider.install
+    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_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
 
-        # Now remove the package
-        if provider.respond_to?(:uninstall)
-            assert_nothing_raised do
-                provider.uninstall
-            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
 
-            assert_absent(provider)
-        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 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
+    # Now remove the package
+    if provider.respond_to?(:uninstall)
+      assert_nothing_raised do
+        provider.uninstall
+      end
 
-        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
+      assert_absent(provider)
     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
+
+  # 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 modpkg(pkg)
-        case pkg[:provider]
-        when :sun
-            pkg[:adminfile] = "/usr/local/pkg/admin_file"
-        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