Rewriting the tests for the package resource type, fixing #930.

10 files changed, 349 insertions, 297 deletions

diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb
index fae0587e1..31e009af5 100644
--- a/lib/puppet/parameter.rb
+++ b/lib/puppet/parameter.rb
@@ -289,9 +289,6 @@ class Puppet::Parameter
             raise Puppet::DevError, "No resource set for %s" % self.class.name
         end
 
-        # LAK 2007-05-09: Keep the @parent around for backward compatibility.
-        #@parent = @resource
-
         if ! self.metaparam? and klass = Puppet::Type.metaparamclass(self.class.name)
             setup_shadow(klass)
         end
@@ -378,36 +375,37 @@ class Puppet::Parameter
         vals = self.class.values
         regs = self.class.regexes
 
-        if regs.is_a? Hash # this is true on properties
-            regs = regs.keys
-        end
-        if vals.empty? and regs.empty?
-            # This parameter isn't using defined values to do its work.
-            return 
-        end
+        # this is true on properties
+        regs = regs.keys if regs.is_a?(Hash)
+
+        # This parameter isn't using defined values to do its work.
+        return if vals.empty? and regs.empty?
+
         newval = value
-        unless value.is_a?(Symbol)
-            newval = value.to_s.intern
-        end
+        newval = value.to_s.intern unless value.is_a?(Symbol)
 
-        unless vals.include?(newval) or
-            self.class.alias(newval) or
-            self.class.match?(value) # We match the string, not the symbol
-                str = "Invalid '%s' value %s. " %
-                    [self.class.name, value.inspect]
+        name = newval
 
-                unless vals.empty?
-                    str += "Valid values are %s. " % vals.join(", ")
-                end
+        unless vals.include?(newval) or name = self.class.alias(newval) or name = self.class.match?(value) # We match the string, not the symbol
+            str = "Invalid '%s' value %s. " %
+                [self.class.name, value.inspect]
 
-                unless regs.empty?
-                    str += "Valid values match %s." % regs.collect { |r|
-                        r.to_s
-                    }.join(", ")
-                end
+            unless vals.empty?
+                str += "Valid values are %s. " % vals.join(", ")
+            end
+
+            unless regs.empty?
+                str += "Valid values match %s." % regs.collect { |r|
+                    r.to_s
+                }.join(", ")
+            end
 
-                raise ArgumentError, str
+            raise ArgumentError, str
         end
+
+        # Now check for features.
+        name = name[0] if name.is_a?(Array) # This is true for regexes.
+        validate_features_per_value(name) if is_a?(Puppet::Property)
     end
 
     def remove
@@ -484,5 +482,12 @@ class Puppet::Parameter
     def to_s
         s = "Parameter(%s)" % self.name
     end
+
+    # Make sure that we've got all of the required features for a given value.
+    def validate_features_per_value(value)
+        if features = self.class.value_option(value, :required_features)
+            raise ArgumentError, "Provider must have features '%s' to set '%s' to '%s'" % [features, self.class.name, value] unless provider.satisfies?(features)
+        end
+    end
 end
 
diff --git a/lib/puppet/property.rb b/lib/puppet/property.rb
index 84620bfb6..f3d879ee2 100644
--- a/lib/puppet/property.rb
+++ b/lib/puppet/property.rb
@@ -67,9 +67,7 @@ class Property < Puppet::Parameter
 
     # Retrieve an option set when a value was defined.
     def self.value_option(name, option)
-        if option.is_a?(String)
-            option = symbolize(option)
-        end
+        option = option.to_sym
         if hash = @parameteroptions[name]
             hash[option]
         else
@@ -209,28 +207,28 @@ class Property < Puppet::Parameter
     # Figure out which event to return.
     def event(name, event = nil)
         if value_event = self.class.value_option(name, :event)
-            return value_event
-        else
-            if event and event.is_a?(Symbol)
-                if event == :nochange
-                    return nil
-                else
-                    return event
-                end
+            return value_event 
+        end
+
+        if event and event.is_a?(Symbol)
+            if event == :nochange
+                return nil
             else
-                if self.class.name == :ensure
-                    event = case self.should
-                    when :present: (@resource.class.name.to_s + "_created").intern
-                    when :absent: (@resource.class.name.to_s + "_removed").intern
-                    else
-                        (@resource.class.name.to_s + "_changed").intern
-                    end
-                else
-                    event = (@resource.class.name.to_s + "_changed").intern
-                end
+                return event
             end
         end
 
