diff --git a/lib/puppet/provider/package/gem.rb b/lib/puppet/provider/package/gem.rb
index 2cd907b7f..331615f22 100755
--- a/lib/puppet/provider/package/gem.rb
+++ b/lib/puppet/provider/package/gem.rb
@@ -1,121 +1,121 @@
 require 'puppet/provider/package'
 require 'uri'
 
 # Ruby gems support.
 Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package do
   desc "Ruby Gem support.  If a URL is passed via `source`, then that URL is used as the
     remote gem repository; if a source is present but is not a valid URL, it will be
     interpreted as the path to a local gem file.  If source is not present at all,
     the gem will be installed from the default gem repositories."
 
   has_feature :versionable
 
   commands :gemcmd => "gem"
 
   def self.gemlist(options)
     gem_list_command = [command(:gemcmd), "list"]
 
     if options[:local]
       gem_list_command << "--local"
     else
       gem_list_command << "--remote"
     end
 
     if name = options[:justme]
       gem_list_command << name + "$"
     end
 
     begin
       list = execute(gem_list_command).lines.map {|set| gemsplit(set) }
     rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error, "Could not list gems: #{detail}"
     end
 
     if options[:justme]
       return list.shift
     else
       return list
     end
   end
 
   def self.gemsplit(desc)
     # `gem list` when output console has a line like:
     # *** LOCAL GEMS ***
     # but when it's not to the console that line
     # and all blank lines are stripped
     # so we don't need to check for them
 
     if desc =~ /^(\S+)\s+\((.+)\)/
       name = $1
       versions = $2.split(/,\s*/)
       {
         :name     => name,
         :ensure   => versions,
         :provider => :gem
       }
     else
       Puppet.warning "Could not match #{desc}"
       nil
     end
   end
 
   def self.instances(justme = false)
     gemlist(:local => true).collect do |hash|
       new(hash)
     end
   end
 
   def install(useversion = true)
     command = [command(:gemcmd), "install"]
     command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
     # Always include dependencies
     command << "--include-dependencies"
 
     if source = resource[:source]
       begin
         uri = URI.parse(source)
       rescue => detail
         fail "Invalid source '#{uri}': #{detail}"
       end
 
       case uri.scheme
       when nil
         # no URI scheme => interpret the source as a local file
         command << source
       when /file/i
         command << uri.path
       when 'puppet'
         # we don't support puppet:// URLs (yet)
         raise Puppet::Error.new("puppet:// URLs are not supported as gem sources")
       else
         # interpret it as a gem repository
         command << "--source" << "#{source}" << resource[:name]
       end
     else
       command << "--no-rdoc" << "--no-ri" << resource[:name]
     end
 
     output = execute(command)
     # Apparently some stupid gem versions don't exit non-0 on failure
     self.fail "Could not install: #{output.chomp}" if output.include?("ERROR")
   end
 
   def latest
     # This always gets the latest version available.
     hash = self.class.gemlist(:justme => resource[:name])
 
-    hash[:ensure]
+    hash[:ensure][0]
   end
 
   def query
     self.class.gemlist(:justme => resource[:name], :local => true)
   end
 
   def uninstall
     gemcmd "uninstall", "-x", "-a", resource[:name]
   end
 
   def update
     self.install(false)
   end
 end
