puppet 7.28.0-x86-mingw32 → 7.29.0-x86-mingw32

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

@@ -1,185 +0,0 @@
-require "spec_helper"
-
-describe Puppet::Type.type(:package).provider(:pkgin) do
-  let(:resource) { Puppet::Type.type(:package).new(:name => "vim", :provider => :pkgin) }
-  subject        { resource.provider }
-
-  describe "Puppet provider interface" do
-    it "can return the list of all packages" do
-      expect(described_class).to respond_to(:instances)
-    end
-  end
-
-  describe "#install" do
-   describe "a package not installed" do
-    before { resource[:ensure] = :absent }
-
-    it "uses pkgin install to install" do
-      expect(subject).to receive(:pkgin).with("-y", :install, "vim").once()
-      subject.install
-    end
-   end
-
-   describe "a package with a fixed version" do
-    before { resource[:ensure] = '7.2.446' }
-
-    it "uses pkgin install to install a fixed version" do
-      expect(subject).to receive(:pkgin).with("-y", :install, "vim-7.2.446").once()
-      subject.install
-    end
-   end
-  end
-
-  describe "#uninstall" do
-    it "uses pkgin remove to uninstall" do
-      expect(subject).to receive(:pkgin).with("-y", :remove, "vim").once()
-      subject.uninstall
-    end
-  end
-
-  describe "#instances" do
-    let(:pkgin_ls_output) do
-      "zlib-1.2.3;General purpose data compression library\nzziplib-0.13.59;Library for ZIP archive handling\n"
-    end
-
-    before do
-      allow(described_class).to receive(:pkgin).with(:list).and_return(pkgin_ls_output)
-    end
-
-    it "returns an array of providers for each package" do
-      instances = described_class.instances
-      expect(instances.count).to eq 2
-      instances.each do |instance|
-        expect(instance).to be_a(described_class)
-      end
-    end
-
-    it "populates each provider with an installed package" do
-      zlib_provider, zziplib_provider = described_class.instances
-      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
-
-  describe "#latest" do
-    before do
-      allow(described_class).to receive(:pkgin).with(:search, "vim").and_return(pkgin_search_output)
-    end
-
-    context "when the package is installed" do
-      let(:pkgin_search_output) do
-        "vim-7.2.446;=;Vim editor (vi clone) without GUI\nvim-share-7.2.446;=;Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
-      end
-
-      it "returns installed version" do
-        expect(subject).to receive(:properties).and_return({ :ensure => "7.2.446" })
-        expect(subject.latest).to eq("7.2.446")
-      end
-    end
-
-    context "when the package is out of date" do
-      let(:pkgin_search_output) do
-        "vim-7.2.447;<;Vim editor (vi clone) without GUI\nvim-share-7.2.447;<;Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
-      end
-
-      it "returns the version to be installed" do
-        expect(subject.latest).to eq("7.2.447")
-      end
-    end
-
-    context "when the package is ahead of date" do
-      let(:pkgin_search_output) do
-        "vim-7.2.446;>;Vim editor (vi clone) without GUI\nvim-share-7.2.446;>;Data files for the vim editor (vi clone)\n\n=: package is installed and up-to-date\n<: package is installed but newer version is available\n>: installed package has a greater version than available package\n"
-      end
-
-      it "returns current version" do
-        expect(subject).to receive(:properties).and_return({ :ensure => "7.2.446" })
-        expect(subject.latest).to eq("7.2.446")
-      end
-    end
-
-    context "when multiple candidates do exists" do
-      let(:pkgin_search_output) do
-        <<-SEARCH
-vim-7.1;>;Vim editor (vi clone) without GUI
-vim-share-7.1;>;Data files for the vim editor (vi clone)
-vim-7.2.446;=;Vim editor (vi clone) without GUI
-vim-share-7.2.446;=;Data files for the vim editor (vi clone)
-vim-7.3;<;Vim editor (vi clone) without GUI
-vim-share-7.3;<;Data files for the vim editor (vi clone)
-
-=: package is installed and up-to-date
-<: package is installed but newer version is available
->: installed package has a greater version than available package
-SEARCH
-      end
-
-      it "returns the newest available version" do
-        allow(described_class).to receive(:pkgin).with(:search, "vim").and_return(pkgin_search_output)
-        expect(subject.latest).to eq("7.3")
-      end
-    end
-
-    context "when the package cannot be found" do
-      let(:pkgin_search_output) do
-        "No results found for is-puppet"
-      end
-
-      it "returns nil" do
-        expect { subject.latest }.to raise_error(Puppet::Error, "No candidate to be installed")
-      end
-    end
-  end
-
-  describe "#parse_pkgin_line" do
-    context "with an installed package" do
-      let(:package) { "vim-7.2.446;=;Vim editor (vi clone) without GUI" }
-
-      it "extracts the name and status" do
-        expect(described_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
-                                                             :status => "=" ,
-                                                             :ensure => "7.2.446" })
-      end
-    end
-
-    context "with an installed package with a hyphen in the name" do
-      let(:package) { "ruby18-puppet-0.25.5nb1;>;Configuration management framework written in Ruby" }
-
-      it "extracts the name and status" do
-        expect(described_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby18-puppet",
-                                                             :status => ">" ,
-                                                             :ensure => "0.25.5nb1" })
-      end
-    end
-
-    context "with an installed package with a hyphen in the name and package description" do
-      let(:package) { "ruby200-facter-2.4.3nb1;=;Cross-platform Ruby library for retrieving facts from OS" }
-
-      it "extracts the name and status" do
-        expect(described_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby200-facter",
-                                                             :status => "=" ,
-                                                             :ensure => "2.4.3nb1" })
-      end
-    end
-
-    context "with a package not yet installed" do
-      let(:package) { "vim-7.2.446;Vim editor (vi clone) without GUI" }
-
-      it "extracts the name and status" do
-        expect(described_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
-                                                             :status => nil ,
-                                                             :ensure => "7.2.446" })
-      end
-    end
-
-    context "with an invalid package" do
-      let(:package) { "" }
-
-      it "returns nil" do
-        expect(described_class.parse_pkgin_line(package)).to be_nil
-      end
-    end
-  end
-end

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

