puppet 3.8.7-x86-mingw32 → 4.0.0.rc1-x86-mingw32

data/spec/unit/provider/package/pkg_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 describe Puppet::Type.type(:package).provider(:pkg) do
   let (:resource) { Puppet::Resource.new(:package, 'dummy', :parameters => {:name => 'dummy', :ensure => :latest}) }
   let (:provider) { described_class.new(resource) }
+
   before :each do
     described_class.stubs(:command).with(:pkg).returns('/bin/pkg')
   end
@@ -11,7 +12,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
   def self.it_should_respond_to(*actions)
     actions.each do |action|
       it "should respond to :#{action}" do
-        provider.should respond_to(action)
+        expect(provider).to respond_to(action)
       end
     end
   end
@@ -19,154 +20,173 @@ describe Puppet::Type.type(:package).provider(:pkg) do
   it_should_respond_to :install, :uninstall, :update, :query, :latest
 
   it "should be versionable" do
-    described_class.should be_versionable
+    expect(described_class).to be_versionable
   end
 
   describe "#methods" do
     context ":pkg_state" do
       it "should raise error on unknown values" do
         expect {
-          described_class.pkg_state('extra').should
+          expect(described_class.pkg_state('extra')).to
         }.to raise_error(ArgumentError, /Unknown format/)
       end
+
       ['known', 'installed'].each do |k|
         it "should return known values" do
-          described_class.pkg_state(k).should == {:status => k}
+          expect(described_class.pkg_state(k)).to eq({:status => k})
         end
       end
     end
+
     context ":ifo_flag" do
       it "should raise error on unknown values" do
         expect {
-          described_class.ifo_flag('x--').should
+          expect(described_class.ifo_flag('x--')).to
         }.to raise_error(ArgumentError, /Unknown format/)
       end
+
       {'i--' => 'installed', '---'=> 'known'}.each do |k, v|
         it "should return known values" do
-          described_class.ifo_flag(k).should == {:status => v}
+          expect(described_class.ifo_flag(k)).to eq({:status => v})
         end
       end
     end
+
     context ":parse_line" do
       it "should raise error on unknown values" do
         expect {
-          described_class.parse_line('pkg (mypkg) 1.2.3.4 i-- zzz').should
+          expect(described_class.parse_line('pkg (mypkg) 1.2.3.4 i-- zzz')).to
         }.to raise_error(ArgumentError, /Unknown line format/)
       end
+
       {
-        'spkg       0.0.7  i--' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg},
-        'spkg (me)  0.0.7  i--' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg, :publisher => 'me'},
-        'spkg (me)  0.0.7  if-' => {:name => 'spkg', :ensure => 'held', :status => 'installed', :provider => :pkg, :publisher => 'me'},
-        'spkg       0.0.7  installed -----' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg},
-        'spkg (me)  0.0.7  installed -----' => {:name => 'spkg', :ensure => '0.0.7', :status => 'installed', :provider => :pkg, :publisher => 'me'},
+        'pkg://omnios/SUNWcs@0.5.11,5.11-0.151006:20130506T161045Z    i--' => {:name => 'SUNWcs', :ensure => '0.5.11,5.11-0.151006:20130506T161045Z', :status => 'installed', :provider => :pkg, :publisher => 'omnios'},
+        'pkg://omnios/incorporation/jeos/illumos-gate@11,5.11-0.151006:20130506T183443Z if-' => {:name => 'incorporation/jeos/illumos-gate', :ensure => 'held', :status => 'installed', :provider => :pkg, :publisher => 'omnios'},
+        'pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  -----' => {:name => 'SUNWcs', :ensure => '0.5.11,5.11-0.151.0.1:20101105T001108Z', :status => 'installed', :provider => :pkg, :publisher => 'solaris'},
        }.each do |k, v|
         it "[#{k}] should correctly parse" do
-          described_class.parse_line(k).should == v
+          expect(described_class.parse_line(k)).to eq(v)
         end
       end
     end
+
     context ":latest" do
       it "should work correctly for ensure latest on solaris 11 (UFOXI) when there are no further packages to install" do
-        described_class.expects(:pkg).with(:list,'-Hn','dummy').returns File.read(my_fixture('dummy_solaris11.installed'))
-        provider.latest.should == "1.0.6-0.175.0.0.0.2.537"
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.installed'))
+        expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
       end
+
       it "should work correctly for ensure latest on solaris 11 in the presence of a certificate expiration warning" do