diff --git a/lib/puppet/type/package.rb b/lib/puppet/type/package.rb
index bfd6e4247..c7d4316a7 100644
--- a/lib/puppet/type/package.rb
+++ b/lib/puppet/type/package.rb
@@ -1,353 +1,357 @@
 # Define the different packaging systems.  Each package system is implemented
 # in a module, which then gets used to individually extend each package object.
 # This allows packages to exist on the same machine using different packaging
 # systems.
 
 module Puppet
   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
       retrieve their own package files, while others (e.g., rpm and sun)
       cannot.  For those package formats that cannot retrieve their own files,
       you can use the `source` parameter to point to the correct file.
 
       Puppet will automatically guess the packaging format that you are
       using based on the platform you are on, but you can override it
       using the `provider` parameter; each provider defines what it
       requires in order to function, and you must meet those requirements
       to use a given provider.
 
       **Autorequires:** If Puppet is managing the files specified as a
       package's `adminfile`, `responsefile`, or `source`, the package
       resource will autorequire those files."
 
     feature :installable, "The provider can install packages.",
       :methods => [:install]
     feature :uninstallable, "The provider can uninstall packages.",
       :methods => [:uninstall]
     feature :upgradeable, "The provider can upgrade to the latest version of a
         package.  This feature is used by specifying `latest` as the
         desired value for the package.",
       :methods => [:update, :latest]
     feature :purgeable, "The provider can purge packages.  This generally means
         that all traces of the package are removed, including
         existing configuration files.  This feature is thus destructive
         and should be used with the utmost care.",
       :methods => [:purge]
     feature :versionable, "The provider is capable of interrogating the
         package database for installed version(s), and can select
         which out of a set of available versions of a package to
         install if asked."
     feature :holdable, "The provider is capable of placing packages on hold
         such that they are not automatically upgraded as a result of
         other package dependencies unless explicit action is taken by
         a user or another package. Held is considered a superset of
         installed.",
       :methods => [:hold]
     feature :install_options, "The provider accepts options to be
       passed to the installer command."
 
     ensurable do
       desc <<-EOT
         What state the package should be in. On packaging systems that can
         retrieve new packages on their own, you can choose which package to
         retrieve by specifying a version number or `latest` as the ensure
         value. On packaging systems that manage configuration files separately
         from "normal" system files, you can uninstall config files by
         specifying `purged` as the ensure value.
       EOT
 
       attr_accessor :latest
 
       newvalue(:present, :event => :package_installed) do
         provider.install
       end
 
       newvalue(:absent, :event => :package_removed) do
         provider.uninstall
       end
 
       newvalue(:purged, :event => :package_purged, :required_features => :purgeable) do
         provider.purge
       end
 
       newvalue(:held, :event => :package_held, :required_features => :holdable) do
         provider.hold
       end
 
       # Alias the 'present' value.
       aliasvalue(:installed, :present)
 
       newvalue(:latest, :required_features => :upgradeable) do
         # Because yum always exits with a 0 exit code, there's a retrieve
         # in the "install" method.  So, check the current state now,
         # to compare against later.
         current = self.retrieve
         begin
           provider.update
         rescue => detail
           self.fail "Could not update: #{detail}"
         end
 
         if current == :absent
           :package_installed
         else
           :package_changed
         end
       end
 
       newvalue(/./, :required_features => :versionable) do
         begin
           provider.install
         rescue => detail
           self.fail "Could not update: #{detail}"
         end
 
         if self.retrieve == :absent
           :package_installed
         else
           :package_changed
         end
       end
 
       defaultto :installed
 
       # Override the parent method, because we've got all kinds of
       # funky definitions of 'in sync'.
       def insync?(is)
         @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
             return true unless [:absent, :purged, :held].include?(is)
           when :latest
             # Short-circuit packages that are not present
             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"
             else
               begin
                 @latest = provider.latest
                 @lateststamp = Time.now.to_i
               rescue => detail
                 error = Puppet::Error.new("Could not get latest version: #{detail}")
                 error.set_backtrace(detail.backtrace)
                 raise error
               end
             end
 
-            case is
-            when @latest
-              return true
-            when :present
-              # This will only happen on retarded packaging systems
-              # that can't query versions.
-              return true
-            else
-              self.debug "#{@resource.name} #{is.inspect} is installed, latest is #{@latest.inspect}"
+            case
+              when is.is_a?(Array) && is.include?(@latest)
+                return true
+              when is == @latest
+                return true
+              when is == :present
+                # This will only happen on retarded packaging systems
+                # that can't query versions.
+                return true
+              else
+                self.debug "#{@resource.name} #{is.inspect} is installed, latest is #{@latest.inspect}"
             end