@@ -1,228 +0,0 @@
-require 'spec_helper'
-require 'puppet/provider/package/pkgng'
-
-describe Puppet::Type.type(:package).provider(:pkgng) do
-  let(:name) { 'bash' }
-  let(:installed_name) { 'zsh' }
-  let(:pkgng) { 'pkgng' }
-
-  let(:resource) do
-    # When bash is not present
-    Puppet::Type.type(:package).new(:name => name, :provider => pkgng)
-  end
-
-  let(:installed_resource) do
-    # When zsh is present
-    Puppet::Type.type(:package).new(:name => installed_name, :provider => pkgng)
-  end
-
-  let(:latest_resource) do
-    # When curl is installed but not the latest
-    Puppet::Type.type(:package).new(:name => 'ftp/curl', :provider => pkgng, :ensure => latest)
-  end
-
-  let (:provider) { resource.provider }
-  let (:installed_provider) { installed_resource.provider }
-
-  def run_in_catalog(*resources)
-    catalog = Puppet::Resource::Catalog.new
-    catalog.host_config = false
-    resources.each do |resource|
-      catalog.add_resource(resource)
-    end
-    catalog.apply
-  end
-
-  before do
-    allow(described_class).to receive(:command).with(:pkg).and_return('/usr/local/sbin/pkg')
-
-    info = File.read(my_fixture('pkg.query'))
-    allow(described_class).to receive(:get_query).and_return(info)
-
-    version_list = File.read(my_fixture('pkg.version'))
-    allow(described_class).to receive(:get_version_list).and_return(version_list)
-  end
-
-  context "#instances" do
-    it "should return the empty set if no packages are listed" do
-      allow(described_class).to receive(:get_query).and_return('')
-      allow(described_class).to receive(:get_version_list).and_return('')
-      expect(described_class.instances).to be_empty
-    end
-
-    it "should return all packages when invoked" do
-      expect(described_class.instances.map(&:name).sort).to eq(
-        %w{ca_root_nss curl nmap pkg gnupg zsh tac_plus}.sort)
-    end
-
-    it "should set latest to current version when no upgrade available" do
-      nmap = described_class.instances.find {|i| i.properties[:origin] == 'security/nmap' }
-
-      expect(nmap.properties[:version]).to eq(nmap.properties[:latest])
-    end
-
-    it "should return an empty array when pkg calls raise an exception" do
-      allow(described_class).to receive(:get_query).and_raise(Puppet::ExecutionFailure, 'An error occurred.')
-      expect(described_class.instances).to eq([])
-    end
-
-    describe "version" do
-      it "should retrieve the correct version of the current package" do
-        zsh = described_class.instances.find {|i| i.properties[:origin] == 'shells/zsh' }
-        expect(zsh.properties[:version]).to eq('5.0.2_1')
-      end
-    end
-  end
-
-  context "#install" do
-    it "should call pkg with the specified package version given an origin for package name" do
-      resource = Puppet::Type.type(:package).new(
-        :name     => 'ftp/curl',
-        :provider => :pkgng,
-        :ensure   => '7.33.1'
-      )
-      expect(resource.provider).to receive(:pkg) do |arg|
-        expect(arg).to include('curl-7.33.1')
-      end
-      resource.provider.install
-    end
-
-    it "should call pkg with the specified package version" do
-      resource = Puppet::Type.type(:package).new(
-        :name     => 'curl',
-        :provider => :pkgng,
-        :ensure   => '7.33.1'
-      )
-      expect(resource.provider).to receive(:pkg) do |arg|
-        expect(arg).to include('curl-7.33.1')
-      end
-      resource.provider.install
-    end
-
-    it "should call pkg with the specified package repo" do
-      resource = Puppet::Type.type(:package).new(
-        :name     => 'curl',
-        :provider => :pkgng,
-        :source   => 'urn:freebsd:repo:FreeBSD'
-      )
-      expect(resource.provider).to receive(:pkg) do |arg|
-        expect(arg).to include('FreeBSD')
-      end
-      resource.provider.install
-    end
-
-    it "should call pkg with the specified install options string" do
-      resource = Puppet::Type.type(:package).new(
-        :name            => 'curl',
-        :provider        => :pkgng,
-        :install_options => ['--foo', '--bar']
-      )
-      expect(resource.provider).to receive(:pkg) do |arg|
-        expect(arg).to include('--foo', '--bar')
-      end
-      resource.provider.install
-    end
-
-    it "should call pkg with the specified install options hash" do
-      resource = Puppet::Type.type(:package).new(
-        :name            => 'curl',
-        :provider        => :pkgng,
-        :install_options => ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
-      )
-      expect(resource.provider).to receive(:pkg) do |arg|
-        expect(arg).to include('--foo', '--bar=baz', '--baz=foo')
-      end
-      resource.provider.install
-    end
-  end
-
-  context "#prefetch" do
-    it "should fail gracefully when " do
-      allow(described_class).to receive(:instances).and_return([])
-      expect{ described_class.prefetch({}) }.to_not raise_error
-    end
-  end
-
-  context "#query" do
-    it "should return the installed version if present" do
-      pkg_query_zsh = File.read(my_fixture('pkg.query.zsh'))
-      allow(described_class).to receive(:get_resource_info).with('zsh').and_return(pkg_query_zsh)
-      described_class.prefetch({installed_name => installed_resource})
-      expect(installed_provider.query).to be >= {:version=>'5.0.2_1'}
-    end
-
-    it "should return nil if not present" do
-      allow(described_class).to receive(:get_resource_info).with('bash').and_raise(Puppet::ExecutionFailure, 'An error occurred')
-
-      expect(provider.query).to equal(nil)
-    end
-  end
-
-  describe "latest" do
-    it "should retrieve the correct version of the latest package" do
-      described_class.prefetch( { installed_name => installed_resource })
-      expect(installed_provider.latest).not_to be_nil
-    end
-
-    it "should set latest to newer package version when available" do
-      instances = described_class.instances
-      curl = instances.find {|i| i.properties[:origin] == 'ftp/curl' }
-      expect(curl.properties[:latest]).to eq('7.33.0_2')
-    end
-
-    it "should call update to upgrade the version" do
-      allow(described_class).to receive(:get_resource_info).with('ftp/curl').and_return('curl 7.61.1 ftp/curl')
-
-      resource = Puppet::Type.type(:package).new(
-        :name     => 'ftp/curl',
-        :provider => pkgng,
-        :ensure   => :latest
-      )
-
-      expect(resource.provider).to receive(:update)
-
-      resource.property(:ensure).sync
-    end
-  end
-
-  describe "get_latest_version" do
-    it "should rereturn nil when the current package is the latest" do
-      version_list = File.read(my_fixture('pkg.version'))
-      allow(described_class).to receive(:get_version_list).and_return(version_list)
-      nmap_latest_version = described_class.get_latest_version('security/nmap')
-
-      expect(nmap_latest_version).to be_nil
-    end
-
-    it "should match the package name exactly" do
-      version_list = File.read(my_fixture('pkg.version'))
-      allow(described_class).to receive(:get_version_list).and_return(version_list)
-      bash_comp_latest_version = described_class.get_latest_version('shells/bash-completion')
-
-      expect(bash_comp_latest_version).to eq('2.1_3')
-    end
-
-    it "should return nil when the package is orphaned" do
-      version_list = File.read(my_fixture('pkg.version'))
-      allow(described_class).to receive(:get_version_list).and_return(version_list)
-      orphan_latest_version = described_class.get_latest_version('sysutils/orphan')
-      expect(orphan_latest_version).to be_nil
-    end
-
-    it "should return nil when the package is broken" do
-      version_list = File.read(my_fixture('pkg.version'))
-      allow(described_class).to receive(:get_version_list).and_return(version_list)
-      broken_latest_version = described_class.get_latest_version('sysutils/broken')
-      expect(broken_latest_version).to be_nil
-    end
-  end
-
-  describe "confine" do
-    context "on FreeBSD" do
-      it "should be the default provider" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:freebsd)
-        expect(described_class).to be_default
-      end
-    end
-  end
-end

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

