chef 15.17.4-universal-mingw32 → 16.0.257-universal-mingw32

data/spec/unit/provider/service/redhat_spec.rb

@@ -21,7 +21,7 @@ require "ostruct"
 
 shared_examples_for "define_resource_requirements_common" do
   it "should raise an error if /sbin/chkconfig does not exist" do
-    allow(File).to receive(:exist?).with("/sbin/chkconfig").and_return(false)
+    allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(false)
     allow(@provider).to receive(:shell_out).with("/sbin/service chef status").and_raise(Errno::ENOENT)
     allow(@provider).to receive(:shell_out!).with("/sbin/chkconfig --list chef", returns: [0, 1]).and_raise(Errno::ENOENT)
     @provider.load_current_resource
@@ -55,7 +55,7 @@ describe "Chef::Provider::Service::Redhat" do
     @provider = Chef::Provider::Service::Redhat.new(@new_resource, @run_context)
     @provider.action = :start
     allow(Chef::Resource::Service).to receive(:new).and_return(@current_resource)
-    allow(File).to receive(:exist?).with("/sbin/chkconfig").and_return(true)
+    allow(File).to receive(:exists?).with("/sbin/chkconfig").and_return(true)
   end
 
   describe "while not in why run mode" do

data/spec/unit/provider/service/systemd_service_spec.rb

@@ -177,13 +177,13 @@ describe Chef::Provider::Service::Systemd do
 
         context "when a user is not specified" do
           it "should call '#{systemctl_path} --system start service_name' if no start command is specified" do
-            expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system start #{service_name_escaped}", default_env: false).and_return(shell_out_success)
+            expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--system", "start", service_name, default_env: false, timeout: 900).and_return(shell_out_success)
             provider.start_service
           end
 
           it "should not call '#{systemctl_path} --system start service_name' if it is already running" do
             current_resource.running(true)
-            expect(provider).not_to receive(:shell_out!).with("#{systemctl_path} --system start #{service_name_escaped}", {})
+            expect(provider).not_to receive(:shell_out_compacted!).with(systemctl_path, "--system", "start", service_name, timeout: 900)
             provider.start_service
           end
         end
@@ -191,14 +191,14 @@ describe Chef::Provider::Service::Systemd do
         context "when a user is specified" do
           it "should call '#{systemctl_path} --user start service_name' if no start command is specified" do
             current_resource.user("joe")
