puppet 4.7.1-universal-darwin → 4.8.0-universal-darwin

data/spec/unit/pops/types/type_parser_spec.rb

@@ -111,6 +111,16 @@ describe TypeParser do
     expect(the_type_parsed_from(opt_t)).to be_the_type(opt_t)
   end
 
+  it "parses timespan type" do
+    timespan_t = types.timespan
+    expect(the_type_parsed_from(timespan_t)).to be_the_type(timespan_t)
+  end
+
+  it "parses timestamp type" do
+    timestamp_t = types.timestamp
+    expect(the_type_parsed_from(timestamp_t)).to be_the_type(timestamp_t)
+  end
+
   it "parses tuple type" do
     tuple_t = types.tuple([Integer, String])
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
@@ -248,6 +258,38 @@ describe TypeParser do
    expect(parser.parse("Collection[1,2]")).to be_the_type(types.collection(types.range(1,2)))
   end
 
+  it 'parses a timespan type' do
+    expect(parser.parse("Timespan")).to be_the_type(types.timespan)
+  end
+
+  it 'parses a timespan type with a lower bound' do
+    expect(parser.parse("Timespan[{hours => 3}]")).to be_the_type(types.timespan({'hours' => 3}))
+  end
+
+  it 'parses a timespan type with an upper bound' do
+    expect(parser.parse("Timespan[default, {hours => 9}]")).to be_the_type(types.timespan(nil, {'hours' => 9}))
+  end
+
+  it 'parses a timespan type with both lower and upper bounds' do
+    expect(parser.parse("Timespan[{hours => 3}, {hours => 9}]")).to be_the_type(types.timespan({'hours' => 3}, {'hours' => 9}))
+  end
+
+  it 'parses a timestamp type' do
+    expect(parser.parse("Timestamp")).to be_the_type(types.timestamp)
+  end
+
+  it 'parses a timestamp type with a lower bound' do
+    expect(parser.parse("Timestamp['2014-12-12T13:14:15 CET']")).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET'))
+  end
+
+  it 'parses a timestamp type with an upper bound' do
+    expect(parser.parse("Timestamp[default, '2014-12-12T13:14:15 CET']")).to be_the_type(types.timestamp(nil, '2014-12-12T13:14:15 CET'))
+  end
+
+  it 'parses a timestamp type with both lower and upper bounds' do
+    expect(parser.parse("Timestamp['2014-12-12T13:14:15 CET', '2016-08-23T17:50:00 CET']")).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET', '2016-08-23T17:50:00 CET'))
+  end
+
   it 'parses a type type' do
     expect(parser.parse("Type[Integer]")).to be_the_type(types.type_type(types.integer))
   end
@@ -257,25 +299,57 @@ describe TypeParser do
   end
 
   it 'parses a callable type' do
-    expect(parser.parse("Callable")).to be_the_type(types.all_callables())
+    t = parser.parse("Callable")
+    expect(t).to be_the_type(types.all_callables())
+    expect(t.return_type).to be_nil
   end
 
   it 'parses a parameterized callable type' do
-    expect(parser.parse("Callable[String, Integer]")).to be_the_type(types.callable(String, Integer))
+    t = parser.parse("Callable[String, Integer]")
+    expect(t).to be_the_type(types.callable(String, Integer))
+    expect(t.return_type).to be_nil
   end
 
   it 'parses a parameterized callable type with min/max' do
-    expect(parser.parse("Callable[String, Integer, 1, default]")).to be_the_type(types.callable(String, Integer, 1, :default))
+    t = parser.parse("Callable[String, Integer, 1, default]")
+    expect(t).to be_the_type(types.callable(String, Integer, 1, :default))
+    expect(t.return_type).to be_nil
   end
 
   it 'parses a parameterized callable type with block' do
-    expect(parser.parse("Callable[String, Callable[Boolean]]")).to be_the_type(types.callable(String, types.callable(true)))
+    t = parser.parse("Callable[String, Callable[Boolean]]")
+    expect(t).to be_the_type(types.callable(String, types.callable(true)))
+    expect(t.return_type).to be_nil
+  end
+
+  it 'parses a callable with no parameters and return type' do
+    expect(parser.parse("Callable[[],Float]")).to be_the_type(types.callable([],Float))
+  end
+
+  it 'parses a parameterized callable type with return type' do
+    expect(parser.parse("Callable[[String, Integer],Float]")).to be_the_type(types.callable([String, Integer],Float))
+  end
+
+  it 'parses a parameterized callable type with min/max and return type' do
+    expect(parser.parse("Callable[[String, Integer, 1, default],Float]")).to be_the_type(types.callable([String, Integer, 1, :default], Float))
+  end
+
+  it 'parses a parameterized callable type with block and return type' do
+    expect(parser.parse("Callable[[String, Callable[Boolean]],Float]")).to be_the_type(types.callable([String, types.callable(true)], Float))
   end
 
   it 'parses a parameterized callable type with 0 min/max' do
     t = parser.parse("Callable[0,0]")
     expect(t).to be_the_type(types.callable(0,0))
     expect(t.param_types.types).to be_empty
