puppet 7.32.1-x64-mingw32 → 8.0.1-x64-mingw32

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

@@ -0,0 +1,473 @@
+require 'spec_helper'
+
+describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platform.jruby? do
+  let (:resource) { Puppet::Resource.new(:package, 'dummy', :parameters => {:name => 'dummy', :ensure => :latest}) }
+  let (:provider) { described_class.new(resource) }
+
+  before :each do
+    allow(described_class).to receive(:command).with(:pkg).and_return('/bin/pkg')
+  end
+
+  def self.it_should_respond_to(*actions)
+    actions.each do |action|
+      it "should respond to :#{action}" do
+        expect(provider).to respond_to(action)
+      end
+    end
+  end
+
+  it_should_respond_to :install, :uninstall, :update, :query, :latest
+
+  context 'default' do
+    [ 10 ].each do |ver|
+      it "should not be the default provider on Solaris #{ver}" do
+        allow(Facter).to receive(:value).with('os.family').and_return(:Solaris)
+        allow(Facter).to receive(:value).with(:kernelrelease).and_return("5.#{ver}")
+        allow(Facter).to receive(:value).with('os.name').and_return(:Solaris)
+        allow(Facter).to receive(:value).with('os.release.major').and_return("#{ver}")
+        expect(described_class).to_not be_default
+      end
+    end
+
+    [ 11, 12 ].each do |ver|
+      it "should be the default provider on Solaris #{ver}" do
+        allow(Facter).to receive(:value).with('os.family').and_return(:Solaris)
+        allow(Facter).to receive(:value).with(:kernelrelease).and_return("5.#{ver}")
+        allow(Facter).to receive(:value).with('os.name').and_return(:Solaris)
+        allow(Facter).to receive(:value).with('os.release.major').and_return("#{ver}")
+        expect(described_class).to be_default
+      end
+    end
+  end
+
+  it "should be versionable" do
+    expect(described_class).to be_versionable
+  end
+
+  describe "#methods" do
+    context ":pkg_state" do
+      it "should raise error on unknown values" do
+        expect {
+          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
+          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 {
+          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
+          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 {
+          expect(described_class.parse_line('pkg (mypkg) 1.2.3.4 i-- zzz')).to
+        }.to raise_error(ArgumentError, /Unknown line format/)
+      end
+
+      {
+        '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 => "11,5.11-0.151006:20130506T183443Z", :mark => :hold, :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
+          expect(described_class.parse_line(k)).to eq(v)
+        end
+      end
+    end
+
+    context ":latest" do
+      before do
+        expect(described_class).to receive(:pkg).with(:refresh)
+      end
+
+      it "should work correctly for ensure latest on solaris 11 (UFOXI) when there are no further packages to install" do
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(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
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(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
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true})
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(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
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(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
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true})
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(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."
+        expect(Puppet).to receive(:warning).with("pkg warning: #{warning}")
+
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.certificate_warning')))
+        provider.latest
+      end
+
+      it "doesn't issue a warning when the certificate hasn't expired" do
+        expect(Puppet).not_to receive(:warning).with(/pkg warning/)
+
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.installed')))
+        provider.latest
+      end
+
+      it "applies install options if available" do
+        resource[:install_options] = ['--foo', {'--bar' => 'baz'}]
+        expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.known')))
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(['/bin/pkg', 'update', '-n', '--foo', '--bar=baz', 'dummy'], {failonfail: false, combine: true})
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        provider.latest
+      end
+    end
+
+    context ":instances" do
+      it "should correctly parse lines on solaris 11" do
+        expect(described_class).to receive(:pkg).with(:list, '-Hv').and_return(File.read(my_fixture('solaris11')))
+        expect(described_class).not_to receive(:warning)
+        instances = described_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure) }}
+        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'))
+        expect(described_class).to receive(:pkg).with(:list,'-Hv').and_return(fake_output)
+        expect {
+          described_class.instances
+        }.to raise_error(ArgumentError, /Unknown line format pkg/)
+      end
+
+      it "should fail on unknown package status" do
+        expect(described_class).to receive(:pkg).with(:list,'-Hv').and_return(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
+          expect(Puppet::Util::Execution).to receive(:execute)
+            .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+            .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris10')), 0))
+          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
+          expect(Puppet::Util::Execution).to receive(:execute)
+            .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 1))
+          expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
+        end
+      end
+
+      context "on solaris 11" do
+        it "should find the package" do
+          expect(Puppet::Util::Execution).to receive(:execute)
+            .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+            .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris11.installed')), 0))
+          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
+          expect(Puppet::Util::Execution).to receive(:execute)
+            .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 1))
+          expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
+        end
+      end
+
+      it "should return fail when the packageline cannot be parsed" do
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+          .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('incomplete')), 0))
+        expect {
+          provider.query
+        }.to raise_error(ArgumentError, /Unknown line format/)
+      end
+    end
+
+    context ":install" do
+      [
+        { :osrel => '11.0', :flags => ['--accept'] },
+        { :osrel => '11.2', :flags => ['--accept', '--sync-actuators-timeout', '900'] },
+      ].each do |hash|
+        context "with 'os.release.full' #{hash[:osrel]}" do
+          before :each do
+            allow(Facter).to receive(:value).with('os.release.full').and_return(hash[:osrel])
+          end
+
+          it "should support install options" do
+            resource[:install_options] = ['--foo', {'--bar' => 'baz'}]
+            expect(provider).to receive(:query).and_return({:ensure => :absent})
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(provider).to receive(:unhold)
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], '--foo', '--bar=baz', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            provider.install
+          end
+
+          it "should accept all licenses" do
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            provider.install
+          end
+
+          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,5.11-0.151006:20131230T130000Z'
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.6,5.11-0.151006:20131230T130000Z  installed -----', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7,5.11-0.151006:20131230T130000Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            provider.install
+          end
+
+          it "should install specific version(2)" do
+            resource[:ensure] = '0.0.8'
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.7,5.11-0.151006:20131230T130000Z  installed -----', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.8'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            provider.install
+          end
+
+          it "should downgrade to specific version" do
+            resource[:ensure] = '0.0.7'
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => '0.0.8,5.11-0.151106:20131230T130000Z'})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            provider.install
+          end
+
+          it "should install any if version is not specified" do
+            resource[:ensure] = :present
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 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'
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            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
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
+            expect(provider).to receive(:properties).and_return({:mark => :hold}).exactly(3).times
+
+            expect(described_class).to receive(:pkg)
+              .with(:freeze, 'dummy')
+            expect(described_class).to receive(:pkg)
+              .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(provider).to receive(:unhold).with(no_args).twice
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 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'
+            expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
+            expect(provider).to receive(:properties).and_return({:mark => :hold}).exactly(3).times
+
+            expect(described_class).to receive(:pkg)
+              .with(:freeze, 'dummy')
+            expect(described_class).to receive(:pkg)
+              .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
+              .and_return(File.read(my_fixture('dummy_implicit_version')))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            expect(provider).to receive(:unhold).with(no_args).twice
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 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'
+            expect(provider).to receive(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
+            expect(described_class).to receive(:pkg)
+              .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 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
+            expect(provider).to receive(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
+            expect(provider).to receive(:warning).with("Selecting version '1.0,5.11-0.151006:20140220T084443Z' for implicit '1.0-0.151006'")
+            expect(described_class).to receive(:pkg)
+              .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            provider.insync?(is)
+          end
+
+          it "should try 5 times to install and fail when all tries failed" do
+            allow_any_instance_of(Kernel).to receive(:sleep)
+
+            expect(provider).to receive(:query).and_return({:ensure => :absent})
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
+            expect(provider).to receive(:unhold)
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 7))
+              .exactly(5).times
+            expect {
+              provider.update
+            }.to raise_error(Puppet::Error, /Pkg could not install dummy after 5 tries. Aborting run/)
+          end
+        end
+      end
+    end
+
+    context ":update" do
+      it "should not raise error if not necessary" do
+        expect(provider).to receive(:install).with(true).and_return({:exit => 0})
+        provider.update
+      end
+
+      it "should not raise error if not necessary (2)" do
+        expect(provider).to receive(:install).with(true).and_return({:exit => 4})
+        provider.update
+      end
+
+      it "should raise error if necessary" do
+        expect(provider).to receive(:install).with(true).and_return({:exit => 1})
+        expect {
+          provider.update
+        }.to raise_error(Puppet::Error, /Unable to update/)
+      end
+    end
+
+    context ":uninstall" do
+      it "should support current pkg version" do
+        expect(described_class).to receive(:pkg).with(:version).and_return('630e1ffc7a19')
+        expect(described_class).to receive(:pkg).with([:uninstall, resource[:name]])
+        expect(provider).to receive(:properties).and_return({:hold => false})
+
+        provider.uninstall
+      end
+
+      it "should support original pkg commands" do
+        expect(described_class).to receive(:pkg).with(:version).and_return('052adf36c3f4')
+        expect(described_class).to receive(:pkg).with([:uninstall, '-r', resource[:name]])
+        expect(provider).to receive(:properties).and_return({:hold => false})
+
+        provider.uninstall
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+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 { is_expected.not_to be_versionable }
+  it { is_expected.not_to be_uninstallable }
+
+  describe "when installing it should fail when" do
+    it "no source is specified" do
+      expect { provider.install }.to raise_error(Puppet::Error, /must specify a package source/)
+    end
+
+    it "the source does not end in .dmg or .pkg" do
+      resource[:source] = "bar"
+      expect { provider.install }.to raise_error(Puppet::Error, /must specify a source string ending in .*dmg.*pkg/)
+    end
+  end
+
+  # These tests shouldn't be this messy. The pkgdmg provider needs work...
+  describe "when installing a pkgdmg" do
+    let(:fake_mountpoint) { "/tmp/dmg.foo" }
+    let(:fake_hdiutil_plist) { {"system-entities" => [{"mount-point" => fake_mountpoint}]} }
+
+    before do
+      fh = double('filehandle')
+      allow(fh).to receive(:path).and_return("/tmp/foo")
+      resource[:source] = "foo.dmg"
+      allow(File).to receive(:open).and_yield(fh)
+      allow(Dir).to receive(:mktmpdir).and_return("/tmp/testtmp123")
+      allow(FileUtils).to receive(:remove_entry_secure)
+    end
+
+    it "should fail when a disk image with no system entities is mounted" do
+      allow(described_class).to receive(:hdiutil).and_return('empty plist')
+      expect(Puppet::Util::Plist).to receive(:parse_plist).with('empty plist').and_return({})
+      expect { provider.install }.to raise_error(Puppet::Error, /No disk entities/)
+    end
+
+    it "should call hdiutil to mount and eject the disk image" do
+      allow(Dir).to receive(:entries).and_return([])
+      expect(provider.class).to receive(:hdiutil).with("eject", fake_mountpoint).and_return(0)
+      expect(provider.class).to receive(:hdiutil).with("mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", '/tmp/foo').and_return('a plist')
+      expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+      provider.install
+    end
+
+    it "should call installpkg if a pkg/mpkg is found on the dmg" do
+      allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+      allow(provider.class).to receive(:hdiutil).and_return('a plist')
+      expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+      expect(provider.class).to receive(:installpkg).with("#{fake_mountpoint}/foo.pkg", resource[:name], "foo.dmg").and_return("")
+      provider.install
+    end
+
+    describe "from a remote source" do
+      let(:tmpdir) { "/tmp/good123" }
+
+      before :each do
+        resource[:source] = "http://fake.puppetlabs.com/foo.dmg"
+      end
+
+      it "should call tmpdir and then call curl with that directory" do
+        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
+        allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args[0]).to eq("-o")
+          expect(args[1]).to include(tmpdir)
+          expect(args).to include("--fail")
+          expect(args).not_to include("-k")
+        end
+        allow(described_class).to receive(:hdiutil).and_return('a plist')
+        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+        expect(described_class).to receive(:installpkg)
+
+        provider.install
+      end
+
+      it "should use an http proxy host and port if specified" do
+        expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
+        expect(Puppet::Util::HttpProxy).to receive(:http_proxy_host).and_return('some_host')
+        expect(Puppet::Util::HttpProxy).to receive(:http_proxy_port).and_return('some_port')
+        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
+        allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args).to include('some_host:some_port')
+          expect(args).to include('--proxy')
+        end
+        allow(described_class).to receive(:hdiutil).and_return('a plist')
+        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+        expect(described_class).to receive(:installpkg)
+
+        provider.install
+      end
+
+      it "should use an http proxy host only if specified" do
+        expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(false)
+        expect(Puppet::Util::HttpProxy).to receive(:http_proxy_host).and_return('some_host')
+        expect(Puppet::Util::HttpProxy).to receive(:http_proxy_port).and_return(nil)
+        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
+        allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args).to include('some_host')
+          expect(args).to include('--proxy')
+        end
+        allow(described_class).to receive(:hdiutil).and_return('a plist')
+        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+        expect(described_class).to receive(:installpkg)
+
+        provider.install
+      end
+
+      it "should not use the configured proxy if no_proxy contains a match for the destination" do
+        expect(Puppet::Util::HttpProxy).to receive(:no_proxy?).and_return(true)
+        expect(Puppet::Util::HttpProxy).not_to receive(:http_proxy_host)
+        expect(Puppet::Util::HttpProxy).not_to receive(:http_proxy_port)
+        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
+        allow(Dir).to receive(:entries).and_return(["foo.pkg"])
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args).not_to include('some_host:some_port')
+          expect(args).not_to include('--proxy')
+          true
+        end
+        allow(described_class).to receive(:hdiutil).and_return('a plist')
+        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
+        expect(described_class).to receive(:installpkg)
+
+        provider.install
+      end
+    end
+  end
+
+  describe "when installing flat pkg file" do
+    describe "with a local source" do
+      it "should call installpkg if a flat pkg file is found instead of a .dmg image" do
+        resource[:source] = "/tmp/test.pkg"
+        resource[:name] = "testpkg"
+        expect(provider.class).to receive(:installpkgdmg).with("/tmp/test.pkg", "testpkg").and_return("")
+        provider.install
+      end
+    end
+
+    describe "with a remote source" do
+      let(:remote_source) { 'http://fake.puppetlabs.com/test.pkg' }
+      let(:tmpdir) { '/path/to/tmpdir' }
+      let(:tmpfile) { File.join(tmpdir, 'testpkg.pkg') }
+
+      before do
+        resource[:name]   = 'testpkg'
+        resource[:source] = remote_source
+
+        allow(Dir).to receive(:mktmpdir).and_return(tmpdir)
+      end
+
+      it "should call installpkg if a flat pkg file is found instead of a .dmg image" do
+        expect(described_class).to receive(:curl) do |*args|
+          expect(args).to include(tmpfile)
+          expect(args).to include(remote_source)
+        end
+        expect(provider.class).to receive(:installpkg).with(tmpfile, 'testpkg', remote_source)
+        provider.install
+      end
+    end
+  end
+end