-        described_class.expects(:pkg).with(:list,'-Hn','dummy').returns File.read(my_fixture('dummy_solaris11.certificate_warning'))
-        provider.latest.should == "1.0.6-0.175.0.0.0.2.537"
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.certificate_warning'))
+        expect(provider.latest).to eq("1.0.6-0.175.0.0.0.2.537")
       end
+
       it "should work correctly for ensure latest on solaris 11(known UFOXI)" do
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true}).returns ''
         $CHILD_STATUS.stubs(:exitstatus).returns 0
 
-        described_class.expects(:pkg).with(:list,'-Hn','dummy').returns File.read(my_fixture('dummy_solaris11.known'))
-        provider.latest.should == "1.0.6-0.175.0.0.0.2.537"
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.known'))
+        expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
       end
+
       it "should work correctly for ensure latest on solaris 11 (IFO)" do
-        described_class.expects(:pkg).with(:list,'-Hn','dummy').returns File.read(my_fixture('dummy_solaris11.ifo.installed'))
-        provider.latest.should == "1.0.6-0.175.0.0.0.2.537"
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.ifo.installed'))
+        expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
       end
+
       it "should work correctly for ensure latest on solaris 11(known IFO)" do
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true}).returns ''
         $CHILD_STATUS.stubs(:exitstatus).returns 0
 
-        described_class.expects(:pkg).with(:list,'-Hn','dummy').returns File.read(my_fixture('dummy_solaris11.ifo.known'))
-        provider.latest.should == "1.0.6-0.175.0.0.0.2.537"
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.ifo.known'))
+        expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
+      end
+
+      it "issues a warning when the certificate has expired" do
+        warning = "Certificate '/var/pkg/ssl/871b4ed0ade09926e6adf95f86bf17535f987684' for publisher 'solarisstudio', needed to access 'https://pkg.oracle.com/solarisstudio/release/', will expire in '29' days."
+        Puppet.expects(:warning).with("pkg warning: #{warning}")
+
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.certificate_warning'))
+        provider.latest
+      end
+
+      it "doesn't issue a warning when the certificate hasn't expired" do
+        Puppet.expects(:warning).with(/pkg warning/).never
+
+        described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.installed'))
+        provider.latest
       end
     end
+
     context ":instances" do
-      it "should correctly parse lines with preferred publisher" do
-        described_class.expects(:pkg).with(:list,'-H').returns File.read(my_fixture('simple'))
-        instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
-        instances.size.should == 2
-        instances[0].should == {:name => 'SUNWdummy', :ensure => "2.5.5-0.111"}
-        instances[1].should == {:name => 'dummy2', :ensure =>"9.3.6.1-0.111"}
-      end
-      it "should correctly parse lines with non preferred publisher" do
-        described_class.expects(:pkg).with(:list,'-H').returns File.read(my_fixture('publisher'))
-        instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
-        instances.size.should == 2
-        instances[0].should == {:name => 'SUNWdummy', :ensure => "8.8-0.111"}
-        instances[1].should == {:name => 'service/network/dummy', :ensure => "0.5.11-0.151.0.1"}
-      end
       it "should correctly parse lines on solaris 11" do
-        described_class.expects(:pkg).with(:list, '-H').returns File.read(my_fixture('solaris11'))
+        described_class.expects(:pkg).with(:list, '-Hv').returns File.read(my_fixture('solaris11'))
         described_class.expects(:warning).never
         instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure) }}
-        instances.size.should == 2
-        instances[0].should == {:name => 'dummy/dummy', :ensure => "3.0-0.175.0.0.0.2.537"}
-        instances[1].should == {:name => 'dummy/dummy2', :ensure => "1.8.1.2-0.175.0.0.0.2.537"}
+        expect(instances.size).to eq(2)
+        expect(instances[0]).to eq({:name => 'dummy/dummy', :ensure => '3.0,5.11-0.175.0.0.0.2.537:20131230T130000Z'})
+        expect(instances[1]).to eq({:name => 'dummy/dummy2', :ensure => '1.8.1.2-0.175.0.0.0.2.537:20131230T130000Z'})
       end
+
       it "should fail on incorrect lines" do
         fake_output = File.read(my_fixture('incomplete'))
-        described_class.expects(:pkg).with(:list,'-H').returns fake_output
+        described_class.expects(:pkg).with(:list,'-Hv').returns fake_output
         expect {
           described_class.instances
         }.to raise_error(ArgumentError, /Unknown line format pkg/)
       end
+
       it "should fail on unknown package status" do
