puppet 6.0.9-x86-mingw32 → 6.0.10-x86-mingw32

data/spec/integration/util/windows/user_spec.rb

@@ -106,6 +106,12 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
     end
 
     describe "logon_user" do
+      let(:fLOGON32_PROVIDER_DEFAULT) {0}
+      let(:fLOGON32_LOGON_INTERACTIVE) {2}
+      let(:fLOGON32_LOGON_NETWORK) {3}
+      let(:token) {'test'}
+      let(:user) {'test'}
+      let(:passwd) {'test'}
       it "should raise an error when provided with an incorrect username and password" do
         expect_logon_failure_error {
           Puppet::Util::Windows::User.logon_user(username, bad_password)
@@ -117,8 +123,21 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
           Puppet::Util::Windows::User.logon_user(username, nil)
         }
       end
+
+      it 'should raise error given that logon returns false' do
+
+        allow(Puppet::Util::Windows::User).to receive(:logon_user_by_logon_type).with(
+            user, passwd, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, anything).and_return (0)
+        allow(Puppet::Util::Windows::User).to receive(:logon_user_by_logon_type).with(
+            user, passwd, fLOGON32_LOGON_INTERACTIVE, fLOGON32_PROVIDER_DEFAULT, anything).and_return(0)
+
+        expect {Puppet::Util::Windows::User.logon_user(user, passwd) {}}
+            .to raise_error(Puppet::Util::Windows::Error, /Failed to logon user/)
+
+      end
     end
 
+
     describe "password_is?" do
       it "should return false given an incorrect username and password" do
         expect(Puppet::Util::Windows::User.password_is?(username, bad_password)).to be_falsey

