puppet 6.4.2-x86-mingw32 → 6.4.3-x86-mingw32

data/spec/unit/application/ssl_spec.rb

@@ -106,6 +106,11 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
 
     it_behaves_like 'an ssl action'
 
+    it 'registers OIDs' do
+      expect(Puppet::SSL::Oids).to receive(:register_puppet_oids)
+      expects_command_to_fail(%r{Failed to submit certificate request})
+    end
+
     it 'submits the CSR and saves it locally' do
       stub_request(:put, %r{puppet-ca/v1/certificate_request/#{name}}).to_return(status: 200)
       stub_request(:get, %r{puppet-ca/v1/certificate/#{name}}).to_return(status: 404)
@@ -366,6 +371,14 @@ describe Puppet::Application::Ssl, unless: Puppet::Util::Platform.jruby? do
       ssl.command_line.args << 'bootstrap'
     end
 
+    it 'registers the OIDs' do
+      expect_any_instance_of(Puppet::SSL::StateMachine).to receive(:ensure_client_certificate).and_return(
+        double('ssl_context')
+      )
+      expect(Puppet::SSL::Oids).to receive(:register_puppet_oids)
+      expects_command_to_pass
+    end
+
     it 'returns an SSLContext with the loaded CA certs, CRLs, private key and client cert' do
       expect_any_instance_of(Puppet::SSL::StateMachine).to receive(:ensure_client_certificate).and_return(
         double('ssl_context')

data/spec/unit/configurer_spec.rb

@@ -1005,7 +1005,7 @@ describe Puppet::Configurer do
       @agent.run :catalog => catalog
     end
 
-    it "should select a server when provided" do
+    it "should select a server when it receives 200 OK response" do
       Puppet.settings[:server_list] = ["myserver:123"]
       response = Net::HTTPOK.new(nil, 200, 'OK')
       allow(Puppet::Network::HttpPool).to receive(:connection).with('myserver', 123, anything).and_return(double('request', get: response))

data/spec/unit/functions/new_spec.rb

@@ -174,6 +174,19 @@ describe 'the new function' do
           )).to have_resource("Notify[Integer, #{result}]")
         end
       end
+
+      { '0x0G'  => :error,
+        '08'    => :error,
+        '10F'   => :error,
+        '0B2'   => :error,
+      }.each do |str, result|
+        it "errors when given a non Integer compliant string '#{str}'" do
+          expect{compile_to_catalog(<<-"MANIFEST"
+            $x = Integer.new("#{str}")
+          MANIFEST
+        )}.to raise_error(Puppet::Error, /invalid value|cannot be converted to Integer/)
+        end
+      end
     end
 
     context "when radix is explicitly set to 'default' it" do
@@ -307,6 +320,8 @@ describe 'the new function' do
       { "10"     => 10,
         "010"    => 10,
         "00010"  => 10,
+        "08"     => 8,
+        "0008"   => 8,
       }.each do |str, result|
         it "produces #{result} from the string '#{str}'" do
           expect(compile_to_catalog(<<-"MANIFEST"

data/spec/unit/hiera/scope_spec.rb

@@ -90,4 +90,11 @@ describe Hiera::Scope do
       expect(scope.include?("calling_module")).to eq(true)
     end
   end
+
+  describe "#call_function" do
+    it "should delegate a call to call_function to the real scope" do
+      expect(real).to receive(:call_function).once
+      scope.call_function('some_function', [1,2,3])
+    end
+  end
 end

data/spec/unit/network/http/factory_spec.rb

@@ -102,6 +102,12 @@ describe Puppet::Network::HTTP::Factory do
     expect(conn.keep_alive_timeout).to eq(2147483647)
   end
 
+  it "disables ruby's max retry on 2.5 and up", if: RUBY_VERSION.to_f >= 2.5 do
+    conn = create_connection(site)
+
+    expect(conn.max_retries).to eq(0)
+  end
+
   context 'source address' do
     it 'defaults to system-defined' do
       conn = create_connection(site)

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

@@ -221,19 +221,30 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
       allow(Tempfile).to receive(:open).and_yield(tempfile)
     end
 
-    it "installs first if holding" do
+    it "installs first if package is not present and ensure holding" do
+
       allow(provider).to receive(:execute)
+      allow(provider).to receive(:package_not_installed?).and_return(true)
       expect(provider).to receive(:install).once
       provider.hold
     end
 
+    it "skips install new package if package is allready installed" do
+      allow(provider).to receive(:execute)
+      allow(provider).to receive(:package_not_installed?).and_return(false)
+      expect(provider).not_to receive(:install)
+      provider.hold
+    end
+
     it "executes dpkg --set-selections when holding" do
+      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
 
     it "executes dpkg --set-selections when unholding" do
+      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
@@ -275,4 +286,10 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     expect(provider).to receive(:dpkg).with("--purge", resource_name)
     provider.purge
   end
+
+  it "raises error if package name is nil" do
+    expect {provider.package_not_installed?(nil)}.to raise_error(ArgumentError,"Package name is nil or empty")
+    expect {provider.package_not_installed?("")}.to raise_error(ArgumentError,"Package name is nil or empty")
+  end
 end
+

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

@@ -2,7 +2,15 @@ require 'spec_helper'
 
 context Puppet::Type.type(:package).provider(:gem) do
 
+  it { is_expected.to be_installable }
+  it { is_expected.to be_uninstallable }
+  it { is_expected.to be_upgradeable }
+  it { is_expected.to be_versionable }
+  it { is_expected.to be_install_options }
+  it { is_expected.to be_targetable }
+
   let(:provider_gem_cmd) { '/provider/gem' }
+  let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
 
   context 'installing myresource' do
     let(:resource) do
@@ -18,8 +26,6 @@ context Puppet::Type.type(:package).provider(:gem) do
       provider
     end
 
-    let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
-
     before :each do
       resource.provider = provider
       allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
@@ -31,45 +37,45 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should use the path to the gem command" do
-        allow(described_class).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
+        allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
         expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return("")
         provider.install
       end
 
       it "should specify that the gem is being installed" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[0]).to eq("install") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[0]).to eq("install") }.and_return("")
         provider.install
       end
 
       it "should specify that --rdoc should not be included when gem version is < 2.0.0" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[1]).to eq("--no-rdoc") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--no-rdoc") }.and_return("")
         provider.install
       end
 
       it "should specify that --ri should not be included when gem version is < 2.0.0" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[2]).to eq("--no-ri") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[2]).to eq("--no-ri") }.and_return("")
         provider.install
       end
 
       it "should specify that --document should not be included when gem version is >= 2.0.0" do
         allow(provider).to receive(:rubygem_version).and_return('2.0.0')
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[1]).to eq("--no-document") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--no-document") }.and_return("")
         provider.install
       end
 
       it "should specify the package name" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("myresource") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[3]).to eq("myresource") }.and_return("")
         provider.install
       end
 
       it "should not append install_options by default" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args.length).to eq(4) }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args.length).to eq(4) }.and_return("")
         provider.install
       end
 
       it "should allow setting an install_options parameter" do
         resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) do |args|
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) do |cmd, args|
           expect(args[1]).to eq('--force')
           expect(args[2]).to eq('--bindir=/usr/bin')
         end.and_return("")