+    expect(t.return_type).to be_nil
+  end
+
+  it 'parses a parameterized callable type with 0 min/max and return_type' do
+    t = parser.parse("Callable[[0,0],Float]")
+    expect(t).to be_the_type(types.callable([0,0],Float))
+    expect(t.param_types.types).to be_empty
+    expect(t.return_type).to be_the_type(types.float)
   end
 
   it 'parses a parameterized callable type with >0 min/max' do
@@ -283,6 +357,15 @@ describe TypeParser do
     expect(t).to be_the_type(types.callable(0,1))
     # Contains a Unit type to indicate "called with what you accept"
     expect(t.param_types.types[0]).to be_the_type(PUnitType.new())
+    expect(t.return_type).to be_nil
+  end
+
+  it 'parses a parameterized callable type with >0 min/max and a return type' do
+    t = parser.parse("Callable[[0,1],Float]")
+    expect(t).to be_the_type(types.callable([0,1], Float))
+    # Contains a Unit type to indicate "called with what you accept"
+    expect(t.param_types.types[0]).to be_the_type(PUnitType.new())
+    expect(t.return_type).to be_the_type(types.float)
   end
 
   it 'parses all known literals' do

data/spec/unit/pops/types/types_spec.rb

@@ -440,7 +440,7 @@ describe 'Puppet Type System' do
       type Foo = Variant[Foo,String,Integer]
       assert_type(Foo, /x/)
       CODE
-      expect { eval_and_collect_notices(code) }.to raise_error(/expected a value of type String or Integer, got Regexp/)
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a value of type String or Integer, got Regexp/)
     end
 
     it 'will handle a scalar correctly in combinations of nested aliased variants' do

data/spec/unit/pops/validator/validator_spec.rb

@@ -440,6 +440,29 @@ describe "validating 4x" do
       end
     end
 
+    context 'that are functions' do
+      it 'accepts typed parameters' do
+        source = <<-CODE
+          function f(Integer $a) { $a }
+        CODE
+        expect(validate(parse(source))).not_to have_any_issues
+      end
+
+      it 'accepts return types' do
+        source = <<-CODE
+          function f() >> Integer { 42 }
+        CODE
+        expect(validate(parse(source))).not_to have_any_issues
+      end
+
+      it 'accepts block with return types' do
+        source = <<-CODE
+          map([1,2]) |Integer $x| >> Integer { $x + 3 }
+        CODE
+        expect(validate(parse(source))).not_to have_any_issues
+      end
+    end
+
     context 'that are type mappings' do
       it 'accepts a valid type mapping expression' do
         source = <<-CODE

data/spec/unit/provider/mount/parsed_spec.rb

@@ -115,6 +115,7 @@ FSTAB
   describe "mountinstances" do
     it "should get name from mountoutput found on Solaris" do
       Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+      Facter.stubs(:value).with(:kernel).returns 'SunOS'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('solaris.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(6)
@@ -128,6 +129,7 @@ FSTAB
 
     it "should get name from mountoutput found on HP-UX" do
       Facter.stubs(:value).with(:osfamily).returns 'HP-UX'
+      Facter.stubs(:value).with(:kernel).returns 'HP-UX'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('hpux.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(17)
@@ -150,32 +152,35 @@ FSTAB
       expect(mounts[16]).to eq({ :name => '/ghost', :mounted => :yes })
     end
 
-    it "should get name from mountoutput found on Darwin" do
+    it "should get name and mount options from mountoutput found on Darwin" do
       Facter.stubs(:value).with(:osfamily).returns 'Darwin'
+      Facter.stubs(:value).with(:kernel).returns 'Darwin'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('darwin.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(6)
-      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
-      expect(mounts[1]).to eq({ :name => '/dev', :mounted => :yes })
-      expect(mounts[2]).to eq({ :name => '/net', :mounted => :yes })
-      expect(mounts[3]).to eq({ :name => '/home', :mounted => :yes })
-      expect(mounts[4]).to eq({ :name => '/usr', :mounted => :yes })
-      expect(mounts[5]).to eq({ :name => '/ghost', :mounted => :yes })
+      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes, :live_options=>"hfs, local, journaled"})
+      expect(mounts[1]).to eq({ :name => '/dev', :mounted => :yes, :live_options=>"devfs, local, nobrowse"})
+      expect(mounts[2]).to eq({ :name => '/net', :mounted => :yes, :live_options=>"autofs, nosuid, automounted, nobrowse"})
+      expect(mounts[3]).to eq({ :name => '/home', :mounted => :yes, :mounted=>:yes, :live_options=>"autofs, automounted, nobrowse"})
+      expect(mounts[4]).to eq({ :name => '/usr', :mounted => :yes, :mounted=>:yes, :live_options=>"hfs, local, journaled"})
+      expect(mounts[5]).to eq({ :name => '/ghost', :mounted => :yes, :live_options => "hfs, local, journaled"})
     end
 
-    it "should get name from mountoutput found on Linux" do
+    it "should get name and mount options from mountoutput found on Linux" do
       Facter.stubs(:value).with(:osfamily).returns 'Gentoo'
+      Facter.stubs(:value).with(:kernel).returns 'Linux'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('linux.mount')))
       mounts = described_class.mountinstances