data/spec/lib/puppet_spec/https.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+require 'webrick'
+
+class PuppetSpec::HTTPSServer
+  attr_reader :ca_cert, :ca_crl, :server_cert, :server_key
+
+  def initialize
+    @ca_cert = OpenSSL::X509::Certificate.new(CA_CERT)
+    @ca_crl = OpenSSL::X509::CRL.new(CRL)
+    @server_key = OpenSSL::PKey::RSA.new(SERVER_KEY)
+    @server_cert = OpenSSL::X509::Certificate.new(SERVER_CERT)
+    @config = WEBrick::Config::HTTP.dup
+  end
+
+  def handle_request(ctx, ssl)
+    req = WEBrick::HTTPRequest.new(@config)
+    req.parse(ssl)
+
+    res = WEBrick::HTTPResponse.new(@config)
+    res.status = 200
+    res.body = 'OK'
+    res.send_response(ssl)
+  end
+
+  def start_server(&block)
+    errors = []
+
+    IO.pipe {|stop_pipe_r, stop_pipe_w|
+      store = OpenSSL::X509::Store.new
+      store.add_cert(@ca_cert)
+      store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.cert_store = store
+      ctx.cert = @server_cert
+      ctx.key = @server_key
+      ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      Socket.do_not_reverse_lookup = true
+      tcps = TCPServer.new("127.0.0.1", 0)
+      begin
+        port = tcps.connect_address.ip_port
+        begin
+          server_thread = Thread.new do
+            begin
+              ssls = OpenSSL::SSL::SSLServer.new(tcps, ctx)
+              ssls.start_immediately = true
+
+              loop do
+                readable, = IO.select([ssls, stop_pipe_r])
+                break if readable.include? stop_pipe_r
+
+                ssl = ssls.accept
+                begin
+                  handle_request(ctx, ssl)
+                ensure
+                  ssl.close
+                end
+              end
+            rescue => e
+              # uncomment this line if something goes wrong
+              # puts "SERVER #{e.message}"
+              errors << e
+            end
+          end
+
+          begin
+            yield port
+          ensure
+            stop_pipe_w.close
+          end
+        ensure
+          server_thread.join
+        end
+      ensure
+        tcps.close
+      end
+    }
+
+    errors
+  end
+
+CA_CERT = <<END
+-----BEGIN CERTIFICATE-----
+MIICMjCCAZugAwIBAgIBADANBgkqhkiG9w0BAQsFADASMRAwDgYDVQQDDAdUZXN0
+IENBMB4XDTcwMDEwMTAwMDAwMFoXDTI5MDMwMTIxMzgxMVowEjEQMA4GA1UEAwwH
+VGVzdCBDQTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAvPbXy4tgmUZsLx39
+Q7/Fuo5cOVk9yNzwMN4000jZQjAC8DQKXSDkbJ/6MmaiRo+VgwWlEIRVttYjrXF/
+YPKZowbEIaggc9uK96+HLiGiZ0H6rNM7DYsJiCX4OzJ91SOx9qsyJbyNxLbf+IP0
+961sTQhsRaqLn8vsn8Mv9I87eHsCAwEAAaOBlzCBlDAPBgNVHRMBAf8EBTADAQH/
+MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUlJ+BUoL64NmMn+IAgiLokQqr0zcw
+MQYJYIZIAYb4QgENBCQWIlB1cHBldCBTZXJ2ZXIgSW50ZXJuYWwgQ2VydGlmaWNh
+dGUwHwYDVR0jBBgwFoAUlJ+BUoL64NmMn+IAgiLokQqr0zcwDQYJKoZIhvcNAQEL
+BQADgYEAbIca4hMdGmQvLOnNIQJ+PaMsIQ9ZT6dr+NCvIf1Ass1dEr0qRy7tpyP0
+scgYmnIrOHDoe+ecyvEuG1oDb/6wLCGzD4OJXRsOzqsSCZJ31HkmDircQGpd+XbR
+BxqltBWaWmSBH+e64Himc1HbHRq5xb8JFRMK9dSqiF3DrREMN/A=
+-----END CERTIFICATE-----
+END
+
+CRL = <<END
+-----BEGIN X509 CRL-----
+MIIBCjB1AgEBMA0GCSqGSIb3DQEBCwUAMBIxEDAOBgNVBAMMB1Rlc3QgQ0EXDTcw
+MDEwMTAwMDAwMFoXDTI5MDMwMTIxMzgxMVqgLzAtMB8GA1UdIwQYMBaAFJSfgVKC
++uDZjJ/iAIIi6JEKq9M3MAoGA1UdFAQDAgEAMA0GCSqGSIb3DQEBCwUAA4GBAK/r
+2fz+PGgDzu85Od5Tp6jH+3Ons5WURxZzpfveGcG5fgRIG274E5Q1z+Aoj9KW/J5V
+6FPbuoVEpykTicKKQaALHfryOEaLqIbTPu+94AivOx9RxzHhYPrblvjuDkmVf+fp
+O3/6YKoeOom3FP/ftKdcsx7tGXy8UxCMUaBGVb5J
+-----END X509 CRL-----
+END
+
+SERVER_CERT = <<END
+-----BEGIN CERTIFICATE-----
+MIIBvzCCASigAwIBAgIBAzANBgkqhkiG9w0BAQsFADASMRAwDgYDVQQDDAdUZXN0
+IENBMB4XDTcwMDEwMTAwMDAwMFoXDTI5MDMwMTIxMzgxMVowFDESMBAGA1UEAwwJ
+MTI3LjAuMC4xMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDRTWFUYiB9TnI/
+ByjHHWnjnA02ieuczgAgI5CzrlrQCbCiogmsyvLmcKp4zJFVPTC6eG6Xy4sXANcn
+g44l5gr3wcSzYctukk05HSbbdoBK5jjAzMT6al9l4mQdVXmv6dIkPFq27rIEaJTu
+pOPaLn+mq64o2+lhTLLESOxygzOlWQIDAQABoyMwITAfBgNVHREEGDAWggkxMjcu
+MC4wLjGCCTEyNy4wLjAuMjANBgkqhkiG9w0BAQsFAAOBgQCNdGVATsyhgfNHe4K8
+19Bi80kA6bvrNQ+6dOwNA3bfpOXog3MU+T5+Sv1tlHl7lL+fnTHZkfRzcQhA10Fw
+YdAxLDyDcY4PzgQcWSw7Lu74TLucfzcR+s+MYHAy8XXP002kjCBrSoSMiQPtXF7P
+f/MQaTCXjA8BP6Ldw4wdlODR5A==
+-----END CERTIFICATE-----
+END
+
+SERVER_KEY = <<END
+-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQDRTWFUYiB9TnI/ByjHHWnjnA02ieuczgAgI5CzrlrQCbCiogms
+yvLmcKp4zJFVPTC6eG6Xy4sXANcng44l5gr3wcSzYctukk05HSbbdoBK5jjAzMT6
+al9l4mQdVXmv6dIkPFq27rIEaJTupOPaLn+mq64o2+lhTLLESOxygzOlWQIDAQAB
+AoGAYbM9O6aSg+uaaNFut4ODajvt7wdydD+0z0vKwBUjTvk2+rOo0H/r4qW07a6Q
+KLnnhSOyfCkHRDWgOVGviQFZHHVptrxiMA6oiyWUL/CuKjGdDQi+Q1xnuEPh0qEz
+Q5ELkY1amDFS0pQV0LkDOweF4rc57haJcgRFxOz2HQJKeAECQQD0csJ4/sTq7lsg
+ebIFn0kKL/k99H53rUH3XlrnGo9CnVChLe6K9J/4smp98MCre0eSgc9ahNs2c4Fs
+ZpcgT8mVAkEA2zFwDhSXkkcWGmfk2Q/pfj/0OqLcIGTYkvi3sc2uirHb93VOLlvj
+ClM2XwRWeeeiEW+Ev5bLmHVGuK55+h/jtQJAfwTatJB9ti2gwGE79dvs0hRXiK/w
+vzMSIf2vcoLEijLAYOBDIYU3Ur0yxLpDA1gNur0lB74dQlAGolM0mB+deQJBAKBf
+RYsnydY+qI9dYHToTYAPrtOQANq6rjKqQ0yWHpRfmX8ulqsYk78kLu3KMLM0pMF5
+BHlhDUlY1QuerKQy3NkCQENWVz2NfnrrcgXUMHBojONcP3mkkOUocO4Ezm4GAgXO
+L55O+hAtuLYdxmuNPNhT2eyOsJ/pmPntS2k/rp39Hf4=
+-----END RSA PRIVATE KEY-----
+END
+
+UNKNOWN_CA = <<END
+-----BEGIN CERTIFICATE-----
+MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQGEwJIVTERMA8G
+A1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3MDUGA1UECwwuVGFuw7pzw610
+dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNlcnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBB
+cmFueSAoQ2xhc3MgR29sZCkgRsWRdGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgx
+MjA2MTUwODIxWjCBpzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxO
+ZXRMb2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlmaWNhdGlv
+biBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNzIEdvbGQpIEbFkXRhbsO6
+c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxCRec75LbRTDofTjl5Bu
+0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrTlF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw
+/HpYzY6b7cNGbIRwXdrzAZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAk
+H3B5r9s5VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRGILdw
+fzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2BJtr+UBdADTHLpl1
+neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAGAQH/AgEEMA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2MU9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwW
+qZw8UQCgwBEIBaeZ5m8BiFRhbvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTta
+YtOUZcTh5m2C+C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC
+bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2FuLjbvrW5Kfna
+NwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2XjG4Kvte9nHfRCaexOYNkbQu
+dZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E=
+-----END CERTIFICATE-----
+END
+end