-            expect(provider).to receive(:shell_out!).with("#{systemctl_path} --user start #{service_name_escaped}", { environment: { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, user: "joe", default_env: false }).and_return(shell_out_success)
+            expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--user", "start", service_name, environment: { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, user: "joe", default_env: false, timeout: 900).and_return(shell_out_success)
             provider.start_service
           end
 
           it "should not call '#{systemctl_path} --user start service_name' if it is already running" do
             current_resource.running(true)
             current_resource.user("joe")
-            expect(provider).not_to receive(:shell_out!).with("#{systemctl_path} --user start #{service_name_escaped}", { environment: { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, user: "joe" })
+            expect(provider).not_to receive(:shell_out_compacted!).with(systemctl_path, "--user", "start", service_name, environment: { "DBUS_SESSION_BUS_ADDRESS" => "unix:path=/run/user/10000/bus" }, user: "joe", timeout: 900)
             provider.start_service
           end
         end
@@ -212,7 +212,7 @@ describe Chef::Provider::Service::Systemd do
 
         it "should call '#{systemctl_path} --system restart service_name' if no restart command is specified" do
           current_resource.running(true)
-          expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system restart #{service_name_escaped}", default_env: false).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--system", "restart", service_name, default_env: false, timeout: 900).and_return(shell_out_success)
           provider.restart_service
         end
 
@@ -229,7 +229,7 @@ describe Chef::Provider::Service::Systemd do
           context "when a reload command is not specified" do
             it "should call '#{systemctl_path} --system reload service_name' if the service is running" do
               current_resource.running(true)
-              expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system reload #{service_name_escaped}", default_env: false).and_return(shell_out_success)
+              expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--system", "reload", service_name, default_env: false, timeout: 900).and_return(shell_out_success)
               provider.reload_service
             end
 
@@ -250,13 +250,13 @@ describe Chef::Provider::Service::Systemd do
 
         it "should call '#{systemctl_path} --system stop service_name' if no stop command is specified" do
           current_resource.running(true)
-          expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system stop #{service_name_escaped}", default_env: false).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--system", "stop", service_name, timeout: 900, default_env: false).and_return(shell_out_success)
           provider.stop_service
         end
 
         it "should not call '#{systemctl_path} --system stop service_name' if it is already stopped" do
           current_resource.running(false)
-          expect(provider).not_to receive(:shell_out!).with("#{systemctl_path} --system stop #{service_name_escaped}", {})
+          expect(provider).not_to receive(:shell_out_compacted!).with(systemctl_path, "--system", "stop", service_name, timeout: 900)
           provider.stop_service
         end
       end
@@ -269,12 +269,12 @@ describe Chef::Provider::Service::Systemd do
         end
 
         it "should call '#{systemctl_path} --system enable service_name' to enable the service" do
-          expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system enable #{service_name_escaped}", {}).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--system", "enable", service_name, timeout: 900).and_return(shell_out_success)
           provider.enable_service
         end
 
         it "should call '#{systemctl_path} --system disable service_name' to disable the service" do
-          expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system disable #{service_name_escaped}", {}).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--system", "disable", service_name, timeout: 900).and_return(shell_out_success)
           provider.disable_service
         end
       end
@@ -287,12 +287,12 @@ describe Chef::Provider::Service::Systemd do
         end
 
         it "should call '#{systemctl_path} --system mask service_name' to mask the service" do
-          expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system mask #{service_name_escaped}", {}).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--system", "mask", service_name, timeout: 900).and_return(shell_out_success)
           provider.mask_service
         end
 
         it "should call '#{systemctl_path} --system unmask service_name' to unmask the service" do
-          expect(provider).to receive(:shell_out!).with("#{systemctl_path} --system unmask #{service_name_escaped}", {}).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out_compacted!).with(systemctl_path, "--system", "unmask", service_name, timeout: 900).and_return(shell_out_success)
           provider.unmask_service
         end
       end
@@ -305,12 +305,12 @@ describe Chef::Provider::Service::Systemd do
         end
 
         it "should return true if '#{systemctl_path} --system is-active service_name' returns 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-active #{service_name_escaped} --quiet", {}).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-active", service_name, "--quiet", timeout: 900).and_return(shell_out_success)
           expect(provider.is_active?).to be true
         end
 
         it "should return false if '#{systemctl_path} --system is-active service_name' returns anything except 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-active #{service_name_escaped} --quiet", {}).and_return(shell_out_failure)
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-active", service_name, "--quiet", timeout: 900).and_return(shell_out_failure)
           expect(provider.is_active?).to be false
         end
       end
@@ -323,12 +323,12 @@ describe Chef::Provider::Service::Systemd do
         end
 
         it "should return true if '#{systemctl_path} --system is-enabled service_name' returns 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped} --quiet", {}).and_return(shell_out_success)
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, "--quiet", timeout: 900).and_return(shell_out_success)
           expect(provider.is_enabled?).to be true
         end
 
         it "should return false if '#{systemctl_path} --system is-enabled service_name' returns anything except 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped} --quiet", {}).and_return(shell_out_failure)
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, "--quiet", timeout: 900).and_return(shell_out_failure)
           expect(provider.is_enabled?).to be false
         end
       end
@@ -341,22 +341,22 @@ describe Chef::Provider::Service::Systemd do
         end
 
         it "should return true if '#{systemctl_path} --system is-enabled service_name' returns 'masked' and returns anything except 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "masked", exitstatus: shell_out_failure))
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, timeout: 900).and_return(double(stdout: "masked", exitstatus: shell_out_failure))
           expect(provider.is_masked?).to be true
         end
 
         it "should return true if '#{systemctl_path} --system is-enabled service_name' outputs 'masked-runtime' and returns anything except 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "masked-runtime", exitstatus: shell_out_failure))
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, timeout: 900).and_return(double(stdout: "masked-runtime", exitstatus: shell_out_failure))
           expect(provider.is_masked?).to be true
         end
 
         it "should return false if '#{systemctl_path} --system is-enabled service_name' returns 0" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "enabled", exitstatus: shell_out_success))
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, timeout: 900).and_return(double(stdout: "enabled", exitstatus: shell_out_success))
           expect(provider.is_masked?).to be false
         end
 
         it "should return false if '#{systemctl_path} --system is-enabled service_name' returns anything except 0 and outputs an error'" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "Failed to get unit file state for #{service_name}: No such file or directory", exitstatus: shell_out_failure))
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, timeout: 900).and_return(double(stdout: "Failed to get unit file state for #{service_name}: No such file or directory", exitstatus: shell_out_failure))
           expect(provider.is_masked?).to be false
         end
       end
