diff --git a/spec/unit/provider/package/openbsd_spec.rb b/spec/unit/provider/package/openbsd_spec.rb
index 63ee2a7ff..712f9cfda 100755
--- a/spec/unit/provider/package/openbsd_spec.rb
+++ b/spec/unit/provider/package/openbsd_spec.rb
@@ -1,368 +1,369 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'stringio'
 
 provider_class = Puppet::Type.type(:package).provider(:openbsd)
 
 describe provider_class do
   let(:package) { Puppet::Type.type(:package).new(:name => 'bash', :provider => 'openbsd') }
   let(:provider) { provider_class.new(package) }
 
   def expect_read_from_pkgconf(lines)
     pkgconf = stub(:readlines => lines)
     Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(true)
     File.expects(:open).with('/etc/pkg.conf', 'rb').returns(pkgconf)
   end
 
   def expect_pkgadd_with_source(source)
     provider.expects(:pkgadd).with do |fullname|
       ENV.should_not be_key('PKG_PATH')
       fullname.should == [source]
     end
   end
 
   def expect_pkgadd_with_env_and_name(source, &block)
     ENV.should_not be_key('PKG_PATH')
 
     provider.expects(:pkgadd).with do |fullname|
       ENV.should be_key('PKG_PATH')
       ENV['PKG_PATH'].should == source
 
       fullname.should == [provider.resource[:name]]
     end
     provider.expects(:execpipe).with(['/bin/pkg_info', '-I', provider.resource[:name]]).yields('')
 
     yield
 
     ENV.should_not be_key('PKG_PATH')
   end
 
   describe 'provider features' do
     it { should be_installable }
-    it { should be_uninstallable }
     it { should be_install_options }
+    it { should be_uninstallable }
     it { should be_uninstall_options }
+    it { should be_upgradeable }
     it { should be_versionable }
   end
 
   before :each do
     # Stub some provider methods to avoid needing the actual software
     # installed, so we can test on whatever platform we want.
     provider_class.stubs(:command).with(:pkginfo).returns('/bin/pkg_info')
     provider_class.stubs(:command).with(:pkgadd).returns('/bin/pkg_add')
     provider_class.stubs(:command).with(:pkgdelete).returns('/bin/pkg_delete')
   end
 
   context "#instances" do
     it "should return nil if execution failed" do
       provider_class.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
       provider_class.instances.should be_nil
     end
 
     it "should return the empty set if no packages are listed" do
       provider_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(StringIO.new(''))
       provider_class.instances.should be_empty
     end
 
     it "should return all packages when invoked" do
       fixture = File.read(my_fixture('pkginfo.list'))
       provider_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(fixture)
       provider_class.instances.map(&:name).sort.should ==
         %w{bash bzip2 expat gettext libiconv lzo openvpn python vim wget}.sort
     end
 
     it "should return all flavors if set" do
       fixture = File.read(my_fixture('pkginfo_flavors.list'))
       provider_class.expects(:execpipe).with(%w{/bin/pkg_info -a}).yields(fixture)
       instances = provider_class.instances.map {|p| {:name => p.get(:name),
         :ensure => p.get(:ensure), :flavor => p.get(:flavor)}}
       instances.size.should == 2
-      instances[0].should == {:name => 'bash', :ensure => '3.1.17',  :flavor => 'static'}
+      instances[0].should == {:name => 'bash', :ensure => '3.1.17', :flavor => 'static'}
       instances[1].should == {:name => 'vim',  :ensure => '7.0.42', :flavor => 'no_x11'}
     end
   end
 
   context "#install" do
     it "should fail if the resource doesn't have a source" do
       Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(false)
 
       expect {
         provider.install
       }.to raise_error(Puppet::Error, /must specify a package source/)
     end
 
     it "should fail if /etc/pkg.conf exists, but is not readable" do
       Puppet::FileSystem.expects(:exist?).with('/etc/pkg.conf').returns(true)
       File.expects(:open).with('/etc/pkg.conf', 'rb').raises(Errno::EACCES)
 
       expect {
         provider.install
       }.to raise_error(Errno::EACCES, /Permission denied/)
     end
 
     it "should fail if /etc/pkg.conf exists, but there is no installpath" do
       expect_read_from_pkgconf([])
       expect {
         provider.install
       }.to raise_error(Puppet::Error, /No valid installpath found in \/etc\/pkg\.conf and no source was set/)
     end
 
     it "should install correctly when given a directory-unlike source" do