+
+
           when :absent
             return true if is == :absent or is == :purged
           when :purged
             return true if is == :purged
           # this handles version number matches and
           # supports providers that can have multiple versions installed
           when *Array(is)
             return true
           end
         }
 
         false
       end
 
       # This retrieves the current state. LAK: I think this method is unused.
       def retrieve
         provider.properties[:ensure]
       end
 
       # Provide a bit more information when logging upgrades.
       def should_to_s(newvalue = @should)
         if @latest
           @latest.to_s
         else
           super(newvalue)
         end
       end
     end
 
     newparam(:name) do
       desc "The package name.  This is the name that the packaging
       system uses internally, which is sometimes (especially on Solaris)
       a name that is basically useless to humans.  If you want to
       abstract package installation, then you can use aliases to provide
       a common name to packages:
 
           # In the 'openssl' class
           $ssl = $operatingsystem ? {
             solaris => SMCossl,
             default => openssl
           }
 
           # It is not an error to set an alias to the same value as the
           # object name.
           package { $ssl:
             ensure => installed,
             alias  => openssl
           }
 
           . etc. .
 
           $ssh = $operatingsystem ? {
             solaris => SMCossh,
             default => openssh
           }
 
           # Use the alias to specify a dependency, rather than
           # having another selector to figure it out again.
           package { $ssh:
             ensure  => installed,
             alias   => openssh,
             require => Package[openssl]
           }
 
       "
       isnamevar
     end
 
     newparam(:source) do
       desc "Where to find the actual package.  This must be a local file
         (or on a network file system) or a URL that your specific
         packaging type understands; Puppet will not retrieve files for you,
         although you can manage packages as `file` resources."
 
       validate do |value|
         provider.validate_source(value)
       end
     end
 
     newparam(:instance) do
       desc "A read-only parameter set by the package."
     end
 
     newparam(:status) do
       desc "A read-only parameter set by the package."
     end
 
     newparam(:type) do
       desc "Deprecated form of `provider`."
 
       munge do |value|
         warning "'type' is deprecated; use 'provider' instead"
         @resource[:provider] = value
 
         @resource[:provider]
       end
     end
 
     newparam(:adminfile) do
       desc "A file containing package defaults for installing packages.
         This is currently only used on Solaris.  The value will be
         validated according to system rules, which in the case of
         Solaris means that it should either be a fully qualified path
         or it should be in `/var/sadm/install/admin`."
     end
 
     newparam(:responsefile) do
       desc "A file containing any necessary answers to questions asked by
         the package.  This is currently used on Solaris and Debian.  The
         value will be validated according to system rules, but it should
         generally be a fully qualified path."
     end
 
     newparam(:configfiles) do
       desc "Whether configfiles should be kept or replaced.  Most packages
         types do not support this parameter. Defaults to `keep`."
 
       defaultto :keep
 
       newvalues(:keep, :replace)
     end
 
     newparam(:category) do
       desc "A read-only parameter set by the package."
     end
     newparam(:platform) do
       desc "A read-only parameter set by the package."
     end
     newparam(:root) do
       desc "A read-only parameter set by the package."
     end
     newparam(:vendor) do
       desc "A read-only parameter set by the package."
     end
     newparam(:description) do
       desc "A read-only parameter set by the package."
     end
 
     newparam(:allowcdrom) do
       desc "Tells apt to allow cdrom sources in the sources.list file.
         Normally apt will bail if you try this."
 
       newvalues(:true, :false)
     end
 
     newparam(:flavor) do
       desc "Newer versions of OpenBSD support 'flavors', which are
         further specifications for which type of package you want."
     end
 
     newparam(:install_options, :required_features => :install_options) do
       desc <<-EOT
         A hash of additional options to pass when installing a package. These
         options are package-specific, and should be documented by the software
         vendor. The most commonly implemented option is `INSTALLDIR`:
 
             package { 'mysql':
               ensure          => installed,
               provider        => 'msi',
               source          => 'N:/packages/mysql-5.5.16-winx64.msi',
               install_options => { 'INSTALLDIR' => 'C:\\mysql-5.5' },
             }
 
         Since these options are passed verbatim to `msiexec`, any file paths
         specified in `install_options` should use a backslash as the separator
         character rather than a forward slash. This is the **only** place in Puppet
         where backslash separators should be used. Note that backslashes in
         double-quoted strings _must_ be double-escaped and backslashes
         in single-quoted strings _may_ be double-escaped.
       EOT
     end
 
     autorequire(:file) do
       autos = []
       [:responsefile, :adminfile].each { |param|
         if val = self[param]
           autos << val
         end
       }
 
       if source = self[:source] and absolute_path?(source)
         autos << source
       end
       autos
     end
 
     # This only exists for testing.
     def clear
       if obj = @parameters[:ensure]
         obj.latest = nil
       end
     end
 
     # The 'query' method returns a hash of info if the package
     # exists and returns nil if it does not.
     def exists?
       @provider.get(:ensure) != :absent
     end
   end
 end