@@ -369,17 +369,17 @@ describe Chef::Provider::Service::Systemd do
         end
 
         it "should return true if '#{systemctl_path} --system is-enabled service_name' returns 'indirect'" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "indirect", exitstatus: shell_out_success))
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, timeout: 900).and_return(double(stdout: "indirect", exitstatus: shell_out_success))
           expect(provider.is_indirect?).to be true
         end
 
         it "should return false if '#{systemctl_path} --system is-enabled service_name' returns 0 and outputs something other than 'indirect'" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "enabled", exitstatus: shell_out_success))
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, timeout: 900).and_return(double(stdout: "enabled", exitstatus: shell_out_success))
           expect(provider.is_indirect?).to be false
         end
 
         it "should return false if '#{systemctl_path} --system is-enabled service_name' returns anything except 0 and outputs somethign other than 'indirect''" do
-          expect(provider).to receive(:shell_out).with("#{systemctl_path} --system is-enabled #{service_name_escaped}", {}).and_return(double(stdout: "enabled", exitstatus: shell_out_failure))
+          expect(provider).to receive(:shell_out_compacted).with(systemctl_path, "--system", "is-enabled", service_name, timeout: 900).and_return(double(stdout: "enabled", exitstatus: shell_out_failure))
           expect(provider.is_indirect?).to be false
         end
       end

data/spec/unit/provider/service/upstart_service_spec.rb

@@ -74,7 +74,7 @@ describe Chef::Provider::Service::Upstart do
       @status = double("Status", exitstatus: 0, stdout: "", stderr: "")
       allow(@provider).to receive(:shell_out).and_return(@status)
 
-      allow(::File).to receive(:exist?).and_return(true)
+      allow(::File).to receive(:exists?).and_return(true)
       allow(::File).to receive(:open).and_return(true)
     end
 
@@ -181,13 +181,13 @@ describe Chef::Provider::Service::Upstart do
     end
 
     it "should assume disable when no job configuration file is found" do
-      allow(::File).to receive(:exist?).and_return(false)
+      allow(::File).to receive(:exists?).and_return(false)
       expect(@current_resource).to receive(:running).with(false)
       @provider.load_current_resource
     end
 
     it "should track state when the upstart configuration file fails to load" do
-      expect(File).to receive(:exist?).and_return false
+      expect(File).to receive(:exists?).and_return false
       @provider.load_current_resource
       expect(@provider.instance_variable_get("@config_file_found")).to eq(false)
     end

data/spec/unit/provider/service/windows_spec.rb

@@ -22,8 +22,12 @@ require "spec_helper"
 describe Chef::Provider::Service::Windows, "load_current_resource" do
   include_context "Win32"
 
-  before do
-    stub_const("Chef::ReservedNames::Win32::Security", Class.new) unless windows?
+  before(:all) do
+    Chef::ReservedNames::Win32::Security = Class.new unless windows?
+  end
+
+  after(:all) do
+    Chef::ReservedNames::Win32.send(:remove_const, :Security) unless windows?
   end
 
   let(:logger) { double("Mixlib::Log::Child").as_null_object }

data/spec/unit/provider/subversion_spec.rb

@@ -46,7 +46,8 @@ describe Chef::Provider::Subversion do
   it "converts resource properties to options for shell_out" do
     expect(@provider.run_options).to eq({})
     @resource.user "deployninja"
-    expect(@provider.run_options).to eq({ user: "deployninja" })
+    expect(@provider).to receive(:get_homedir).and_return("/home/deployninja")
+    expect(@provider.run_options).to eq({ user: "deployninja", environment: { "HOME" => "/home/deployninja" } })
   end
 
   context "determining the revision of the currently deployed code" do
@@ -221,7 +222,8 @@ describe Chef::Provider::Subversion do
     @resource.user "whois"
     @resource.group "thisis"
     expected_cmd = "svn checkout -q   -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    expect(@provider).to receive(:shell_out!).with(expected_cmd, { user: "whois", group: "thisis" })
+    expect(@provider).to receive(:get_homedir).and_return("/home/whois")
+    expect(@provider).to receive(:shell_out!).with(expected_cmd, { user: "whois", group: "thisis", environment: { "HOME" => "/home/whois" } })
     @provider.run_action(:checkout)
     expect(@resource).to be_updated
   end

data/spec/unit/provider/systemd_unit_spec.rb

@@ -220,35 +220,31 @@ describe Chef::Provider::SystemdUnit do
       expect(current_resource.content).to eq(nil)
     end
 