+        if self.class.name == :ensure
+            event = case self.should
+            when :present: (@resource.class.name.to_s + "_created").intern
+            when :absent: (@resource.class.name.to_s + "_removed").intern
+            else
+                (@resource.class.name.to_s + "_changed").intern
+            end
+        else
+            event = (@resource.class.name.to_s + "_changed").intern
+        end
+
         return event
     end
     
@@ -297,8 +295,7 @@ class Property < Puppet::Parameter
     # Send a log message.
     def log(msg)
         unless @resource[:loglevel]
-            self.devfail "Parent %s has no loglevel" %
-                @resource.name
+            self.devfail "Parent %s has no loglevel" % @resource.name
         end
         Puppet::Util::Log.create(
             :level => @resource[:loglevel],
@@ -338,10 +335,7 @@ class Property < Puppet::Parameter
     # provider.  In other words, if the property name is 'gid', we'll call
     # 'provider.gid' to retrieve the current value.
     def retrieve
-        is = provider.send(self.class.name)
-#        puts "IS is: " + is.to_s
-#       puts "and its an array!!!" if is.is_a? Array
-        return is
+        provider.send(self.class.name)
     end
 
     # Set our value, using the provider, an associated block, or both.
@@ -420,17 +414,9 @@ class Property < Puppet::Parameter
         end
     end
 
-    # The default 'sync' method only selects among a list of registered
-    # values.
+    # The default 'sync' method only selects among a list of registered # values.
     def sync
-#        if self.insync?
-#            self.info "already in sync"
-#            return nil
-#        end
-        unless self.class.values
-            self.devfail "No values defined for %s" %
-                self.class.name
-        end
+        self.devfail("No values defined for %s" % self.class.name) unless self.class.values
 
         if value = self.should
             set(value)
diff --git a/lib/puppet/provider.rb b/lib/puppet/provider.rb
index 26c1254e3..e73bb0cb6 100644
--- a/lib/puppet/provider.rb
+++ b/lib/puppet/provider.rb
@@ -64,6 +64,11 @@ class Puppet::Provider
         end
     end
 
+    # Is the provided feature a declared feature?
+    def self.declared_feature?(name)
+        defined?(@declared_features) and @declared_features.include?(name)
+    end
+
     # Does this implementation match all of the default requirements?  If
     # defaults are empty, we return false.
     def self.default?
diff --git a/lib/puppet/provider/package.rb b/lib/puppet/provider/package.rb
index 094bfb9f4..f7ff7e55a 100644
--- a/lib/puppet/provider/package.rb
+++ b/lib/puppet/provider/package.rb
@@ -27,4 +27,3 @@ class Puppet::Provider::Package < Puppet::Provider
         @property_hash.dup
     end
 end
-
diff --git a/lib/puppet/type/package.rb b/lib/puppet/type/package.rb
index e04f651a9..616362206 100644
--- a/lib/puppet/type/package.rb
+++ b/lib/puppet/type/package.rb
@@ -4,7 +4,6 @@
 # systems.
 
 module Puppet
-    class PackageError < Puppet::Error; end
     newtype(:package) do
         @doc = "Manage packages.  There is a basic dichotomy in package
             support right now:  Some package types (e.g., yum and apt) can
@@ -108,25 +107,15 @@ module Puppet
                 @lateststamp ||= (Time.now.to_i - 1000)
                 # Iterate across all of the should values, and see how they
                 # turn out.
+
                 @should.each { |should|
                     case should
                     when :present
-                        unless [:absent, :purged].include?(is)
-                            return true
-                        end
+                        return true unless [:absent, :purged].include?(is)
                     when :latest
                         # Short-circuit packages that are not present
-                        if is == :absent
-                            return false
-                        end
-
-                        unless provider.respond_to?(:latest)
-                            self.fail(
-                                "Package type %s does not support specifying 'latest'" %
-                                @resource[:provider]
-                            )
-                        end
-
+                        return false if is == :absent or is == :purged
+ 
                         # Don't run 'latest' more than about every 5 minutes
                         if @latest and ((Time.now.to_i - @lateststamp) / 60) < 5
                             #self.debug "Skipping latest check"
@@ -153,9 +142,9 @@ module Puppet
                                 [is.inspect, @resource.name, @latest.inspect]
                         end
                     when :absent
-                        if is == :absent or is == :purged
-                            return true
-                        end
+                        return true if is == :absent or is == :purged
+                    when :purged
+                        return true if is == :purged
                     when is
                         return true
                     end
@@ -312,46 +301,6 @@ module Puppet
             autos
         end
 
-        @listed = false
-
-        @allowedmethods = [:types]
-
-        class << self
-            attr_reader :listed
-        end
-
-        def self.clear
-            @listed = false
-            super
-        end
-
-        # Create a new package object from listed information
-        def self.installedpkg(hash)
-            unless hash.include? :provider
-                raise Puppet::DevError, "Got installed package with no provider"
-            end
-            # this is from code, so we don't have to do as much checking
-            name = hash[:name]
-            hash.delete(:name)
-
-            object = self[name] || self.create(:name => name)
-            object.setparams(hash)
-
-            return object
-        end
-
-        # Iterate across all packages of a given type and mark them absent
-        # if they are not in the list
-        def self.markabsent(pkgtype, packages)
-            # Mark any packages we didn't find as absent
-            self.each do |pkg|
-                next unless packages[:provider] == pkgtype
-                unless packages.include? pkg
-                    pkg.provider.send(:ensure, :absent)
-                end
-            end
-        end
-
         # This only exists for testing.
         def clear
             if obj = @parameters[:ensure]
@@ -365,10 +314,6 @@ module Puppet
             @provider.get(:ensure) != :absent
         end
 
-        # okay, there are two ways that a package could be created...
-        # either through the language, in which case the hash's values should
-        # be set in 'should', or through comparing against the system, in which
-        # case the hash's values should be set in 'is'
         def initialize(params)
             self.initvars
             provider = nil
diff --git a/lib/puppet/util/provider_features.rb b/lib/puppet/util/provider_features.rb
index d5f272420..3a9d4262d 100644
--- a/lib/puppet/util/provider_features.rb
+++ b/lib/puppet/util/provider_features.rb
@@ -55,9 +55,7 @@ module Puppet::Util::ProviderFeatures
     # required to determine if the feature is present.
     def feature(name, docs, hash = {})
         @features ||= {}
-        if @features.include?(name)
-            raise Puppet::DevError, "Feature %s is already defined" % name
-        end
+        raise(Puppet::DevError, "Feature %s is already defined" % name) if @features.include?(name)
         begin
             obj = ProviderFeature.new(name, docs, hash)
             @features[obj.name] = obj
@@ -133,7 +131,8 @@ module Puppet::Util::ProviderFeatures
                 }
             end
 
-            # Create a method that will list all functional features.
+            # Create a method that will determine if a provided list of
+            # features are satisfied by the curred provider.
             @feature_module.send(:define_method, :satisfies?) do |*needed|
                 ret = true
                 needed.flatten.each do |feature|
@@ -150,13 +149,7 @@ module Puppet::Util::ProviderFeatures
             @features.each do |name, feature|
                 method = name.to_s + "?"
                 @feature_module.send(:define_method, method) do
-                    if defined? @declared_features and @declared_features.include?(name)
-                        true
-                    elsif feature.available?(self)
-                        true
-                    else
-                        false
-                    end
+                    self.class.declared_feature?(name) or feature.available?(self)
                 end
             end
 
@@ -173,5 +166,12 @@ module Puppet::Util::ProviderFeatures
         end
         @feature_module
     end
+
+    # Return the actual provider feature instance.  Really only used for testing.
+    def provider_feature(name)
+        return nil unless defined?(@features)
+
+        @features[name]
+    end
 end
 
diff --git a/spec/integration/ral/types/package.rb b/spec/integration/ral/types/package.rb
new file mode 100755
index 000000000..20567629d
--- /dev/null
+++ b/spec/integration/ral/types/package.rb
@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/type/package'
+
+describe Puppet::Type::Package, "when choosing a default package provider" do
+    before do
+        # the default provider is cached.
+        Puppet::Type::Package.defaultprovider = nil
+    end
+
+    def provider_name(os)
+        {"Debian" => :apt, "Darwin" => :apple, "RedHat" => :up2date, "Fedora" => :yum, "FreeBSD" => :ports, "OpenBSD" => :openbsd, "Solaris" => :sun}[os]
+    end
+
+    it "should have a default provider" do
+        Puppet::Type::Package.defaultprovider.should_not be_nil
+    end
+
+    it "should choose the correct provider each platform" do
+        Puppet::Type::Package.defaultprovider.name.should == provider_name(Facter.value(:operatingsystem))
+    end
+end
diff --git a/spec/unit/ral/types/package.rb b/spec/unit/ral/types/package.rb
new file mode 100755
index 000000000..f037ef5c2
--- /dev/null
+++ b/spec/unit/ral/types/package.rb
@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/type/package'
+
+$platform = Facter["operatingsystem"].value
+
+describe Puppet::Type::Package do
+    it "should have an :installable feature that requires the :install method" do
+        Puppet::Type::Package.provider_feature(:installable).methods.should == [:install]
+    end
+
+    it "should have an :uninstallable feature that requires the :uninstall method" do
+        Puppet::Type::Package.provider_feature(:uninstallable).methods.should == [:uninstall]
+    end
+
+    it "should have an :upgradeable feature that requires :update and :latest methods" do
+        Puppet::Type::Package.provider_feature(:upgradeable).methods.should == [:update, :latest]
+    end
+
+    it "should have a :purgeable feature that requires the :purge latest method" do
+        Puppet::Type::Package.provider_feature(:purgeable).methods.should == [:purge]
+    end
+
+    it "should have a :versionable feature" do
+        Puppet::Type::Package.provider_feature(:purgeable).should_not be_nil
+    end
+
+    it "should default to being installed" do
+        pkg = Puppet::Type::Package.create(:name => "yay")
+        pkg.should(:ensure).should == :present
+    end
+
+    after { Puppet::Type::Package.clear }
+end
+
+describe Puppet::Type::Package, "when validating attributes" do
+    [:name, :source, :instance, :status, :adminfile, :responsefile, :configfiles, :category, :platform, :root, :vendor, :description, :allowcdrom].each do |param|
+        it "should have a #{param} parameter" do
+            Puppet::Type::Package.attrtype(param).should == :param
+        end
+    end
+
+    it "should have an ensure property" do
+        Puppet::Type::Package.attrtype(:ensure).should == :property
+    end
+end
+
+describe Puppet::Type::Package, "when validating attribute values" do
+    before do
+        @provider = stub 'provider', :class => Puppet::Type::Package.defaultprovider, :clear => nil
+        Puppet::Type::Package.defaultprovider.expects(:new).returns(@provider)
+    end
+
+    it "should support :present as a value to :ensure" do
+        Puppet::Type::Package.create(:name => "yay", :ensure => :present)
+    end
+
+    it "should alias :installed to :present as a value to :ensure" do
+        pkg = Puppet::Type::Package.create(:name => "yay", :ensure => :installed)
+        pkg.should(:ensure).should == :present
+    end
+
+    it "should support :absent as a value to :ensure" do
+        Puppet::Type::Package.create(:name => "yay", :ensure => :absent)
+    end
+
+    it "should support :purged as a value to :ensure if the provider has the :purgeable feature" do
+        @provider.expects(:satisfies?).with(:purgeable).returns(true)
+        Puppet::Type::Package.create(:name => "yay", :ensure => :purged)
+    end
+
+    it "should not support :purged as a value to :ensure if the provider does not have the :purgeable feature" do
+        @provider.expects(:satisfies?).with(:purgeable).returns(false)
+        proc { Puppet::Type::Package.create(:name => "yay", :ensure => :purged) }.should raise_error(Puppet::Error)
+    end
+
+    it "should support :latest as a value to :ensure if the provider has the :upgradeable feature" do
+        @provider.expects(:satisfies?).with(:upgradeable).returns(true)
+        Puppet::Type::Package.create(:name => "yay", :ensure => :latest)
+    end
+
+    it "should not support :latest as a value to :ensure if the provider does not have the :upgradeable feature" do
+        @provider.expects(:satisfies?).with(:upgradeable).returns(false)
+        proc { Puppet::Type::Package.create(:name => "yay", :ensure => :latest) }.should raise_error(Puppet::Error)
+    end
+
+    it "should support version numbers as a value to :ensure if the provider has the :versionable feature" do
+        @provider.expects(:satisfies?).with(:versionable).returns(true)
+        Puppet::Type::Package.create(:name => "yay", :ensure => "1.0")
+    end
+
+    it "should not support version numbers as a value to :ensure if the provider does not have the :versionable feature" do
+        @provider.expects(:satisfies?).with(:versionable).returns(false)
+        proc { Puppet::Type::Package.create(:name => "yay", :ensure => "1.0") }.should raise_error(Puppet::Error)
+    end
+
+    it "should only accept files and URLs as values to :source" do
+        proc { Puppet::Type::Package.create(:name => "yay", :source => "stuff") }.should raise_error(Puppet::Error)
+    end
+
+    after { Puppet::Type::Package.clear }
+end
+
+module PackageEvaluationTesting
+    def setup
+        @provider = stub 'provider', :class => Puppet::Type::Package.defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
+        Puppet::Type::Package.defaultprovider.stubs(:new).returns(@provider)
+        @package = Puppet::Type::Package.create(:name => "yay")
+
+        @configuration = Puppet::Node::Configuration.new
+        @configuration.add_resource(@package)
+    end
+
+    def setprops(properties)
+        @provider.stubs(:properties).returns(properties)
+    end
+
+    def teardown
+        @configuration.clear(true)
+        Puppet::Type::Package.clear
+    end
+end
+
+describe Puppet::Type::Package, "when it should be purged" do
+    include PackageEvaluationTesting
+
+    before { @package[:ensure] = :purged }
+
+    it "should do nothing if it is :purged" do
+        @provider.expects(:properties).returns(:ensure => :purged)
+        @configuration.apply
+    end
+
+    [:absent, :installed, :present, :latest].each do |state|
+        it "should purge if it is #{state.to_s}" do
+            @provider.stubs(:properties).returns(:ensure => state)
+            @provider.expects(:purge)
+            @configuration.apply
+        end
+    end
+end
+
+describe Puppet::Type::Package, "when it should be absent" do
+    include PackageEvaluationTesting
+
+    before { @package[:ensure] = :absent }
+
+    [:purged, :absent].each do |state|
+        it "should do nothing if it is #{state.to_s}" do
+            @provider.expects(:properties).returns(:ensure => state)
+            @configuration.apply
+        end
+    end
+
+    [:installed, :present, :latest].each do |state|
+        it "should uninstall if it is #{state.to_s}" do
+            @provider.stubs(:properties).returns(:ensure => state)
+            @provider.expects(:uninstall)
+            @configuration.apply
+        end
+    end
+end
+
+describe Puppet::Type::Package, "when it should be present" do
+    include PackageEvaluationTesting
+
+    before { @package[:ensure] = :present }
+
+    [:present, :latest, "1.0"].each do |state|
+        it "should do nothing if it is #{state.to_s}" do
+            @provider.expects(:properties).returns(:ensure => state)
+            @configuration.apply
+        end
+    end
+
+    [:purged, :absent].each do |state|
+        it "should install if it is #{state.to_s}" do
+            @provider.stubs(:properties).returns(:ensure => state)
+            @provider.expects(:install)
+            @configuration.apply
+        end
+    end
+end
+
+describe Puppet::Type::Package, "when it should be latest" do
+    include PackageEvaluationTesting
+
+    before { @package[:ensure] = :latest }
+
+    [:purged, :absent].each do |state|
+        it "should upgrade if it is #{state.to_s}" do
+            @provider.stubs(:properties).returns(:ensure => state)
+            @provider.expects(:update)
+            @configuration.apply
+        end
+    end
+
+    it "should upgrade if the current version is not equal to the latest version" do
+        @provider.stubs(:properties).returns(:ensure => "1.0")
+        @provider.stubs(:latest).returns("2.0")
+        @provider.expects(:update)
+        @configuration.apply
+    end
+
+    it "should do nothing if it is equal to the latest version" do
+        @provider.stubs(:properties).returns(:ensure => "1.0")
+        @provider.stubs(:latest).returns("1.0")
+        @provider.expects(:update).never
+        @configuration.apply
+    end
+
+    it "should do nothing if the provider returns :present as the latest version" do
+        @provider.stubs(:properties).returns(:ensure => :present)
+        @provider.stubs(:latest).returns("1.0")
+        @provider.expects(:update).never
+        @configuration.apply
+    end
+end
+
+describe Puppet::Type::Package, "when it should be a specific version" do
+    include PackageEvaluationTesting
+
+    before { @package[:ensure] = "1.0" }
+
+    [:purged, :absent].each do |state|
+        it "should install if it is #{state.to_s}" do
+            @provider.stubs(:properties).returns(:ensure => state)
+            @provider.expects(:install)
+            @configuration.apply
+        end
+    end
+
+    it "should do nothing if the current version is equal to the desired version" do
+        @provider.stubs(:properties).returns(:ensure => "1.0")
+        @provider.expects(:install).never
+        @configuration.apply
+    end
+
+    it "should install if the current version is not equal to the specified version" do
+        @provider.stubs(:properties).returns(:ensure => "2.0")
+        @provider.expects(:install)
+        @configuration.apply
+    end
+end
diff --git a/test/ral/providers/package.rb b/test/ral/providers/package.rb
index a602a4dab..2040d6633 100755
--- a/test/ral/providers/package.rb
+++ b/test/ral/providers/package.rb
@@ -149,7 +149,7 @@ class TestPackageProvider < Test::Unit::TestCase
         assert_absent(provider)
 
         if Process.uid != 0
-            $stderr.puts "Run as root for full package tests"
+            Puppet.info "Run as root for full package tests"
             return
         end
 
diff --git a/test/ral/types/package.rb b/test/ral/types/package.rb
deleted file mode 100755
index c8d7d6088..000000000
--- a/test/ral/types/package.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../lib/puppettest'
-
-require 'puppettest'
-require 'puppettest/support/utils'
-require 'facter'
-require 'mocha'
-
-$platform = Facter["operatingsystem"].value
-
-class TestPackages < Test::Unit::TestCase
-    include PuppetTest::Support::Utils
-    include PuppetTest::FileTesting
-    def setup
-        super
-        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 = @resource.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")
-
-        current_values = nil
-        assert_nothing_raised do
-            current_values = pkg.retrieve
-        end
-
-        assert_equal(:absent, current_values[pkg.property(: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.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
-
-    # Make sure we can prefetch and retrieve packages
-    def test_package_instances
-        providers = []
-        instances = nil
-        assert_nothing_raised("Could not get package instances") do
-            instances = @type.instances
-        end
-        instances.each do |resource|
-            # Just do one of each type
-            next if providers.include?(resource.provider.class)
-            providers << resource.provider.class
-
-            # We should have data on the resource
-            assert(resource.exists?, "Listed resource thinks it's absent")
-
-            # Now flush the resource and make sure it clears the property_hash
-            assert_nothing_raised("Could not flush package") do
-                resource.flush
-            end
-
-            assert_equal(:absent, resource.provider.get(:ensure), "Flushing did not empty property hash")
-
-            # And query anew
-            props = nil
-            assert_nothing_raised("Could not retrieve package again") do
-                props = resource.retrieve
-            end
-            provider_props = resource.provider.send(:instance_variable_get, "@property_hash")
-            props.each do |prop, value|
-                assert_equal(value, provider_props[prop.name], "Query did not return same result as the property_hash for %s" % prop.name)
-            end
-        end
-    end
-
-    # Make sure we can prefetch package information, rather than getting it one package at a time.
-    def test_prefetch
-        @type.providers_by_source.each do |provider|
-            # The yum provider can't be used if you're not root
-            next if provider.name == :yum && Process.euid != 0
-
-            # First get a list of packages
-            list = provider.instances
-
-            packages = {}
-            list.each do |package|
-                packages[package.name] = @type.create(:name => package.name, :ensure => :installed)
-                break if packages.length > 4
-            end
-
-            # Now prefetch using that list of packages
-            assert_nothing_raised("Could not prefetch with %s" % provider.name) do
-                provider.prefetch(packages)
-            end
-
-            # And make sure each package is marked as existing, without calling query
-            packages.each do |name, package|
-                assert(package.exists?, "Package of type %s not marked present" % provider.name)
-                package.provider.expects(:query).never
-            end
-        end
-    end
-
-    # #716
-    def test_purge_is_not_installed
-        package = @type.create(:ensure => :installed, :name => "whatever")
-
-        property = package.property(:ensure)
-        assert(! property.insync?(:purged), "Package in state 'purged' was considered in sync")
-    end
-end
-