diff --git a/spec/unit/provider/package/gem_spec.rb b/spec/unit/provider/package/gem_spec.rb
index 7c3cbded0..516e57926 100755
--- a/spec/unit/provider/package/gem_spec.rb
+++ b/spec/unit/provider/package/gem_spec.rb
@@ -1,112 +1,127 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:package).provider(:gem)
 
 describe provider_class do
   let(:resource) do
     Puppet::Type.type(:package).new(
       :name     => 'myresource',
       :ensure   => :installed
     )
   end
 
   let(:provider) do
     provider = provider_class.new
     provider.resource = resource
     provider
   end
 
   describe "when installing" do
     it "should use the path to the gem" do
       provider_class.stubs(:command).with(:gemcmd).returns "/my/gem"
       provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
       provider.install
     end
 
     it "should specify that the gem is being installed" do
       provider.expects(:execute).with { |args| args[1] == "install" }.returns ""
       provider.install
     end
 
     it "should specify that dependencies should be included" do
       provider.expects(:execute).with { |args| args[2] == "--include-dependencies" }.returns ""
       provider.install
     end
 
     it "should specify that documentation should not be included" do
       provider.expects(:execute).with { |args| args[3] == "--no-rdoc" }.returns ""
       provider.install
     end
 
     it "should specify that RI should not be included" do
       provider.expects(:execute).with { |args| args[4] == "--no-ri" }.returns ""
       provider.install
     end
 
     it "should specify the package name" do
       provider.expects(:execute).with { |args| args[5] == "myresource" }.returns ""
       provider.install
     end
 
     describe "when a source is specified" do
       describe "as a normal file" do
         it "should use the file name instead of the gem name" do
           resource[:source] = "/my/file"
           provider.expects(:execute).with { |args| args[3] == "/my/file" }.returns ""
           provider.install
         end
       end
       describe "as a file url" do
         it "should use the file name instead of the gem name" do
           resource[:source] = "file:///my/file"
           provider.expects(:execute).with { |args| args[3] == "/my/file" }.returns ""
           provider.install
         end
       end
       describe "as a puppet url" do
         it "should fail" do
           resource[:source] = "puppet://my/file"
           lambda { provider.install }.should raise_error(Puppet::Error)
         end
       end
       describe "as a non-file and non-puppet url" do
         it "should treat the source as a gem repository" do
           resource[:source] = "http://host/my/file"
           provider.expects(:execute).with { |args| args[3..5] == ["--source", "http://host/my/file", "myresource"] }.returns ""
           provider.install
         end
       end
       describe "with an invalid uri" do
         it "should fail" do
           URI.expects(:parse).raises(ArgumentError)
           resource[:source] = "http:::::uppet:/:/my/file"
           lambda { provider.install }.should raise_error(Puppet::Error)
         end
       end
     end
   end
 