-    # A password is required when specifying a user on Windows. Since systemd resources
-    # won't actually run on Windows, skip these tests rather than code a workaround.
-    unless windows?
-      it "loads the user unit content if the file exists and user is set" do
-        new_resource.user("joe")
-        allow(File).to receive(:exist?)
-          .with(unit_path_user)
-          .and_return(true)
-        allow(File).to receive(:read)
-          .with(unit_path_user)
-          .and_return(unit_content_string)
-        expect(File).to receive(:exist?)
-          .with(unit_path_user)
-        expect(File).to receive(:read)
-          .with(unit_path_user)
-        provider.load_current_resource
-        expect(current_resource.content).to eq(unit_content_string)
-      end
+    it "loads the user unit content if the file exists and user is set" do
+      new_resource.user("joe")
+      allow(File).to receive(:exist?)
+        .with(unit_path_user)
+        .and_return(true)
+      allow(File).to receive(:read)
+        .with(unit_path_user)
+        .and_return(unit_content_string)
+      expect(File).to receive(:exist?)
+        .with(unit_path_user)
+      expect(File).to receive(:read)
+        .with(unit_path_user)
+      provider.load_current_resource
+      expect(current_resource.content).to eq(unit_content_string)
+    end
 
-      it "does not load the user unit if the file does not exist and user is set" do
-        new_resource.user("joe")
-        allow(File).to receive(:exist?)
-          .with(unit_path_user)
-          .and_return(false)
-        expect(File).to_not receive(:read)
-          .with(unit_path_user)
-        provider.load_current_resource
-        expect(current_resource.content).to eq(nil)
-      end
+    it "does not load the user unit if the file does not exist and user is set" do
+      new_resource.user("joe")
+      allow(File).to receive(:exist?)
+        .with(unit_path_user)
+        .and_return(false)
+      expect(File).to_not receive(:read)
+        .with(unit_path_user)
+      provider.load_current_resource
+      expect(current_resource.content).to eq(nil)
     end
   end
 

data/spec/unit/provider/template_spec.rb

@@ -24,10 +24,9 @@ require "ostruct"
 require "support/shared/unit/provider/file"
 
 describe Chef::Provider::Template do
-  let(:node) { double("Chef::Node") }
-  let(:events) { double("Chef::Events").as_null_object } # mock all the methods
-  let(:logger) { double("Mixlib::Log::Child").as_null_object }
-  let(:run_context) { double("Chef::RunContext", node: node, events: events, logger: logger) }
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:enclosing_directory) do
     canonicalize_path(File.expand_path(File.join(CHEF_SPEC_DATA, "templates")))
   end

data/spec/unit/provider/zypper_repository_spec.rb

@@ -18,50 +18,22 @@
 
 require "spec_helper"
 
-describe Chef::Provider::ZypperRepository do
-  # Output of the command:
-  # => rpm -qa gpg-pubkey*
-  ZYPPER_RPM_KEYS = <<~EOF.freeze
-    gpg-pubkey-307e3d54-4be01a65
-    gpg-pubkey-3dbdc284-53674dd4
-  EOF
-
-  # Output of the command:
-  # => gpg --with-fingerprint [FILE]
-  ZYPPER_GPG_20 = <<~EOF.freeze
-    pub  2048R/3DBDC284 2011-08-19 [expires: 2024-06-14]
-          Key fingerprint = 573B FD6B 3D8F BC64 1079  A6AB ABF5 BD82 7BD9 BF62
-    uid                            nginx signing key <signing-key@nginx.com>
-  EOF
-
-  # Output of the command:
-  # => gpg --import-options import-show --dry-run --import --with-colons [FILE]
-  ZYPPER_GPG_22 = <<~EOF.freeze
-    pub:-:2048:1:ABF5BD827BD9BF62:1313747554:1718374819::-:::scSC::::::23::0:
-    fpr:::::::::573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62:
-    uid:-::::1466086904::F18C4DBBFCB45099ABB59088DB6B252FA7E9FB41::nginx signing key <signing-key@nginx.com>::::::::::0:
-    gpg: Total number processed: 1
-  EOF
-
-  # Output of the command:
-  # -> gpg --version
-  ZYPPER_GPG_VERSION = <<~EOF.freeze
-    gpg (GnuPG) 2.2.20
-    libgcrypt 1.8.5
-    Copyright (C) 2020 Free Software Foundation, Inc.
-    License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
-    This is free software: you are free to change and redistribute it.
-    There is NO WARRANTY, to the extent permitted by law.
-
-    Home: /Users/tsmith/.gnupg
-    Supported algorithms:
-    Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
-    Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,
-            CAMELLIA128, CAMELLIA192, CAMELLIA256
-    Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
-    Compression: Uncompressed, ZIP, ZLIB, BZIP2
-  EOF
+# Output of the command:
+# => rpm -qa gpg-pubkey*
+RPM_KEYS = <<~EOF.freeze
+  gpg-pubkey-307e3d54-4be01a65
+  gpg-pubkey-3dbdc284-53674dd4
+EOF
+
+# Output of the command:
+# => gpg --with-fingerprint [FILE]
+GPG_FINGER = <<~EOF.freeze
+  pub  2048R/3DBDC284 2011-08-19 [expires: 2024-06-14]
+        Key fingerprint = 573B FD6B 3D8F BC64 1079  A6AB ABF5 BD82 7BD9 BF62
+  uid                            nginx signing key <signing-key@nginx.com>
+EOF
 