-      source = '/whatever.pkg'
+      source = '/whatever.tgz'
       provider.resource[:source] = source
       expect_pkgadd_with_source(source)
 
       provider.install
     end
 
     it "should install correctly when given a directory-like source" do
       source = '/whatever/'
       provider.resource[:source] = source
       expect_pkgadd_with_env_and_name(source) do
         provider.install
       end
     end
 
     it "should install correctly when given a CDROM installpath" do
       dir = '/mnt/cdrom/5.2/packages/amd64/'
       expect_read_from_pkgconf(["installpath = #{dir}"])
       expect_pkgadd_with_env_and_name(dir) do
         provider.install
       end
     end
 
     it "should install correctly when given a ftp mirror" do
       url = 'ftp://your.ftp.mirror/pub/OpenBSD/5.2/packages/amd64/'
       expect_read_from_pkgconf(["installpath = #{url}"])
       expect_pkgadd_with_env_and_name(url) do
         provider.install
       end
     end
 
     it "should set the resource's source parameter" do
       url = 'ftp://your.ftp.mirror/pub/OpenBSD/5.2/packages/amd64/'
       expect_read_from_pkgconf(["installpath = #{url}"])
       expect_pkgadd_with_env_and_name(url) do
         provider.install
       end
 
       provider.resource[:source].should == url
     end
 
     it "should strip leading whitespace in installpath" do
       dir = '/one/'
       lines = ["# Notice the extra spaces after the ='s\n",
                "installpath =   #{dir}\n",
                "# And notice how each line ends with a newline\n"]
 
       expect_read_from_pkgconf(lines)
       expect_pkgadd_with_env_and_name(dir) do
         provider.install
       end
     end
 
     it "should not require spaces around the equals" do
       dir = '/one/'
       lines = ["installpath=#{dir}"]
 
       expect_read_from_pkgconf(lines)
       expect_pkgadd_with_env_and_name(dir) do
         provider.install
       end
     end
 
     it "should be case-insensitive" do
       dir = '/one/'
       lines = ["INSTALLPATH = #{dir}"]
 
       expect_read_from_pkgconf(lines)
       expect_pkgadd_with_env_and_name(dir) do
         provider.install
       end
     end
 
     it "should ignore unknown keywords" do
       dir = '/one/'
       lines = ["foo = bar\n",
                "installpath = #{dir}\n"]
 
       expect_read_from_pkgconf(lines)
       expect_pkgadd_with_env_and_name(dir) do
         provider.install
       end
     end
 
     it "should preserve trailing spaces" do
       dir = '/one/   '
       lines = ["installpath = #{dir}"]
 
       expect_read_from_pkgconf(lines)
       expect_pkgadd_with_source(dir)
 
       provider.install
     end
 
     it "should append installpath" do
       urls = ["ftp://your.ftp.mirror/pub/OpenBSD/5.2/packages/amd64/",
               "http://another.ftp.mirror/pub/OpenBSD/5.2/packages/amd64/"]
       lines = ["installpath  = #{urls[0]}\n",
                "installpath += #{urls[1]}\n"]
 
       expect_read_from_pkgconf(lines)
       expect_pkgadd_with_env_and_name(urls.join(":")) do
         provider.install
       end
     end
 
     it "should handle append on first installpath" do
       url = "ftp://your.ftp.mirror/pub/OpenBSD/5.2/packages/amd64/"
       lines = ["installpath += #{url}\n"]
 
       expect_read_from_pkgconf(lines)
       expect_pkgadd_with_env_and_name(url) do
         provider.install
       end
     end
 
     %w{ installpath installpath= installpath+=}.each do |line|
       it "should reject '#{line}'" do
         expect_read_from_pkgconf([line])
         expect {
           provider.install
         }.to raise_error(Puppet::Error, /No valid installpath found in \/etc\/pkg\.conf and no source was set/)
       end
     end
 
     it 'should use install_options as Array' do
       provider.resource[:source] = '/tma1/'
       provider.resource[:install_options] = ['-r', '-z']
       provider.expects(:pkgadd).with(['-r', '-z', 'bash'])
       provider.install
     end
   end
 
   context "#latest"  do
     before do
       provider.resource[:source] = '/tmp/tcsh.tgz'
       provider.resource[:name] = 'tcsh'
       provider.stubs(:pkginfo).with('tcsh')
     end
 
     it "should return the ensure value if the package is already installed" do
       provider.stubs(:properties).returns({:ensure => '4.2.45'})
       provider.stubs(:pkginfo).with('-Q', 'tcsh')
       provider.latest.should == '4.2.45'
     end
 
     it "should recognize a new version" do
       pkginfo_query = 'tcsh-6.18.01p1'
       provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
       provider.latest.should == '6.18.01p1'
     end
 
     it "should recognize a newer version" do
       provider.stubs(:properties).returns({:ensure => '1.6.8'})
       pkginfo_query = 'tcsh-1.6.10'
       provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
       provider.latest.should == '1.6.10'
     end
 
     it "should recognize a package that is already the newest" do
       pkginfo_query = 'tcsh-6.18.01p0 (installed)'
       provider.stubs(:pkginfo).with('-Q', 'tcsh').returns(pkginfo_query)
       provider.latest.should == '6.18.01p0'
     end
   end
 
   context "#get_version" do
     it "should return nil if execution fails" do
       provider.expects(:execpipe).raises(Puppet::ExecutionFailure, 'wawawa')
       provider.get_version.should be_nil
     end
 
     it "should return the package version if in the output" do
       output = 'bash-3.1.17         GNU Bourne Again Shell'
       provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields(output)
       provider.get_version.should == '3.1.17'
     end
 
     it "should return the empty string if the package is not present" do
       provider.resource[:name] = 'zsh'
       provider.expects(:execpipe).with(%w{/bin/pkg_info -I zsh}).yields(StringIO.new(''))
       provider.get_version.should == ''
     end
   end
 
   context "#query" do
     it "should return the installed version if present" do
       fixture = File.read(my_fixture('pkginfo.detail'))
       provider.expects(:pkginfo).with('bash').returns(fixture)
       provider.query.should == { :ensure => '3.1.17' }
     end
 
     it "should return nothing if not present" do
       provider.resource[:name] = 'zsh'
       provider.expects(:pkginfo).with('zsh').returns('')
       provider.query.should be_nil
     end
   end
 
   context "#install_options" do
     it "should return nill by default" do
       provider.install_options.should be_nil
     end
 
     it "should return install_options when set" do
       provider.resource[:install_options] = ['-n']
       provider.resource[:install_options].should == ['-n']
     end
 
     it "should return multiple install_options when set" do
       provider.resource[:install_options] = ['-L', '/opt/puppet']
       provider.resource[:install_options].should == ['-L', '/opt/puppet']
     end
 
     it 'should return install_options when set as hash' do
       provider.resource[:install_options] = { '-Darch' => 'vax' }
       provider.install_options.should == ['-Darch=vax']
     end
   end
 
   context "#uninstall_options" do
     it "should return nill by default" do
       provider.uninstall_options.should be_nil
     end
 
     it "should return uninstall_options when set" do
       provider.resource[:uninstall_options] = ['-n']
       provider.resource[:uninstall_options].should == ['-n']
     end
 
     it "should return multiple uninstall_options when set" do
       provider.resource[:uninstall_options] = ['-q', '-c']
       provider.resource[:uninstall_options].should == ['-q', '-c']
     end
 
     it 'should return uninstall_options when set as hash' do
       provider.resource[:uninstall_options] = { '-Dbaddepend' => '1' }
       provider.uninstall_options.should == ['-Dbaddepend=1']
     end
   end
 
   context "#uninstall" do
     describe 'when uninstalling' do
       it 'should use erase to purge' do
         provider.expects(:pkgdelete).with('-c', '-q', 'bash')
         provider.purge
       end
     end
 
     describe 'with uninstall_options' do
       it 'should use uninstall_options as Array' do
         provider.resource[:uninstall_options] = ['-q', '-c']
         provider.expects(:pkgdelete).with(['-q', '-c'], 'bash')
         provider.uninstall
       end
     end
   end
 end