-        described_class.expects(:pkg).with(:list,'-H').returns File.read(my_fixture('unknown_status'))
+        described_class.expects(:pkg).with(:list,'-Hv').returns File.read(my_fixture('unknown_status'))
         expect {
           described_class.instances
         }.to raise_error(ArgumentError, /Unknown format pkg/)
       end
     end
+
     context ":query" do
       context "on solaris 10" do
         it "should find the package" do
-          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns File.read(my_fixture('dummy_solaris10'))
+          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns File.read(my_fixture('dummy_solaris10'))
           $CHILD_STATUS.stubs(:exitstatus).returns 0
-          provider.query.should == {
-            :name     => 'dummy',
-            :ensure   => "2.5.5-0.111",
-            :status   => "installed",
-            :provider => :pkg,
-          }
+          expect(provider.query).to eq({
+            :name      => 'dummy',
+            :ensure    => '2.5.5,5.10-0.111:20131230T130000Z',
+            :publisher => 'solaris',
+            :status    => 'installed',
+            :provider  => :pkg,
+          })
         end
+
         it "should return :absent when the package is not found" do
-          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns ''
           $CHILD_STATUS.stubs(:exitstatus).returns 1
-          provider.query.should == {:ensure => :absent, :name => "dummy"}
+          expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
+
       context "on solaris 11" do
         it "should find the package" do
           $CHILD_STATUS.stubs(:exitstatus).returns 0
-          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns File.read(my_fixture('dummy_solaris11.installed'))
-          provider.query.should == {
-            :name     => 'dummy',
-            :status   => 'installed',
-            :ensure   => "1.0.6-0.175.0.0.0.2.537",
-            :provider => :pkg
-          }
+          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns File.read(my_fixture('dummy_solaris11.installed'))
+          expect(provider.query).to eq({
+            :name      => 'dummy',
+            :status    => 'installed',
+            :ensure    => '1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z',
+            :publisher => 'solaris',
+            :provider  => :pkg,
+          })
         end
+
         it "should return :absent when the package is not found" do
-          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns ''
           $CHILD_STATUS.stubs(:exitstatus).returns 1
-          provider.query.should == {:ensure => :absent, :name => "dummy"}
+          expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
+
       it "should return fail when the packageline cannot be parsed" do
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns(File.read(my_fixture('incomplete')))
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns(File.read(my_fixture('incomplete')))
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         expect {
           provider.query
@@ -176,6 +196,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
     context ":install" do
       it "should accept all licenses" do
+        provider.expects(:query).with().returns({:ensure => :absent})
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy'], {:failonfail => false, :combine => true}).returns ''
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true}).returns ''
         $CHILD_STATUS.stubs(:exitstatus).returns 0
@@ -184,37 +205,41 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
       it "should install specific version(1)" do
         # Should install also check if the version installed is the same version we are asked to install? or should we rely on puppet for that?
-        resource[:ensure] = '0.0.7'
+        resource[:ensure] = '0.0.7,5.11-0.151006:20131230T130000Z'
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns 'dummy       0.0.6  installed -----'
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns 'pkg://foo/dummy@0.0.6,5.11-0.151006:20131230T130000Z  installed -----'
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '--accept', 'dummy@0.0.7,5.11-0.151006:20131230T130000Z'], {:failonfail => false, :combine => true}).returns ''
         provider.install
       end
+
       it "should install specific version(2)" do
         resource[:ensure] = '0.0.8'
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-H', 'dummy'], {:failonfail => false, :combine => true}).returns 'dummy       0.0.7  installed -----'
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy@0.0.8'], {:failonfail => false, :combine => true}).returns ''
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns 'pkg://foo/dummy@0.0.7,5.11-0.151006:20131230T130000Z  installed -----'
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '--accept', 'dummy@0.0.8'], {:failonfail => false, :combine => true}).returns ''
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.install
       end
-      it "should install specific version(3)" do
+
+      it "should downgrade to specific version" do
         resource[:ensure] = '0.0.7'
-        provider.expects(:query).with().returns({:ensure => '0.0.8'})
-        provider.expects(:uninstall).with()
+        provider.expects(:query).with().returns({:ensure => '0.0.8,5.11-0.151106:20131230T130000Z'})
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '--accept', 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
         provider.install
       end
+
       it "should install any if version is not specified" do
         resource[:ensure] = :present
+        provider.expects(:query).with().returns({:ensure => :absent})
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy'], {:failonfail => false, :combine => true}).returns ''
         Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.install
       end