@@ -80,7 +86,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a normal file" do
           it "should use the file name instead of the gem name" do
             resource[:source] = "/my/file"
-            expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("/my/file") }.and_return("")
+            expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, array_including("/my/file")).and_return("")
             provider.install
           end
         end
@@ -88,7 +94,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a file url" do
           it "should use the file name instead of the gem name" do
             resource[:source] = "file:///my/file"
-            expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("/my/file") }.and_return("")
+            expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, array_including("/my/file")).and_return("")
             provider.install
           end
         end
@@ -103,7 +109,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a non-file and non-puppet url" do
           it "should treat the source as a gem repository" do
             resource[:source] = "http://host/my/file"
-            expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3..5]).to eq(["--source", "http://host/my/file", "myresource"]) }.and_return("")
+            expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[3..5]).to eq(["--source", "http://host/my/file", "myresource"]) }.and_return("")
             provider.install
           end
         end
@@ -111,7 +117,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         context "as a windows path on windows", :if => Puppet::Util::Platform.windows? do
           it "should treat the source as a local path" do
             resource[:source] = "c:/this/is/a/path/to/a/gem.gem"
-            expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("c:/this/is/a/path/to/a/gem.gem") }.and_return("")
+            expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, array_including("c:/this/is/a/path/to/a/gem.gem")).and_return("")
             provider.install
           end
         end
@@ -131,7 +137,7 @@ context Puppet::Type.type(:package).provider(:gem) do
         #gemlist is used for retrieving both local and remote version numbers, and there are cases
         # (particularly local) where it makes sense for it to return an array.  That doesn't make
         # sense for '#latest', though.