+  describe "#latest" do
+    it "should return a single value for 'latest'" do
+      #gemlist is used for retrieving both local and remote version numbers, and there are cases
+      # (particularly local) where it makes sense for it to return an array.  That doesn't make
+      # sense for '#latest', though.
+      provider.class.expects(:gemlist).with({ :justme => 'myresource'}).returns({
+          :name     => 'myresource',
+          :ensure   => ["3.0"],
+          :provider => :gem,
+          })
+      provider.latest.should == "3.0"
+    end
+  end
+
+
   describe "#instances" do
     before do
       provider_class.stubs(:command).with(:gemcmd).returns "/my/gem"
     end
 
     it "should return an empty array when no gems installed" do
       provider_class.expects(:execute).with(%w{/my/gem list --local}).returns("\n")
       provider_class.instances.should == []
     end
 
     it "should return ensure values as an array of installed versions" do
       provider_class.expects(:execute).with(%w{/my/gem list --local}).returns <<-HEREDOC.gsub(/        /, '')
         systemu (1.2.0)
         vagrant (0.8.7, 0.6.9)
       HEREDOC
 
       provider_class.instances.map {|p| p.properties}.should == [
         {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
         {:ensure => ["0.8.7", "0.6.9"], :provider => :gem, :name => 'vagrant'}
       ]
     end
   end
 end
diff --git a/spec/unit/type/package_spec.rb b/spec/unit/type/package_spec.rb
index 921af54a3..003d1f69a 100755
--- a/spec/unit/type/package_spec.rb
+++ b/spec/unit/type/package_spec.rb
@@ -1,276 +1,286 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Type.type(:package) do
   before do
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should have an :installable feature that requires the :install method" do
     Puppet::Type.type(:package).provider_feature(:installable).methods.should == [:install]
   end
 
   it "should have an :uninstallable feature that requires the :uninstall method" do
     Puppet::Type.type(:package).provider_feature(:uninstallable).methods.should == [:uninstall]
   end
 
   it "should have an :upgradeable feature that requires :update and :latest methods" do
     Puppet::Type.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.type(:package).provider_feature(:purgeable).methods.should == [:purge]
   end
 
   it "should have a :versionable feature" do
     Puppet::Type.type(:package).provider_feature(:versionable).should_not be_nil
   end
 
   it "should default to being installed" do
     pkg = Puppet::Type.type(:package).new(:name => "yay", :provider => :apt)
     pkg.should(:ensure).should == :present
   end
 
   describe "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.type(:package).attrtype(param).should == :param
       end
     end
 
     it "should have an ensure property" do
       Puppet::Type.type(:package).attrtype(:ensure).should == :property
     end
   end
 
   describe "when validating attribute values" do
     before do
       @provider = stub(
         'provider',
         :class           => Puppet::Type.type(:package).defaultprovider,
         :clear           => nil,
         :validate_source => nil
       )
       Puppet::Type.type(:package).defaultprovider.expects(:new).returns(@provider)
     end
 
     it "should support :present as a value to :ensure" do
       Puppet::Type.type(:package).new(:name => "yay", :ensure => :present)
     end
 
     it "should alias :installed to :present as a value to :ensure" do
       pkg = Puppet::Type.type(:package).new(:name => "yay", :ensure => :installed)
       pkg.should(:ensure).should == :present
     end
 
     it "should support :absent as a value to :ensure" do
       Puppet::Type.type(:package).new(: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.type(:package).new(: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.type(:package).new(: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.type(:package).new(: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.type(:package).new(: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.type(:package).new(: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.type(:package).new(:name => "yay", :ensure => "1.0") }.should raise_error(Puppet::Error)
     end
 
     it "should accept any string as an argument to :source" do
       proc { Puppet::Type.type(:package).new(:name => "yay", :source => "stuff") }.should_not raise_error(Puppet::Error)
     end
   end
 
   module PackageEvaluationTesting
     def setprops(properties)
       @provider.stubs(:properties).returns(properties)
     end
   end
 
   describe Puppet::Type.type(:package) do
     before :each do
       @provider = stub(
         'provider',
         :class           => Puppet::Type.type(:package).defaultprovider,
         :clear           => nil,
         :satisfies?      => true,
         :name            => :mock,
         :validate_source => nil
       )
       Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
       Puppet::Type.type(:package).defaultprovider.stubs(:instances).returns([])
       @package = Puppet::Type.type(:package).new(:name => "yay")
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource(@package)
     end
 
     describe Puppet::Type.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).at_least_once
         @catalog.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)
           @catalog.apply
         end
       end
     end
 
     describe Puppet::Type.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).at_least_once
           @catalog.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)
           @catalog.apply
         end
       end
     end
 
     describe Puppet::Type.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).at_least_once
           @catalog.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)
           @catalog.apply
         end
       end
     end
 
     describe Puppet::Type.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)
           @catalog.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)
         @catalog.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
         @catalog.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
         @catalog.apply
       end
     end
 
     describe Puppet::Type.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)
           @package.property(:ensure).insync?(state).should be_false
           @provider.expects(:install)
           @catalog.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")
         @package.property(:ensure).insync?('1.0').should be_true
         @provider.expects(:install).never
         @catalog.apply
       end
 
       it "should install if the current version is not equal to the specified version" do
         @provider.stubs(:properties).returns(:ensure => "2.0")
         @package.property(:ensure).insync?('2.0').should be_false
         @provider.expects(:install)
         @catalog.apply
       end
 
       describe "when current value is an array" do
         let(:installed_versions) { ["1.0", "2.0", "3.0"] }
 
         before (:each) do
           @provider.stubs(:properties).returns(:ensure => installed_versions)
         end
 
         it "should install if value not in the array" do
           @package[:ensure] = "1.5"
           @package.property(:ensure).insync?(installed_versions).should be_false
           @provider.expects(:install)
           @catalog.apply
         end
 
         it "should not install if value is in the array" do
           @package[:ensure] = "2.0"
           @package.property(:ensure).insync?(installed_versions).should be_true
           @provider.expects(:install).never
           @catalog.apply
         end
+
+        describe "when ensure is set to 'latest'" do
+          it "should not install if the value is in the array" do
+            @provider.expects(:latest).returns("3.0")
+            @package[:ensure] = "latest"
+            @package.property(:ensure).insync?(installed_versions).should be_true
+            @provider.expects(:install).never
+            @catalog.apply
+          end
+        end
       end
     end
   end
 end