+describe Chef::Provider::ZypperRepository do
   let(:new_resource) { Chef::Resource::ZypperRepository.new("Nginx Repository") }
   let(:logger) { double("Mixlib::Log::Child").as_null_object }
   let(:provider) do
@@ -73,19 +45,11 @@ describe Chef::Provider::ZypperRepository do
   end
 
   let(:rpm_key_finger) do
-    double("shell_out", stdout: ZYPPER_RPM_KEYS, exitstatus: 0, error?: false)
-  end
-
-  let(:gpg_20) do
-    double("shell_out", stdout: ZYPPER_GPG_20, exitstatus: 0, error?: false)
-  end
-
-  let(:gpg_22) do
-    double("shell_out", stdout: ZYPPER_GPG_22, exitstatus: 0, error?: false)
+    double("shell_out", stdout: RPM_KEYS, exitstatus: 0, error?: false)
   end
 
-  let(:gpg_ver) do
-    double("shell_out", stdout: ZYPPER_GPG_VERSION, exitstatus: 0, error?: false)
+  let(:gpg_finger) do
+    double("shell_out", stdout: GPG_FINGER, exitstatus: 0, error?: false)
   end
 
   it "responds to load_current_resource" do
@@ -132,38 +96,24 @@ describe Chef::Provider::ZypperRepository do
 
   describe "#key_installed?" do
     before do
-      expect(provider).to receive(:shell_out).with("/bin/rpm -qa gpg-pubkey*").and_return(rpm_key_finger)
+      expect(provider).to receive(:shell_out).with("rpm -qa gpg-pubkey*").and_return(rpm_key_finger)
     end
 
     it "returns true if the key is installed" do
-      expect(provider).to receive(:short_key_id).and_return("3dbdc284")
+      expect(provider).to receive(:key_fingerprint).and_return("3dbdc284")
       expect(provider.key_installed?("/foo/nginx.key")).to be_truthy
     end
 
     it "returns false if the key is not installed" do
-      expect(provider).to receive(:short_key_id).and_return("BOGUS")
+      expect(provider).to receive(:key_fingerprint).and_return("BOGUS")
       expect(provider.key_installed?("/foo/nginx.key")).to be_falsey
     end
   end
 
-  describe "#gpg_version" do
-    it "returns the gpg version by shelling out to gpg" do
-      expect(provider).to receive(:shell_out!).with("gpg --version").and_return(gpg_ver)
-      expect(provider.gpg_version).to eq(Gem::Version.new("2.2.20"))
-    end
-  end
-
-  describe "#short_key_id" do
-    it "returns the short key ID via running a dry-run import on gpg 2.2+" do
-      expect(provider).to receive(:gpg_version).and_return(Gem::Version.new("2.2"))
-      expect(provider).to receive(:shell_out!).with("gpg --import-options import-show --dry-run --import --with-colons /foo/nginx.key").and_return(gpg_22)
-      expect(provider.short_key_id("/foo/nginx.key")).to eq("7bd9bf62")
-    end
-
-    it "returns the short key ID via --with-fingerpint on gpg < 2.2" do
-      expect(provider).to receive(:gpg_version).and_return(Gem::Version.new("2.0"))
-      expect(provider).to receive(:shell_out!).with("gpg --with-fingerprint /foo/nginx.key").and_return(gpg_20)
-      expect(provider.short_key_id("/foo/nginx.key")).to eq("3dbdc284")
+  describe "#key_fingerprint" do
+    it "returns the key's fingerprint" do
+      expect(provider).to receive(:shell_out!).with("gpg --with-fingerprint /foo/nginx.key").and_return(gpg_finger)
+      expect(provider.key_fingerprint("/foo/nginx.key")).to eq("3dbdc284")
     end
   end