puppet 3.8.7 → 4.0.0.rc1

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

@@ -22,17 +22,17 @@ describe provider_class do
 
   it "should have an install method" do
     @provider = provider_class.new
-    @provider.should respond_to(:install)
+    expect(@provider).to respond_to(:install)
   end
 
   it "should have an uninstall method" do
     @provider = provider_class.new
-    @provider.should respond_to(:uninstall)
+    expect(@provider).to respond_to(:uninstall)
   end
 
   it "should have a swlist method" do
     @provider = provider_class.new
-    @provider.should respond_to(:swlist)
+    expect(@provider).to respond_to(:swlist)
   end
 
   describe "when installing" do

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

@@ -24,10 +24,10 @@ describe provider_class do
   describe "provider features" do
     subject { provider }
 
-    it { should be_installable }
-    it { should be_uninstallable }
-    it { should be_upgradeable }
-    it { should be_versionable }
+    it { is_expected.to be_installable }
+    it { is_expected.to be_uninstallable }
+    it { is_expected.to be_upgradeable }
+    it { is_expected.to be_versionable }
   end
 
   describe "when listing all instances" do
@@ -38,17 +38,17 @@ describe provider_class do
 
     it "should create instances from active ports" do
       provider_class.expects(:port).returns("foo @1.234.5_2 (active)")
-      provider_class.instances.size.should == 1
+      expect(provider_class.instances.size).to eq(1)
     end
 
     it "should ignore ports that aren't activated" do
       provider_class.expects(:port).returns("foo @1.234.5_2")
-      provider_class.instances.size.should == 0
+      expect(provider_class.instances.size).to eq(0)
     end
 
     it "should ignore variants" do
-      provider_class.parse_installed_query_line("bar @1.0beta2_38_1+x11+java (active)").
-        should == {:provider=>:macports, :revision=>"1", :name=>"bar", :ensure=>"1.0beta2_38"}
+      expect(provider_class.parse_installed_query_line("bar @1.0beta2_38_1+x11+java (active)")).
+        to eq({:provider=>:macports, :revision=>"1", :name=>"bar", :ensure=>"1.0beta2_38"})
     end
 
   end
@@ -57,7 +57,7 @@ describe provider_class do
    it "should not specify a version when ensure is set to latest" do
      resource[:ensure] = :latest
      provider.expects(:port).with { |flag, method, name, version|
-       version.should be_nil
+       expect(version).to be_nil
      }
      provider.install
    end
@@ -65,7 +65,7 @@ describe provider_class do
    it "should not specify a version when ensure is set to present" do
      resource[:ensure] = :present
      provider.expects(:port).with { |flag, method, name, version|
-       version.should be_nil
+       expect(version).to be_nil
      }
      provider.install
    end
@@ -73,7 +73,7 @@ describe provider_class do
    it "should specify a version when ensure is set to a version" do
      resource[:ensure] = "1.2.3"
      provider.expects(:port).with { |flag, method, name, version|
-       version.should be
+       expect(version).to be
      }
      provider.install
    end
@@ -95,28 +95,28 @@ describe provider_class do
     it "should return nil when the package cannot be found" do
       resource[:name] = resource_name
       provider.expects(:execute).with(infoargs, arguments).returns("")
-      provider.latest.should == nil
+      expect(provider.latest).to eq(nil)
     end
 
     it "should return the current version if the installed port has the same revision" do
       current_hash[:revision] = "2"
       provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
       provider.expects(:query).returns(current_hash)
-      provider.latest.should == current_hash[:ensure]
+      expect(provider.latest).to eq(current_hash[:ensure])
     end
 
     it "should return the new version_revision if the installed port has a lower revision" do
       current_hash[:revision] = "1"
       provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
       provider.expects(:query).returns(current_hash)
-      provider.latest.should == "1.2.3_2"
+      expect(provider.latest).to eq("1.2.3_2")
     end
 
     it "should return the newest version if the port is not installed" do
       resource[:name] = resource_name
       provider.expects(:execute).with(infoargs, arguments).returns(new_info_line)
       provider.expects(:execute).with(["/opt/local/bin/port", "-q", :installed, resource[:name]], arguments).returns("")
-      provider.latest.should == "1.2.3_2"
+      expect(provider.latest).to eq("1.2.3_2")
     end
   end
 

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