-        expect(provider.class).to receive(:gemlist).with({:justme => 'myresource'}).and_return({
+        expect(provider.class).to receive(:gemlist).with({:command => provider_gem_cmd, :justme => 'myresource'}).and_return({
           :name     => 'myresource',
           :ensure   => ["3.0"],
           :provider => :gem,
@@ -142,7 +148,7 @@ context Puppet::Type.type(:package).provider(:gem) do
       it "should list from the specified source repository" do
         resource[:source] = "http://foo.bar.baz/gems"
         expect(provider.class).to receive(:gemlist).
-          with({:justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
+          with({:command => provider_gem_cmd, :justme => 'myresource', :source => "http://foo.bar.baz/gems"}).
           and_return({
             :name     => 'myresource',
             :ensure   => ["3.0"],
@@ -158,67 +164,67 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
 
       it "should return an empty array when no gems installed" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return("\n")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return("\n")
         expect(described_class.instances).to eq([])
       end
 
       it "should return ensure values as an array of installed versions" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
         systemu (1.2.0)
         vagrant (0.8.7, 0.6.9)
         HEREDOC
 
         expect(described_class.instances.map {|p| p.properties}).to eq([
-          {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
-          {:ensure => ["0.8.7", "0.6.9"], :provider => :gem, :name => 'vagrant'}
+          {:name => "systemu", :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.2.0"]},
+          {:name => "vagrant", :provider => :gem, :command => provider_gem_cmd, :ensure => ["0.8.7", "0.6.9"]}
         ])
       end
 
       it "should ignore platform specifications" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
         systemu (1.2.0)
         nokogiri (1.6.1 ruby java x86-mingw32 x86-mswin32-60, 1.4.4.1 x86-mswin32)
         HEREDOC
 
         expect(described_class.instances.map {|p| p.properties}).to eq([
-          {:ensure => ["1.2.0"],          :provider => :gem, :name => 'systemu'},
-          {:ensure => ["1.6.1", "1.4.4.1"], :provider => :gem, :name => 'nokogiri'}
+          {:name => "systemu",  :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.2.0"]},
+          {:name => "nokogiri", :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.6.1", "1.4.4.1"]}
         ])
       end
 
       it "should not list 'default: ' text from rubygems''" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(<<-HEREDOC.gsub(/        /, ''))
         bundler (1.16.1, default: 1.16.0, 1.15.1)
         HEREDOC
 
         expect(described_class.instances.map {|p| p.properties}).to eq([
-          {:name => 'bundler', :ensure => ["1.16.1", "1.16.0", "1.15.1"], :provider => :gem}
+          {:name => "bundler", :provider => :gem, :command => provider_gem_cmd, :ensure => ["1.16.1", "1.16.0", "1.15.1"]}
         ])
       end
 
       it "should not fail when an unmatched line is returned" do
-        expect(described_class).to receive(:execute_gem_command).with(%w{list --local}).and_return(File.read(my_fixture('line-with-1.8.5-warning')))
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{list --local}).and_return(File.read(my_fixture('line-with-1.8.5-warning')))
 
         expect(described_class.instances.map {|p| p.properties}).
-          to eq([{provider: :gem, ensure: ["0.3.2"],    name: "columnize"},
-                 {provider: :gem, ensure: ["1.1.3"],    name: "diff-lcs"},
-                 {provider: :gem, ensure: ["0.0.1"],    name: "metaclass"},
-                 {provider: :gem, ensure: ["0.10.5"],   name: "mocha"},
-                 {provider: :gem, ensure: ["0.8.7"],    name: "rake"},
-                 {provider: :gem, ensure: ["2.9.0"],    name: "rspec-core"},
-                 {provider: :gem, ensure: ["2.9.1"],    name: "rspec-expectations"},
-                 {provider: :gem, ensure: ["2.9.0"],    name: "rspec-mocks"},
-                 {provider: :gem, ensure: ["0.9.0"],    name: "rubygems-bundler"},
-                 {provider: :gem, ensure: ["1.11.3.3"], name: "rvm"}])
+          to eq([{:name=>"columnize",          :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.3.2"]},
+                 {:name=>"diff-lcs",           :provider=>:gem, :command => provider_gem_cmd, :ensure=>["1.1.3"]},
+                 {:name=>"metaclass",          :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.0.1"]},
+                 {:name=>"mocha",              :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.10.5"]},
+                 {:name=>"rake",               :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.8.7"]},
+                 {:name=>"rspec-core",         :provider=>:gem, :command => provider_gem_cmd, :ensure=>["2.9.0"]},
+                 {:name=>"rspec-expectations", :provider=>:gem, :command => provider_gem_cmd, :ensure=>["2.9.1"]},
+                 {:name=>"rspec-mocks",        :provider=>:gem, :command => provider_gem_cmd, :ensure=>["2.9.0"]},
+                 {:name=>"rubygems-bundler",   :provider=>:gem, :command => provider_gem_cmd, :ensure=>["0.9.0"]},
+                 {:name=>"rvm",                :provider=>:gem, :command => provider_gem_cmd, :ensure=>["1.11.3.3"]}])
       end
     end
 
     context "listing gems" do
       context "searching for a single package" do
         it "searches for an exact match" do
-          expect(described_class).to receive(:execute_gem_command).with(include('\Abundler\z')).and_return(File.read(my_fixture('gem-list-single-package')))
-          expected = {:name => 'bundler', :ensure => %w[1.6.2], :provider => :gem}
-          expect(described_class.gemlist({:justme => 'bundler'})).to eq(expected)
+          expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, array_including('\Abundler\z')).and_return(File.read(my_fixture('gem-list-single-package')))
+          expected = {:name=>"bundler", :provider=>:gem, :ensure=>["1.6.2"]}
+          expect(described_class.gemlist({:command => provider_gem_cmd, :justme => 'bundler'})).to eq(expected)
         end
       end
     end
@@ -294,6 +300,39 @@ context Puppet::Type.type(:package).provider(:gem) do
     end
   end
 
+  context 'installing myresource with a target command' do
+    let(:resource_gem_cmd) { '/resource/gem' }
+
+    let(:resource) do
+      Puppet::Type.type(:package).new(
+        :name     => "myresource",
+        :ensure   => :installed,
+      )
+    end
+
+    let(:provider) do
+      provider = described_class.new
+      provider.resource = resource
+      provider
+    end
+
+    before :each do
+      resource.provider = provider
+    end
+
+    context "when installing with a target command" do
+      before :each do
+        allow(described_class).to receive(:which).with(resource_gem_cmd).and_return(resource_gem_cmd)
+      end
+
+      it "should use the path to the other gem" do
+        resource::original_parameters[:command] = resource_gem_cmd
+        expect(described_class).to receive(:execute_gem_command).with(resource_gem_cmd, be_a(Array)).twice.and_return("")
+        provider.install
+      end
+    end
+  end
+
   context 'uninstalling myresource' do
     let(:resource) do
       Puppet::Type.type(:package).new(
@@ -308,8 +347,6 @@ context Puppet::Type.type(:package).provider(:gem) do
       provider
     end
 
-    let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
-
     before :each do
       resource.provider = provider
       allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
@@ -317,39 +354,39 @@ context Puppet::Type.type(:package).provider(:gem) do
 
     context "when uninstalling" do
       it "should use the path to the gem command" do
-        allow(described_class).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
+        allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
         expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return("")
         provider.uninstall
       end
 
       it "should specify that the gem is being uninstalled" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[0]).to eq("uninstall") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[0]).to eq("uninstall") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that the relevant executables should be removed without confirmation" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[1]).to eq("--executables") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[1]).to eq("--executables") }.and_return("")
         provider.uninstall
       end
 
       it "should specify that all the matching versions should be removed" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[2]).to eq("--all") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[2]).to eq("--all") }.and_return("")
         provider.uninstall
       end
 
       it "should specify the package name" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args[3]).to eq("myresource") }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args[3]).to eq("myresource") }.and_return("")
         provider.uninstall
       end
 
       it "should not append uninstall_options by default" do
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) { |args| expect(args.length).to eq(4) }.and_return("")
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) { |cmd, args| expect(args.length).to eq(4) }.and_return("")
         provider.uninstall
       end
 
       it "should allow setting an uninstall_options parameter" do
         resource[:uninstall_options] = [ '--ignore-dependencies', {'--version' => '0.1.1' } ]
-        expect(described_class).to receive(:execute_gem_command).with(be_a(Array)) do |args|
+        expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, be_a(Array)) do |cmd, args|
           expect(args[4]).to eq('--ignore-dependencies')
           expect(args[5]).to eq('--version=0.1.1')
         end.and_return('')
@@ -357,4 +394,20 @@ context Puppet::Type.type(:package).provider(:gem) do
       end
     end
   end
+
+  context 'calculated specificity' do
+    context 'when is not defaultfor' do
+      subject { described_class.specificity }
+      it { is_expected.to eql 1 }
+    end
+
+    context 'when is defaultfor' do
+      let(:os) {  Facter.value(:operatingsystem) }
+      subject do
+        described_class.defaultfor(operatingsystem: os)
+        described_class.specificity
+      end
+      it { is_expected.to be > 100 }
+    end
+  end
 end