-      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
-      expect(mounts[1]).to eq({ :name => '/lib64/rc/init.d', :mounted => :yes })
-      expect(mounts[2]).to eq({ :name => '/sys', :mounted => :yes })
-      expect(mounts[3]).to eq({ :name => '/usr/portage', :mounted => :yes })
-      expect(mounts[4]).to eq({ :name => '/ghost', :mounted => :yes })
+      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes, :live_options=>"rw,noatime"})
+      expect(mounts[1]).to eq({ :name => '/lib64/rc/init.d', :mounted => :yes, :live_options => "rw,nosuid,nodev,noexec,relatime,size=1024k,mode=755" })
+      expect(mounts[2]).to eq({ :name => '/sys', :mounted => :yes, :live_options => "rw,nosuid,nodev,noexec,relatime"})
+      expect(mounts[3]).to eq({ :name => '/usr/portage', :mounted => :yes, :live_options => "rw" })
+      expect(mounts[4]).to eq({ :name => '/ghost', :mounted => :yes, :live_options => "rw" })
     end
 
     it "should get name from mountoutput found on AIX" do
       Facter.stubs(:value).with(:osfamily).returns 'AIX'
+      Facter.stubs(:value).with(:kernel).returns 'AIX'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
       mounts = described_class.mountinstances
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
@@ -224,29 +229,42 @@ FSTAB
           platform != 'solaris' or
             skip "We need to stub the operatingsystem fact at load time, but can't"
         end
-
-        # Stub the mount output to our fixture.
-        begin
-          mount = my_fixture(platform + '.mount')
-          described_class.stubs(:mountcmd).returns File.read(mount)
-        rescue
-          skip "is #{platform}.mount missing at this point?"
-        end
-
-        # Note: we have to stub default_target before creating resources
-        # because it is used by Puppet::Type::Mount.new to populate the
-        # :target property.
-        described_class.stubs(:default_target).returns fstab
-        @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
       end
 
       # Following mountpoint are present in all fstabs/mountoutputs
       describe "on other platforms than Solaris", :if => Facter.value(:osfamily) != 'Solaris' do
-        it "should include unmounted resources" do
+        before :each do
+          # Stub the mount output to our fixture.
+          begin
+            mount = my_fixture(platform + '.mount')
+            described_class.stubs(:mountcmd).returns File.read(mount)
+          rescue
+            skip "is #{platform}.mount missing at this point?"
+          end
+
+          # Note: we have to stub default_target before creating resources
+          # because it is used by Puppet::Type::Mount.new to populate the
+          # :target property.
+          described_class.stubs(:default_target).returns fstab
+
+          platforms = {
+            'linux' => ['Gentoo', 'Linux'],
+            'freebsd' => ['BSD', 'BSD'],
+            'openbsd' => ['BSD', 'BSD'],
+            'netbsd' => ['BSd', 'BSD']
+          }
+          Facter.stubs(:value).with(:osfamily).returns(platforms[platform][0])
+          Facter.stubs(:value).with(:kernel).returns(platforms[platform][1])
+
+          @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
+        end
+        
+        it "should include mounted resources" do
           expect(@retrieve).to include(:name => '/', :ensure => :mounted)
         end
 
-        it "should include mounted resources" do
+        it "should include unmounted resources" do
+        @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
           expect(@retrieve).to include(:name => '/boot', :ensure => :unmounted)
         end
 

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

@@ -201,105 +201,115 @@ describe Puppet::Type.type(:package).provider(:pkg) do
     end
 
     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
-        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'
-        $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', '-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', '-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 downgrade to specific version" do
-        resource[:ensure] = '0.0.7'
-        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', '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})
-        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 ''
-        $CHILD_STATUS.stubs(:exitstatus).returns 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
-        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)
+      [
+        { :osrel => '11.0', :flags => ['--accept'] },
+        { :osrel => '11.2', :flags => ['--accept', '--sync-actuators-timeout', '900'] },
+      ].each do |hash|
+        context "with :operatingsystemrelease #{hash[:osrel]}" do
+          before :each do
+            Facter.stubs(:value).with(:operatingsystemrelease).returns hash[:osrel]
+          end
+          it "should accept all licenses" do
+            provider.expects(:query).with().returns({:ensure => :absent})
+            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', *hash[:flags], '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
+            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'
+            $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', '-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', *hash[:flags], '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', '-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', *hash[:flags], 'dummy@0.0.8'], {:failonfail => false, :combine => true}).returns ''
+            $CHILD_STATUS.stubs(:exitstatus).returns 0
+            provider.install
+          end
+
+          it "should downgrade to specific version" do
+            resource[:ensure] = '0.0.7'
+            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', 'update', *hash[:flags], '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', *hash[:flags], '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})
+            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
+            $CHILD_STATUS.stubs(:exitstatus).returns 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
+            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', *hash[:flags], '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', *hash[:flags], '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
       end
     end