@@ -23,7 +23,7 @@ describe provider_class do
 
   it "should have an install method" do
     @provider = provider_class.new
-    @provider.should respond_to(:install)
+    expect(@provider).to respond_to(:install)
   end
 
   let(:bff_showres_output) {
@@ -195,21 +195,21 @@ OUTPUT
     describe "#parse_showres_output" do
       it "should be able to parse installp/BFF package listings" do
         packages = subject.send(:parse_showres_output, bff_showres_output)
-        Set.new(packages.keys).should == Set.new(['mypackage.foo'])
+        expect(Set.new(packages.keys)).to eq(Set.new(['mypackage.foo']))
         versions = packages['mypackage.foo']
         ['1.2.3.1', '1.2.3.4', '1.2.3.8'].each do |version|
-          versions.has_key?(version).should == true
-          versions[version].should == :installp
+          expect(versions.has_key?(version)).to eq(true)
+          expect(versions[version]).to eq(:installp)
         end
       end
 
       it "should be able to parse RPM package listings" do
         packages = subject.send(:parse_showres_output, rpm_showres_output)
-        Set.new(packages.keys).should == Set.new(['mypackage.foo'])
+        expect(Set.new(packages.keys)).to eq(Set.new(['mypackage.foo']))
         versions = packages['mypackage.foo']
         ['1.2.3-1', '1.2.3-4', '1.2.3-8'].each do |version|
-          versions.has_key?(version).should == true
-          versions[version].should == :rpm
+          expect(versions.has_key?(version)).to eq(true)
+          expect(versions[version]).to eq(:rpm)
         end
       end
     end
@@ -217,7 +217,7 @@ OUTPUT
     describe "#determine_latest_version" do
       context "when there are multiple versions" do
         it "should return the latest version" do
-          subject.send(:determine_latest_version, rpm_showres_output, 'mypackage.foo').should == [:rpm, '1.2.3-8']
+          expect(subject.send(:determine_latest_version, rpm_showres_output, 'mypackage.foo')).to eq([:rpm, '1.2.3-8'])
         end
       end
 
@@ -228,7 +228,7 @@ mypackage.foo                                                                ALL
  @@R:mypackage.foo-1.2.3-4 1.2.3-4
 
 END
-          subject.send(:determine_latest_version, nimclient_showres_output, 'mypackage.foo').should == [:rpm, nil]
+          expect(subject.send(:determine_latest_version, nimclient_showres_output, 'mypackage.foo')).to eq([:rpm, nil])
         end
       end
 
@@ -236,11 +236,11 @@ END
 
     describe "#determine_package_type" do
       it "should return :rpm for rpm packages" do
-        subject.send(:determine_package_type, rpm_showres_output, 'mypackage.foo', '1.2.3-4').should == :rpm
+        expect(subject.send(:determine_package_type, rpm_showres_output, 'mypackage.foo', '1.2.3-4')).to eq(:rpm)
       end
 
       it "should return :installp for installp/bff packages" do
-        subject.send(:determine_package_type, bff_showres_output, 'mypackage.foo', '1.2.3.4').should == :installp
+        expect(subject.send(:determine_package_type, bff_showres_output, 'mypackage.foo', '1.2.3.4')).to eq(:installp)
       end
     end
   end

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

@@ -16,34 +16,34 @@ describe provider_class do
 
   def expect_pkgadd_with_source(source)
     provider.expects(:pkgadd).with do |fullname|
-      ENV.should_not be_key('PKG_PATH')
-      fullname.should == [source]
+      expect(ENV).not_to be_key('PKG_PATH')
+      expect(fullname).to eq([source])
     end
   end
 
   def expect_pkgadd_with_env_and_name(source, &block)
-    ENV.should_not be_key('PKG_PATH')
+    expect(ENV).not_to be_key('PKG_PATH')
 
     provider.expects(:pkgadd).with do |fullname|
-      ENV.should be_key('PKG_PATH')
-      ENV['PKG_PATH'].should == source
+      expect(ENV).to be_key('PKG_PATH')
+      expect(ENV['PKG_PATH']).to eq(source)
 
-      fullname.should == [provider.resource[:name]]
+      expect(fullname).to eq([provider.resource[:name]])
     end
     provider.expects(:execpipe).with(['/bin/pkg_info', '-I', provider.resource[:name]]).yields('')
 
     yield
 
-    ENV.should_not be_key('PKG_PATH')
+    expect(ENV).not_to be_key('PKG_PATH')
   end
 
   describe 'provider features' do
-    it { should be_installable }
-    it { should be_install_options }
-    it { should be_uninstallable }
-    it { should be_uninstall_options }
-    it { should be_upgradeable }
-    it { should be_versionable }
+    it { is_expected.to be_installable }
+    it { is_expected.to be_install_options }
+    it { is_expected.to be_uninstallable }
+    it { is_expected.to be_uninstall_options }
+    it { is_expected.to be_upgradeable }
+    it { is_expected.to be_versionable }
   end
 
   before :each do
@@ -57,19 +57,20 @@ describe provider_class do
   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
+      expect(provider_class.instances).to 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
+      expect(provider_class.instances).to 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 ==
+      expect(provider_class.instances.map(&:name).sort).to eq(
         %w{bash bzip2 expat gettext libiconv lzo openvpn python vim wget}.sort
+      )
     end
 
     it "should return all flavors if set" do
@@ -77,9 +78,9 @@ describe provider_class do
       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[1].should == {:name => 'vim',  :ensure => '7.0.42', :flavor => 'no_x11'}
+      expect(instances.size).to eq(2)
+      expect(instances[0]).to eq({:name => 'bash', :ensure => '3.1.17', :flavor => 'static'})
+      expect(instances[1]).to eq({:name => 'vim',  :ensure => '7.0.42', :flavor => 'no_x11'})
     end
   end
 
@@ -147,7 +148,7 @@ describe provider_class do
         provider.install
       end
 
-      provider.resource[:source].should == url
+      expect(provider.resource[:source]).to eq(url)
     end
 
     it "should strip leading whitespace in installpath" do
@@ -252,45 +253,79 @@ describe provider_class do
     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'
+      expect(provider.latest).to eq('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'
+      expect(provider.latest).to eq('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'
+      expect(provider.latest).to eq('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'
+      expect(provider.latest).to eq('6.18.01p0')
+    end
+  end
+
+  context "#get_full_name" do
+    it "should return the full unversioned package name when updating with a flavor" do
+      provider.resource[:ensure] = 'latest'
+      provider.resource[:flavor] = 'static'
+      expect(provider.get_full_name).to eq('bash--static')
+    end
+
+    it "should return the full unversioned package name when updating without a flavor" do
+        provider.resource[:name] = 'puppet'
+        provider.resource[:ensure] = 'latest'
+        expect(provider.get_full_name).to eq('puppet')
+    end
+
+    it "should use the ensure parameter if it is numeric" do
+      provider.resource[:name] = 'zsh'
+      provider.resource[:ensure] = '1.0'
+      expect(provider.get_full_name).to eq('zsh-1.0')
+    end
+
+    it "should lookup the correct version" do
+      output = 'bash-3.1.17         GNU Bourne Again Shell'
+      provider.expects(:execpipe).with(%w{/bin/pkg_info -I bash}).yields(output)
+      expect(provider.get_full_name).to eq('bash-3.1.17')
+    end
+
+    it "should lookup the correction version with flavors" do
+      provider.resource[:name] = 'fossil'
+      provider.resource[:flavor] = 'static'
+      output = 'fossil-1.29v0-static simple distributed software configuration management'
+      provider.expects(:execpipe).with(%w{/bin/pkg_info -I fossil}).yields(output)
+      expect(provider.get_full_name).to eq('fossil-1.29v0-static')
     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
+      expect(provider.get_version).to 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'
+      expect(provider.get_version).to eq('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 == ''
+      expect(provider.get_version).to eq('')
     end
   end
 
@@ -298,55 +333,55 @@ describe provider_class 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' }
+      expect(provider.query).to eq({ :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
+      expect(provider.query).to be_nil
     end
   end
 
   context "#install_options" do
     it "should return nill by default" do
-      provider.install_options.should be_nil
+      expect(provider.install_options).to be_nil
     end
 
     it "should return install_options when set" do
       provider.resource[:install_options] = ['-n']
-      provider.resource[:install_options].should == ['-n']
+      expect(provider.resource[:install_options]).to eq(['-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']
+      expect(provider.resource[:install_options]).to eq(['-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']
+      expect(provider.install_options).to eq(['-Darch=vax'])
     end
   end
 
   context "#uninstall_options" do
     it "should return nill by default" do
-      provider.uninstall_options.should be_nil
+      expect(provider.uninstall_options).to be_nil
     end
 
     it "should return uninstall_options when set" do
       provider.resource[:uninstall_options] = ['-n']
-      provider.resource[:uninstall_options].should == ['-n']
+      expect(provider.resource[:uninstall_options]).to eq(['-n'])
     end
 
     it "should return multiple uninstall_options when set" do
       provider.resource[:uninstall_options] = ['-q', '-c']
-      provider.resource[:uninstall_options].should == ['-q', '-c']
+      expect(provider.resource[:uninstall_options]).to eq(['-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']
+      expect(provider.uninstall_options).to eq(['-Dbaddepend=1'])
     end
   end
 

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

@@ -12,7 +12,7 @@ describe Puppet::Type.type(:package).provider(:opkg) do
   before do
     Puppet::Util::Execution.stubs(:execute).never
     Puppet::Util.stubs(:which).with("opkg").returns("/bin/opkg")
-    Dir.stubs(:entries).with('/var/opkg-lists/').returns ['.', '..', 'packages']
+    provider.stubs(:package_lists).returns ['.', '..', 'packages']
   end
 
   describe "when installing" do
@@ -22,7 +22,7 @@ describe Puppet::Type.type(:package).provider(:opkg) do
 
     context "when the package list is absent" do
       before do
-        Dir.stubs(:entries).with('/var/opkg-lists/').returns ['.', '..']  #empty, no package list
+        provider.stubs(:package_lists).returns ['.', '..']  #empty, no package list
       end
 
       it "fetches the package list when installing" do
@@ -35,7 +35,7 @@ describe Puppet::Type.type(:package).provider(:opkg) do
 
     context "when the package list is present" do
       before do
-        Dir.stubs(:entries).with('/var/opkg-lists/').returns ['.', '..', 'lists']  # With a pre-downloaded package list
+        provider.stubs(:package_lists).returns ['.', '..', 'lists']  # With a pre-downloaded package list
       end
 
       it "fetches the package list when installing" do
@@ -111,7 +111,7 @@ describe Puppet::Type.type(:package).provider(:opkg) do
   describe "when updating" do
     it "should call install" do
       provider.expects(:install).returns("install return value")
-      provider.update.should == "install return value"
+      expect(provider.update).to eq("install return value")
     end
   end
 
@@ -138,42 +138,45 @@ OPKG_OUTPUT
         described_class.expects(:execpipe).with("/bin/opkg list-installed").yields(packages)
 
         installed_packages = described_class.instances
-        installed_packages.length.should == 3
+        expect(installed_packages.length).to eq(3)
 
-        installed_packages[0].properties.should ==
+        expect(installed_packages[0].properties).to eq(
           {
             :provider => :opkg,
             :name => "dropbear",
             :ensure => "2011.54-2"
           }
-        installed_packages[1].properties.should ==
+        )
+        expect(installed_packages[1].properties).to eq(
           {
             :provider => :opkg,
             :name => "kernel",
             :ensure => "3.3.8-1-ba5cdb2523b4fc7722698b4a7ece6702"
           }
-        installed_packages[2].properties.should ==
+        )
+        expect(installed_packages[2].properties).to eq(
           {
             :provider => :opkg,
             :name => "uhttpd",
             :ensure => "2012-10-30-e57bf6d8bfa465a50eea2c30269acdfe751a46fd"
           }
+        )
       end
     end
 
     it "should return a nil if the package isn't found" do
       Puppet::Util::Execution.expects(:execute).returns("")
-      provider.query.should be_nil
+      expect(provider.query).to be_nil
     end
 
     it "should return a hash indicating that the package is missing on error" do
       Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("ERROR!"))
-      provider.query.should == {
+      expect(provider.query).to eq({
         :ensure => :purged,
         :status => 'missing',
         :name => resource[:name],
         :error => 'ok',
-      }
+      })
     end
   end #end when querying