data/spec/unit/application/ssl_spec.rb

@@ -105,6 +105,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(:get, %r{puppet-ca/v1/certificate_request/#{name}}).to_return(status: 404)
       stub_request(:put, %r{puppet-ca/v1/certificate_request/#{name}}).to_return(status: 200)

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(:http_ssl_instance).with('myserver', '123').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/indirector/resource/ral_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'puppet/type/user'
 require 'puppet/indirector/resource/ral'
 
 describe "Puppet::Resource::Ral" do

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

@@ -62,102 +62,6 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-  shared_examples_for 'ssl verifier' do
-    include PuppetSpec::Files
-
-    let (:host) { "my_server" }
-    let (:port) { 8140 }
-
-    # This is terrible, and is doing things that should probably be in spec/lib/puppet_spec/validators.rb,
-    # but we can't call allow from there.
-    before(:each) do
-      allow_any_instance_of(ConstantErrorValidator).to receive(:setup_connection) do |cev, connection|
-        allow(connection).to receive(:start).and_raise(OpenSSL::SSL::SSLError.new(cev.instance_variable_get(:@fails_with)))
-      end
-    end
-
-    before :all do
-      WebMock.disable!
-    end
-
-    after :all do
-      WebMock.enable!
-    end
-
-    it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet::Util::Platform.windows? do
-      connection = Puppet::Network::HTTP::Connection.new(
-        host, port,
-        :verify => ConstantErrorValidator.new(:fails_with => 'certificate verify failed',
-                                              :error_string => 'shady looking signature'))
-
-      expect do
-        connection.get('request')
-      end.to raise_error(Puppet::Error, /certificate verify failed: \[shady looking signature\]/)
-    end
-
-    it "should provide a helpful error message when hostname was not match with server certificate", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
-      Puppet[:confdir] = tmpdir('conf')
-
-      connection = Puppet::Network::HTTP::Connection.new(
-      host, port,
-      :verify => ConstantErrorValidator.new(
-        :fails_with => 'hostname was not match with server certificate',
-        :peer_certs => [Puppet::TestCa.new.generate('not_my_server',
-                                                    :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:not_my_server')[:cert]]))
-
-      expect do
-        connection.get('request')
-      end.to raise_error(Puppet::Error) do |error|
-        error.message =~ /\AServer hostname 'my_server' did not match server certificate; expected one of (.+)/
-        expect($1.split(', ')).to match_array(%w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server])
-      end
-    end
-
-    it "should pass along the error message otherwise" do
-      connection = Puppet::Network::HTTP::Connection.new(
-        host, port,
-        :verify => ConstantErrorValidator.new(:fails_with => 'some other message'))
-
-      expect do
-        connection.get('request')
-      end.to raise_error(/some other message/)
-    end
-
-    it "should check all peer certificates for upcoming expiration", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
-      Puppet[:confdir] = tmpdir('conf')
-      cert = Puppet::TestCa.new.generate('server',
-                                         :subject_alt_names => 'DNS:foo,DNS:bar,DNS:baz,DNS:server')[:cert]
-
-      connection = Puppet::Network::HTTP::Connection.new(
-        host, port,
-        :verify => NoProblemsValidator.new(cert))
-
-      allow_any_instance_of(Net::HTTP).to receive(:start)
-      allow_any_instance_of(Net::HTTP).to receive(:request).and_return(httpok)
-      allow_any_instance_of(Puppet::Network::HTTP::Pool).to receive(:setsockopts)
-
-      connection.get('request')
-    end
-  end
-
-  context "when using single use HTTPS connections", :unless => RUBY_PLATFORM == 'java' do
-    it_behaves_like 'ssl verifier' do
-    end
-  end
-
-  context "when using persistent HTTPS connections", :unless => RUBY_PLATFORM == 'java' do
-    around :each do |example|
-      pool = Puppet::Network::HTTP::Pool.new
-      Puppet.override(:http_pool => pool) do
-        example.run
-      end
-      pool.close
-    end
-
-    it_behaves_like 'ssl verifier' do
-    end
-  end
-
   context "when response is a redirect" do
     let (:site)       { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
     let (:other_site) { Puppet::Network::HTTP::Site.new('http', 'redirected', 9292) }

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

@@ -101,6 +101,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