diff --git a/lib/puppet/provider/package/apt.rb b/lib/puppet/provider/package/apt.rb
index 7bbbcfe03..c43bb4dfc 100755
--- a/lib/puppet/provider/package/apt.rb
+++ b/lib/puppet/provider/package/apt.rb
@@ -1,117 +1,118 @@
 Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     # Provide sorting functionality
     include Puppet::Util::Package
 
     desc "Package management via ``apt-get``."
 
     has_feature :versionable
 
     commands :aptget => "/usr/bin/apt-get"
     commands :aptcache => "/usr/bin/apt-cache"
     commands :preseed => "/usr/bin/debconf-set-selections"
 
     defaultfor :operatingsystem => [:debian, :ubuntu]
 
     ENV['DEBIAN_FRONTEND'] = "noninteractive"
 
     # A derivative of DPKG; this is how most people actually manage
     # Debian boxes, and the only thing that differs is that it can
     # install packages from remote sites.
 
     def checkforcdrom
         unless defined? @@checkedforcdrom
             if FileTest.exists? "/etc/apt/sources.list"
                 if File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/
                     @@checkedforcdrom = true
                 else
                     @@checkedforcdrom = false
                 end
             else
                 # This is basically a pathalogical case, but we'll just
                 # ignore it
                 @@checkedforcdrom = false
             end
         end
 
         if @@checkedforcdrom and @resource[:allowcdrom] != :true
             raise Puppet::Error,
                 "/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure."
         end
     end
 
     # Install a package using 'apt-get'.  This function needs to support
     # installing a specific version.
     def install
         if @resource[:responsefile]
             self.run_preseed
         end
         should = @resource[:ensure]
 
         checkforcdrom()
         cmd = %w{-q -y}
 
         keep = ""
         if config = @resource[:configfiles]
             if config == :keep
                 cmd << "-o" << 'DPkg::Options::=--force-confold'
             else
                 cmd << "-o" << 'DPkg::Options::=--force-confnew'
             end
         end
 
         str = @resource[:name]
         case should
         when true, false, Symbol
             # pass
         else
-            # Add the package version
+            # Add the package version and --force-yes option
             str += "=%s" % should
+            cmd << "--force-yes"
         end
 
         cmd << :install << str
 
         aptget(*cmd)
     end
 
     # What's the latest package version available?
     def latest
         output = aptcache :policy,  @resource[:name]
 
         if output =~ /Candidate:\s+(\S+)\s/
             return $1
         else
             self.err "Could not find latest version"
             return nil
         end
     end
 
     #
     # preseeds answers to dpkg-set-selection from the "responsefile"
     #
     def run_preseed
         if response = @resource[:responsefile] and FileTest.exist?(response)
             self.info("Preseeding %s to debconf-set-selections" % response)
 
             preseed response
         else
             self.info "No responsefile specified or non existant, not preseeding anything"
         end
     end
 
     def uninstall
         if @resource[:responsefile]
             self.run_preseed
         end
         aptget "-y", "-q", :remove, @resource[:name]
     end
 
     def purge
         if @resource[:responsefile]
             self.run_preseed
         end
         aptget '-y', '-q', :remove, '--purge', @resource[:name]
         # workaround a "bug" in apt, that already removed packages are not purged
         super
     end
 end
 
diff --git a/spec/unit/provider/package/apt.rb b/spec/unit/provider/package/apt.rb
index 25d74bf90..861029838 100755
--- a/spec/unit/provider/package/apt.rb
+++ b/spec/unit/provider/package/apt.rb
@@ -1,138 +1,145 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 provider = Puppet::Type.type(:package).provider(:apt)
 
 describe provider do
     before do
         @resource = stub 'resource', :[] => "asdf"
         @provider = provider.new(@resource)
 
         @fakeresult = "install ok installed asdf 1.0\n"
     end
 
     it "should be versionable" do
         provider.should be_versionable
     end
 
     it "should use :install to update" do
         @provider.expects(:install)
         @provider.update
     end
 
     it "should use 'apt-get remove' to uninstall" do
         @provider.expects(:aptget).with("-y", "-q", :remove, "asdf")
 
         @provider.uninstall
     end
 
     it "should use 'apt-get purge' and 'dpkg purge' to purge" do
         @provider.expects(:aptget).with("-y", "-q", :remove, "--purge", "asdf")
         @provider.expects(:dpkg).with("--purge", "asdf")
 
         @provider.purge
     end
 
     it "should use 'apt-cache policy' to determine the latest version of a package" do
         @provider.expects(:aptcache).with(:policy, "asdf").returns "asdf:
 Installed: 1:1.0
 Candidate: 1:1.1
 Version table:
  1:1.0
     650 http://ftp.osuosl.org testing/main Packages
 *** 1:1.1
     100 /var/lib/dpkg/status"
 
         @provider.latest.should == "1:1.1"
     end
 
     it "should print and error and return nil if no policy is found" do
         @provider.expects(:aptcache).with(:policy, "asdf").returns "asdf:"
 
         @provider.expects(:err)
         @provider.latest.should be_nil
     end
 
     it "should be able to preseed" do
         @provider.should respond_to(:run_preseed)
     end
 
     it "should preseed with the provided responsefile when preseeding is called for" do
         @resource.expects(:[]).with(:responsefile).returns "/my/file"
         FileTest.expects(:exist?).with("/my/file").returns true
 
         @provider.expects(:info)
         @provider.expects(:preseed).with("/my/file")
 
         @provider.run_preseed
     end
 
     it "should not preseed if no responsefile is provided" do
         @resource.expects(:[]).with(:responsefile).returns nil
 
         @provider.expects(:info)
         @provider.expects(:preseed).never
 
         @provider.run_preseed
     end
 
     it "should fail if a cdrom is listed in the sources list and :allowcdrom is not specified"
 
     describe "when installing" do
         it "should preseed if a responsefile is provided" do
             @resource.expects(:[]).with(:responsefile).returns "/my/file"
             @provider.expects(:run_preseed)
 
             @provider.stubs(:aptget)
             @provider.install
         end
 
         it "should check for a cdrom" do
             @provider.expects(:checkforcdrom)
 
             @provider.stubs(:aptget)
             @provider.install
         end
 
         it "should use 'apt-get install' with the package name if no version is asked for" do
             @resource.expects(:[]).with(:ensure).returns :installed
             @provider.expects(:aptget).with { |*command| command[-1] == "asdf" and command[-2] == :install }
 
             @provider.install
         end
 
         it "should specify the package version if one is asked for" do
             @resource.expects(:[]).with(:ensure).returns "1.0"
             @provider.expects(:aptget).with { |*command| command[-1] == "asdf=1.0" }
 
             @provider.install
         end
 
+        it "should use --force-yes if a package version is specified" do
+            @resource.expects(:[]).with(:ensure).returns "1.0"
+            @provider.expects(:aptget).with { |*command| command.include?("--force-yes") }
+
+            @provider.install
+        end
+
         it "should do a quiet install" do
             @provider.expects(:aptget).with { |*command| command.include?("-q") }
 
             @provider.install
         end
 
         it "should default to 'yes' for all questions" do
             @provider.expects(:aptget).with { |*command| command.include?("-y") }
 
             @provider.install
         end
 
         it "should keep config files if asked" do
             @resource.expects(:[]).with(:configfiles).returns :keep
             @provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confold") }
 
             @provider.install
         end
 
         it "should replace config files if asked" do
             @resource.expects(:[]).with(:configfiles).returns :replace
             @provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confnew") }
 
             @provider.install
         end
     end
 end