+
       it "should install if no version was previously installed, and a specific version was requested" do
         resource[:ensure] = '0.0.7'
         provider.expects(:query).with().returns({:ensure => :absent})
@@ -224,6 +249,52 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         provider.install
       end
 
+      it "installs the latest matching version when given implicit version, and none are installed" do
+        resource[:ensure] = '1.0-0.151006'
+        is = :absent
+        provider.expects(:query).with().returns({:ensure => is})
+        described_class.expects(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').returns File.read(my_fixture('dummy_implicit_version'))
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+        provider.expects(:unhold).with()
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '--accept', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        provider.insync?(is)
+        provider.install
+      end
+
+      it "updates to the latest matching version when given implicit version" do
+        resource[:ensure] = '1.0-0.151006'
+        is = '1.0,5.11-0.151006:20140219T191204Z'
+        provider.expects(:query).with().returns({:ensure => is})
+        described_class.expects(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').returns File.read(my_fixture('dummy_implicit_version'))
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+        provider.expects(:unhold).with()
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '--accept', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        provider.insync?(is)
+        provider.install
+      end
+
+      it "issues a warning when an implicit version number is used, and in sync" do
+        resource[:ensure] = '1.0-0.151006'
+        is = '1.0,5.11-0.151006:20140220T084443Z'
+        provider.expects(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
+        described_class.expects(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').returns File.read(my_fixture('dummy_implicit_version'))
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+        $CHILD_STATUS.stubs(:exitstatus).returns 4
+        provider.insync?(is)
+      end
+
+      it "issues a warning when choosing a version number for an implicit match" do
+        resource[:ensure] = '1.0-0.151006'
+        is = :absent
+        provider.expects(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
+        provider.expects(:warning).with("Selecting version '1.0,5.11-0.151006:20140220T084443Z' for implicit '1.0-0.151006'")
+        described_class.expects(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').returns File.read(my_fixture('dummy_implicit_version'))
+        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
+        provider.insync?(is)
+      end
     end
 
     context ":update" do
@@ -231,10 +302,12 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         provider.expects(:install).with(true).returns({:exit => 0})
         provider.update
       end
+
       it "should not raise error if not necessary (2)" do
         provider.expects(:install).with(true).returns({:exit => 4})
         provider.update
       end
+
       it "should raise error if necessary" do
         provider.expects(:install).with(true).returns({:exit => 1})
         expect {
@@ -249,6 +322,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         described_class.expects(:pkg).with([:uninstall, resource[:name]])
         provider.uninstall
       end
+
       it "should support original pkg commands" do
         described_class.expects(:pkg).with(:version).returns('052adf36c3f4')
         described_class.expects(:pkg).with([:uninstall, '-r', resource[:name]])

data/spec/unit/provider/package/pkgdmg_spec.rb

@@ -5,8 +5,8 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
   let(:resource) { Puppet::Type.type(:package).new(:name => 'foo', :provider => :pkgdmg) }
   let(:provider) { described_class.new(resource) }
 
-  it { should_not be_versionable }
-  it { should_not be_uninstallable }
+  it { is_expected.not_to be_versionable }
+  it { is_expected.not_to be_uninstallable }
 
   describe "when installing it should fail when" do
     before :each do
@@ -68,7 +68,7 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
         Dir.expects(:mktmpdir).returns tmpdir
         Dir.stubs(:entries).returns ["foo.pkg"]
         described_class.expects(:curl).with do |*args|
-          args[0] == "-o" and args[1].include? tmpdir and args.include? "--fail"
+          args[0] == "-o" && args[1].include?(tmpdir) && args.include?("--fail") && ! args.include?("-k")
         end
         described_class.stubs(:hdiutil).returns fake_hdiutil_plist
         described_class.expects(:installpkg)
@@ -82,8 +82,8 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
         Dir.expects(:mktmpdir).returns tmpdir
         Dir.stubs(:entries).returns ["foo.pkg"]
         described_class.expects(:curl).with do |*args|
-          args.should be_include 'some_host:some_port'
-          args.should be_include '--proxy'
+          expect(args).to be_include 'some_host:some_port'
+          expect(args).to be_include '--proxy'
         end
         described_class.stubs(:hdiutil).returns fake_hdiutil_plist
         described_class.expects(:installpkg)
@@ -97,8 +97,8 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
         Dir.expects(:mktmpdir).returns tmpdir
         Dir.stubs(:entries).returns ["foo.pkg"]
         described_class.expects(:curl).with do |*args|
-          args.should be_include 'some_host'
-          args.should be_include '--proxy'
+          expect(args).to be_include 'some_host'
+          expect(args).to be_include '--proxy'
         end
         described_class.stubs(:hdiutil).returns fake_hdiutil_plist
         described_class.expects(:installpkg)
@@ -133,8 +133,8 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
 
       it "should call installpkg if a flat pkg file is found instead of a .dmg image" do
         described_class.expects(:curl).with do |*args|
-          args.should be_include tmpfile
-          args.should be_include remote_source
+          expect(args).to be_include tmpfile
+          expect(args).to be_include remote_source
         end
         provider.class.expects(:installpkg).with(tmpfile, 'testpkg', remote_source)
         provider.install

data/spec/unit/provider/package/pkgin_spec.rb

@@ -8,7 +8,7 @@ describe provider_class do
 
   describe "Puppet provider interface" do
     it "can return the list of all packages" do
-      provider_class.should respond_to(:instances)
+      expect(provider_class).to respond_to(:instances)
     end
   end
 
@@ -50,18 +50,18 @@ describe provider_class do
 
     it "returns an array of providers for each package" do
       instances = provider_class.instances
-      instances.should have(2).items
+      expect(instances).to have(2).items
       instances.each do |instance|
-        instance.should be_a(provider_class)
+        expect(instance).to be_a(provider_class)
       end
     end
 
     it "populates each provider with an installed package" do
       zlib_provider, zziplib_provider = provider_class.instances
-      zlib_provider.get(:name).should == "zlib"
-      zlib_provider.get(:ensure).should == "1.2.3"
-      zziplib_provider.get(:name).should == "zziplib"
-      zziplib_provider.get(:ensure).should == "0.13.59"
+      expect(zlib_provider.get(:name)).to eq("zlib")
+      expect(zlib_provider.get(:ensure)).to eq("1.2.3")
+      expect(zziplib_provider.get(:name)).to eq("zziplib")
+      expect(zziplib_provider.get(:ensure)).to eq("0.13.59")
     end
   end
 
@@ -77,7 +77,7 @@ describe provider_class do
 
       it "returns installed version" do
         subject.expects(:properties).returns( { :ensure => "7.2.446" } )
-        subject.latest.should == "7.2.446"
+        expect(subject.latest).to eq("7.2.446")
       end
     end
 
@@ -87,7 +87,7 @@ describe provider_class do
       end
 
       it "returns the version to be installed" do
-        subject.latest.should == "7.2.447"
+        expect(subject.latest).to eq("7.2.447")
       end
     end
 
@@ -98,7 +98,7 @@ describe provider_class do
 
       it "returns current version" do
         subject.expects(:properties).returns( { :ensure => "7.2.446" } )
-        subject.latest.should == "7.2.446"
+        expect(subject.latest).to eq("7.2.446")
       end
     end
 
@@ -120,7 +120,7 @@ SEARCH
 
       it "returns the newest available version" do
         provider_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
-        subject.latest.should == "7.3"
+        expect(subject.latest).to eq("7.3")
       end
     end
 
@@ -140,9 +140,9 @@ SEARCH
       let(:package) { "vim-7.2.446 =        Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        provider_class.parse_pkgin_line(package).should == { :name => "vim" ,
+        expect(provider_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
                                                              :status => "=" ,
-                                                             :ensure => "7.2.446" }
+                                                             :ensure => "7.2.446" })
       end
     end
 
@@ -150,9 +150,9 @@ SEARCH
       let(:package) { "ruby18-puppet-0.25.5nb1 > Configuration management framework written in Ruby" }
 
       it "extracts the name and status" do
-        provider_class.parse_pkgin_line(package).should == { :name =>  "ruby18-puppet",
+        expect(provider_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby18-puppet",
                                                              :status => ">" ,
-                                                             :ensure => "0.25.5nb1" }
+                                                             :ensure => "0.25.5nb1" })
       end
     end
 
@@ -160,9 +160,9 @@ SEARCH
       let(:package) { "vim-7.2.446          Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        provider_class.parse_pkgin_line(package).should == { :name => "vim" ,
+        expect(provider_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
                                                              :status => nil ,
-                                                             :ensure => "7.2.446" }
+                                                             :ensure => "7.2.446" })
       end
 
     end
@@ -171,7 +171,7 @@ SEARCH
       let(:package) { "" }
 
       it "returns nil" do
-        provider_class.parse_pkgin_line(package).should be_nil
+        expect(provider_class.parse_pkgin_line(package)).to be_nil
       end
     end
   end