@@ -1,231 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:pkgutil) do
-  before(:each) do
-    @resource = Puppet::Type.type(:package).new(
-      :name     => "TESTpkg",
-      :ensure   => :present,
-      :provider => :pkgutil
-    )
-    @provider = described_class.new(@resource)
-
-    # Stub all file and config tests
-    allow(described_class).to receive(:healthcheck)
-  end
-
-  it "should have an install method" do
-    expect(@provider).to respond_to(:install)
-  end
-
-  it "should have a latest method" do
-    expect(@provider).to respond_to(:uninstall)
-  end
-
-  it "should have an update method" do
-    expect(@provider).to respond_to(:update)
-  end
-
-  it "should have a latest method" do
-    expect(@provider).to respond_to(:latest)
-  end
-
-  describe "when installing" do
-    it "should use a command without versioned package" do
-      @resource[:ensure] = :latest
-      expect(@provider).to receive(:pkguti).with('-y', '-i', 'TESTpkg')
-      @provider.install
-    end
-
-    it "should support a single temp repo URL" do
-      @resource[:ensure] = :latest
-      @resource[:source] = "http://example.net/repo"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-i', 'TESTpkg')
-      @provider.install
-    end
-
-    it "should support multiple temp repo URLs as array" do
-      @resource[:ensure] = :latest
-      @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-i', 'TESTpkg')
-      @provider.install
-    end
-  end
-
-  describe "when updating" do
-    it "should use a command without versioned package" do
-      expect(@provider).to receive(:pkguti).with('-y', '-u', 'TESTpkg')
-      @provider.update
-    end
-
-    it "should support a single temp repo URL" do
-      @resource[:source] = "http://example.net/repo"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-u', 'TESTpkg')
-      @provider.update
-    end
-
-    it "should support multiple temp repo URLs as array" do
-      @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-u', 'TESTpkg')
-      @provider.update
-    end
-  end
-
-  describe "when uninstalling" do
-    it "should call the remove operation" do
-      expect(@provider).to receive(:pkguti).with('-y', '-r', 'TESTpkg')
-      @provider.uninstall
-    end
-
-    it "should support a single temp repo URL" do
-      @resource[:source] = "http://example.net/repo"
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-y', '-r', 'TESTpkg')
-      @provider.uninstall
-    end
-
-    it "should support multiple temp repo URLs as array" do
-      @resource[:source] = [ 'http://example.net/repo', 'http://example.net/foo' ]
-      expect(@provider).to receive(:pkguti).with('-t', 'http://example.net/repo', '-t', 'http://example.net/foo', '-y', '-r', 'TESTpkg')
-      @provider.uninstall
-    end
-  end
-
-  describe "when getting latest version" do
-    it "should return TESTpkg's version string" do
-      fake_data = "
-noisy output here
-TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
-    end
-
-    it "should support a temp repo URL" do
-      @resource[:source] = "http://example.net/repo"
-      fake_data = "
-noisy output here
-TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
-    end
-
-    it "should handle TESTpkg's 'SAME' version string" do
-      fake_data = "
-noisy output here
-TESTpkg                   1.4.5,REV=2007.11.18      SAME"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.latest).to eq("1.4.5,REV=2007.11.18")
-    end
-
-    it "should handle a non-existent package" do
-      fake_data = "noisy output here
-Not in catalog"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.latest).to eq(nil)
-    end
-
-    it "should warn on unknown pkgutil noise" do
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return("testingnoise")
-      expect(@provider.latest).to eq(nil)
-    end
-
-    it "should ignore pkgutil noise/headers to find TESTpkg" do
-      fake_data = "# stuff
-=> Fetching new catalog and descriptions (http://mirror.opencsw.org/opencsw/unstable/i386/5.11) if available ...
-2011-02-19 23:05:46 URL:http://mirror.opencsw.org/opencsw/unstable/i386/5.11/catalog [534635/534635] -> \"/var/opt/csw/pkgutil/catalog.mirror.opencsw.org_opencsw_unstable_i386_5.11.tmp\" [1]
-Checking integrity of /var/opt/csw/pkgutil/catalog.mirror.opencsw.org_opencsw_unstable_i386_5.11 with gpg.
-gpg: Signature made February 17, 2011 05:27:53 PM GMT using DSA key ID E12E9D2F
-gpg: Good signature from \"Distribution Manager <dm@blastwave.org>\"
-==> 2770 packages loaded from /var/opt/csw/pkgutil/catalog.mirror.opencsw.org_opencsw_unstable_i386_5.11
-package                   installed                 catalog
-TESTpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.latest).to eq("1.4.5,REV=2007.11.20")
-    end
-
-    it "should find REALpkg via an alias (TESTpkg)" do
-      fake_data = "
-noisy output here
-REALpkg                   1.4.5,REV=2007.11.18      1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.query[:name]).to eq("TESTpkg")
-    end
-  end
-
-  describe "when querying current version" do
-    it "should return TESTpkg's version string" do
-      fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.query[:ensure]).to eq("1.4.5,REV=2007.11.18")
-    end
-
-    it "should handle a package that isn't installed" do
-      fake_data = "TESTpkg  notinst  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.query[:ensure]).to eq(:absent)
-    end
-
-    it "should handle a non-existent package" do
-      fake_data = "noisy output here
-Not in catalog"
-      expect(described_class).to receive(:pkguti).with('-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.query[:ensure]).to eq(:absent)
-    end
-
-    it "should support a temp repo URL" do
-      @resource[:source] = "http://example.net/repo"
-      fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with('-t', 'http://example.net/repo', '-c', '--single', 'TESTpkg').and_return(fake_data)
-      expect(@provider.query[:ensure]).to eq("1.4.5,REV=2007.11.18")
-    end
-  end
-
-  describe "when querying current instances" do
-    it "should warn on unknown pkgutil noise" do
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return("testingnoise")
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return("testingnoise")
-      expect(Puppet).to receive(:warning).twice
-      expect(described_class).not_to receive(:new)
-      expect(described_class.instances).to eq([])
-    end
-
-    it "should return TESTpkg's version string" do
-      fake_data = "TESTpkg  TESTpkg  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
-
-      fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
-
-      testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with({:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil}).and_return(testpkg)
-      expect(described_class.instances).to eq([testpkg])
-    end
-
-    it "should also return both TESTpkg and mypkg alias instances" do
-      fake_data = "mypkg  TESTpkg  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
-
-      fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
-
-      testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with({:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil}).and_return(testpkg)
-
-      aliaspkg = double('pkg2')
-      expect(described_class).to receive(:new).with({:ensure => "1.4.5,REV=2007.11.18", :name => "mypkg", :provider => :pkgutil}).and_return(aliaspkg)
-
-      expect(described_class.instances).to eq([testpkg,aliaspkg])
-    end
-
-    it "shouldn't mind noise in the -a output" do
-      fake_data = "noisy output here"
-      expect(described_class).to receive(:pkguti).with(['-a']).and_return(fake_data)
-
-      fake_data = "TESTpkg  1.4.5,REV=2007.11.18  1.4.5,REV=2007.11.20"
-      expect(described_class).to receive(:pkguti).with(['-c']).and_return(fake_data)
-
-      testpkg = double('pkg1')
-      expect(described_class).to receive(:new).with({:ensure => "1.4.5,REV=2007.11.18", :name => "TESTpkg", :provider => :pkgutil}).and_return(testpkg)
-
-      expect(described_class.instances).to eq([testpkg])
-    end
-  end
-end