chef 17.0.242-universal-mingw32 → 17.4.25-universal-mingw32

data/lib/chef/secret_fetcher/aws_secrets_manager.rb

@@ -0,0 +1,65 @@
+#
+# Author:: Marc Paradise (<marc@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "base"
+require "aws-sdk-core"
+require "aws-sdk-secretsmanager"
+
+class Chef
+  # == Chef::SecretFetcher::AWSSecretsManager
+  # A fetcher that fetches a secret from AWS Secrets Manager
+  # In this initial iteration it defaults to authentication via instance profile.
+  # It is possible to pass options that configure it to use alternative credentials.
+  # This implementation supports fetching with version.
+  #
+  # @note ':region' is required configuration.  If it is not explicitly provided,
+  # and it is not available via global AWS config, we will pull it from node ohai data by default.
+  # If this isn't correct, you will need to explicitly override it.
+  # If it is not available via ohai data either (such as if you have the AWS plugin disabled)
+  # then the converge will fail with an error.
+  #
+  # @note: This does not yet support automatic retries, which the AWS client does by default.
+  #
+  # For configuration options see https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#initialize-instance_method
+  #
+  #
+  # Usage Example:
+  #
+  # fetcher = SecretFetcher.for_service(:aws_secrets_manager)
+  # fetcher.fetch("secretkey1", "v1")
+  class SecretFetcher
+    class AWSSecretsManager < Base
+      def validate!
+        config[:region] = config[:region] || Aws.config[:region] || run_context.node.dig("ec2", "region")
+        if config[:region].nil?
+          raise Chef::Exceptions::Secret::ConfigurationInvalid.new("Missing required config for AWS secret fetcher: :region")
+        end
+      end
+
+      # @param identifier [String] the secret_id
+      # @param version [String] the secret version. Not usd at this time
+      # @return Aws::SecretsManager::Types::GetSecretValueResponse
+      def do_fetch(identifier, version)
+        client = Aws::SecretsManager::Client.new(config)
+        result = client.get_secret_value(secret_id: identifier, version_stage: version)
+        # These fields are mutually exclusive
+        result.secret_string || result.secret_binary
+      end
+    end
+  end
+end

data/lib/chef/secret_fetcher/azure_key_vault.rb

@@ -0,0 +1,78 @@
+require_relative "base"
+
+class Chef
+  class SecretFetcher
+    # == Chef::SecretFetcher::AWSSecretsManager
+    # A fetcher that fetches a secret from Azure Key Vault. Supports fetching with version.
+    #
+    # In this initial iteration this authenticates via token obtained from the OAuth2  /token
+    # endpoint.
+    #
+    # Validation of required configuration (vault name) is not performed until
+    # `fetch` time, to allow for embedding the vault name in with the secret
+    # name, such as "my_vault/secretkey1".
+    #
+    # @example
+    #
+    # fetcher = SecretFetcher.for_service(:azure_key_vault, { vault: "my_vault" }, run_context )
+    # fetcher.fetch("secretkey1", "v1")
+    #
+    # @example
+    #
+    # fetcher = SecretFetcher.for_service(:azure_key_vault, {}, run_context )
+    # fetcher.fetch("my_vault/secretkey1", "v1")
+    class AzureKeyVault < Base
+
+      def do_fetch(name, version)
+        token = fetch_token
+        vault, name = resolve_vault_and_secret_name(name)
+        if vault.nil?
+          raise Chef::Exceptions::Secret::ConfigurationInvalid.new("You must provide a vault name to fetcher options as vault: 'vault_name' or in the secret name as 'vault_name/secret_name'")
+        end
+
+        # Note that `version` is optional after the final `/`. If nil/"", the latest secret version will be fetched.
+        secret_uri = URI.parse("https://#{vault}.vault.azure.net/secrets/#{name}/#{version}?api-version=7.2")
+        http = Net::HTTP.new(secret_uri.host, secret_uri.port)
+        http.use_ssl = true
+
+        response = http.get(secret_uri, { "Authorization" => "Bearer #{token}",
+                                          "Content-Type" => "application/json" })
+
+        # If an exception is not raised, we can be reasonably confident of the
+        # shape of the result.
+        result = JSON.parse(response.body)
+        if result.key? "value"
+          result["value"]
+        else
+          raise Chef::Exceptions::Secret::FetchFailed.new("#{result["error"]["code"]}: #{result["error"]["message"]}")
+        end
+      end
+
+      # Determine the vault name and secret name from the provided name.
+      # If it is not in the provided name in the form "vault_name/secret_name"
+      # it will determine the vault name from `config[:vault]`.
+      # @param name [String] the secret name or vault and secret name in the form "vault_name/secret_name"
+      # @return Array[String, String] vault and secret name respectively
+      def resolve_vault_and_secret_name(name)
+        # We support a simplified approach where the vault name is not passed i
+        # into configuration, but
+        if name.include?("/")
+          name.split("/", 2)
+        else
+          [config[:vault], name]
+        end
+      end
+
+      def fetch_token
+        token_uri = URI.parse("http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https%3A%2F%2Fvault.azure.net")
+        http = Net::HTTP.new(token_uri.host, token_uri.port)
+        response = http.get(token_uri, { "Metadata" => "true" })
+        body = JSON.parse(response.body)
+        body["access_token"]
+      end
+    end
+  end
+end
+
+
+

data/lib/chef/secret_fetcher/base.rb

@@ -0,0 +1,76 @@
+#
+# Author:: Marc Paradise (<marc@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../exceptions"
+
+class Chef
+  # == Chef::SecretFetcher
+  # An abstract base class that defines the methods required to implement
+  # a Secret Fetcher.
+  class SecretFetcher
+    class Base
+      attr_reader :config
+      # Note that this is only available in the context of a recipe.
+      # Since that's the only place it's intended to be used, that's probably OK.
+      attr_reader :run_context
+
+      # Initialize a new SecretFetcher::Base
+      #
+      # @param config [Hash] Configuration hash.  Expected configuration keys and values
+      # will vary based on implementation, and are validated in `validate!`.
+      def initialize(config, run_context)
+        @config = config
+        @run_context = run_context
+      end
+
+      # Fetch the named secret by invoking implementation-specific [Chef::SecretFetcher::Base#do_fetch]
+      #
+      # @param name [Object] the name or identifier of the secret.
+      # @param version [Object] Optional version of the secret to fetch.
+      # @note - the name parameter will probably see a narrowing of type as we learn more about different integrations.
+      # @return [Object] the fetched secret
+      # @raise [Chef::Exceptions::Secret::MissingSecretName] when secret name is not provided
+      # @raise [Chef::Exceptions::Secret::FetchFailed] when the underlying attempt to fetch the secret fails.
+      def fetch(name, version = nil)
+        raise Chef::Exceptions::Secret::MissingSecretName.new if name.to_s == ""
+
+        do_fetch(name, version)
+      end
+
+      # Validate that the instance is correctly configured.
+      # @raise [Chef::Exceptions::Secret::ConfigurationInvalid] if it is not.
+      def validate!; end
+
+      # Called to fetch the secret identified by 'identifer'.  Implementations
+      # should expect that `validate!` has been invoked before `do_fetch`.
+      #
+      # @param identifier [Object] Unique identifier of the secret to be retrieved.
+      # When invoked via DSL, this is pre-verified to be not nil/not empty string.
+      # The expected data type and form can vary by implementation.
+      # @param version [Object] Optional version of the secret to be retrieved.  If not
+      # provided, implementations are expected to fetch the most recent version of the
+      # secret by default.
+      #
+      # @return [Object] The secret as returned from the implementation.  The data type
+      # will vary implementation.
+      #
+      # @raise [Chef::Exceptions::Secret::FetchFailed] if the secret could not be fetched
+      def do_fetch(identifier, version); raise NotImplementedError.new; end
+    end
+  end
+end

data/lib/chef/secret_fetcher/example.rb

@@ -0,0 +1,46 @@
+#
+# Author:: Marc Paradise (<marc@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "base"
+
+class Chef
+  # == Chef::SecretFetcher::Example
+  # A simple implementation of a secrets fetcher.
+  # It expects to be initialized with a hash of
+  # keys and secret values.
+  #
+  # Usage Example:
+  #
+  # fetcher = SecretFetcher.for_service(:example, "secretkey1" => { "secret" => "lives here" })
+  # fetcher.fetch("secretkey1")
+  class SecretFetcher
+    class Example < Base
+      def validate!
+        if config.class != Hash
+          raise Chef::Exceptions::Secret::ConfigurationInvalid.new("The Example fetcher requires a hash of secrets")
+        end
+      end
+
+      def do_fetch(identifier, version)
+        raise Chef::Exceptions::Secret::FetchFailed.new("Secret #{identifier}) not found.") unless config.key?(identifier)
+
+        config[identifier]
+      end
+    end
+  end
+end

data/lib/chef/secret_fetcher.rb

@@ -0,0 +1,55 @@
+#
+# Author:: Marc Paradise (<marc@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "exceptions"
+
+class Chef
+  class SecretFetcher
+
+    SECRET_FETCHERS = %i{example aws_secrets_manager azure_key_vault}.freeze
+
+    # Returns a configured and validated instance
+    # of a [Chef::SecretFetcher::Base]  for the given
+    # service and configuration.
+    #
+    # @param service [Symbol] the identifier for the service that will support this request. Must be in
+    #                         SECRET_FETCHERS
+    # @param config [Hash] configuration that the secrets service requires
+    # @param run_context [Chef::RunContext] the run context this is being invoked from
+    def self.for_service(service, config, run_context)
+      fetcher = case service
+                when :example
+                  require_relative "secret_fetcher/example"
+                  Chef::SecretFetcher::Example.new(config, run_context)
+                when :aws_secrets_manager
+                  require_relative "secret_fetcher/aws_secrets_manager"
+                  Chef::SecretFetcher::AWSSecretsManager.new(config, run_context)
+                when :azure_key_vault
+                  require_relative "secret_fetcher/azure_key_vault"
+                  Chef::SecretFetcher::AzureKeyVault.new(config, run_context)
+                when nil, ""
+                  raise Chef::Exceptions::Secret::MissingFetcher.new(SECRET_FETCHERS)
+                else
+                  raise Chef::Exceptions::Secret::InvalidFetcherService.new("Unsupported secret service: #{service}", SECRET_FETCHERS)
+                end
+      fetcher.validate!
+      fetcher
+    end
+  end
+end
+

data/lib/chef/shell/ext.rb

@@ -198,9 +198,9 @@ module Shell
           prints a detailed explanation of the command if available, or the
           description if no explanation is available.
       E
-      def help(commmand = nil)
-        if commmand
-          explain_command(commmand)
+      def help(command = nil)
+        if command
+          explain_command(command)
         else
           puts help_banner
         end

data/lib/chef/version.rb

@@ -23,7 +23,7 @@ require_relative "version_string"
 
 class Chef
   CHEF_ROOT = File.expand_path("..", __dir__)
-  VERSION = Chef::VersionString.new("17.0.242")
+  VERSION = Chef::VersionString.new("17.4.25")
 end
 
 #

data/lib/chef/win32/api.rb

@@ -43,6 +43,8 @@ class Chef
 
         host.ffi_convention :stdcall
 
+        win64 = ENV["PROCESSOR_ARCHITECTURE"] == "AMD64"
+
         # Windows-specific type defs (ms-help://MS.MSDNQTR.v90.en/winprog/winprog/windows_data_types.htm):
         host.typedef :ushort,  :ATOM # Atom ~= Symbol: Atom table stores strings and corresponding identifiers. Application
         # places a string in an atom table and receives a 16-bit integer, called an atom, that
@@ -120,10 +122,15 @@ class Chef
         host.typedef :int32,   :LONG32 # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
         host.typedef :int64,   :LONG64 # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
         host.typedef :int64,   :LONGLONG # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
-        host.typedef :long,    :LONG_PTR # Signed long type for pointer precision. Use when casting a pointer to a long to
         # perform pointer arithmetic. BaseTsd.h:
         # if defined(_WIN64) host.typedef __int64 LONG_PTR; #else host.typedef long LONG_PTR;
-        host.typedef :long,    :LPARAM # Message parameter. WinDef.h as follows: #host.typedef LONG_PTR LPARAM;
+        if win64
+          host.typedef :int64,    :LONG_PTR # Signed long type for pointer precision. Use when casting a pointer to a long to
+          host.typedef :int64,    :LPARAM # Message parameter. WinDef.h as follows: #host.typedef LONG_PTR LPARAM;
+        else
+          host.typedef :long,    :LONG_PTR # Signed long type for pointer precision. Use when casting a pointer to a long to
+          host.typedef :long,    :LPARAM # Message parameter. WinDef.h as follows: #host.typedef LONG_PTR LPARAM;
+        end
         host.typedef :pointer, :LPBOOL # Pointer to a BOOL. WinDef.h as follows: #host.typedef BOOL far *LPBOOL;
         host.typedef :pointer, :LPBYTE # Pointer to a BYTE. WinDef.h as follows: #host.typedef BYTE far *LPBYTE;
         host.typedef :pointer, :LPCOLORREF # Pointer to a COLORREF value. WinDef.h as follows: #host.typedef DWORD *LPCOLORREF;

data/spec/data/knife_subcommand/test_explicit_category.rb

@@ -0,0 +1,7 @@
+module KnifeSpecs
+  class TestExplicitCategory < Chef::Knife
+    # i.e., the cookbook site commands should be in the cookbook site
+    # category instead of cookbook (which is what would be assumed)
+    category "cookbook site"
+  end
+end

data/spec/data/knife_subcommand/test_name_mapping.rb

@@ -0,0 +1,4 @@
+module KnifeSpecs
+  class TestNameMapping < Chef::Knife
+  end  
+end

data/spec/data/knife_subcommand/test_yourself.rb

@@ -0,0 +1,21 @@
+module KnifeSpecs
+  class TestYourself < Chef::Knife
+
+    class << self
+      attr_reader :test_deps_loaded
+    end
+
+    deps do
+      @test_deps_loaded = true
+    end
+
+    option :scro, :short => '-s SCRO', :long => '--scro SCRO', :description => 'a configurable setting'
+
+    attr_reader :ran
+
+    def run
+      @ran = true
+      self # return self so tests can poke at me
+    end
+  end
+end

data/spec/functional/mixin/from_file_spec.rb

@@ -33,7 +33,7 @@ describe Chef::Mixin::FromFile do
   end
 
   class ClassTestData
-    class <<self
+    class << self
       include Chef::Mixin::FromFile
 
       def a(a = nil)

data/spec/functional/resource/dnf_package_spec.rb

@@ -18,12 +18,10 @@
 require "spec_helper"
 require "chef/mixin/shell_out"
 
-# run this test only for following platforms.
-# TODO: 2021-04-23 we removed 'fedora' from this list because our fedora functional tests
-#                  are consistently timing out in BuildKite.  Once we've addressed this (see issue chef/11414)
-#                  we will re-add the platform.
-exclude_test = !(%w{rhel amazon}.include?(ohai[:platform_family]) && File.exist?("/usr/bin/dnf"))
+# test on any fedora-ish platform with dnf
+exclude_test = !(%w{rhel amazon fedora}.include?(OHAI_SYSTEM[:platform_family]) && File.exist?("/usr/bin/dnf"))
 describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
+  include RecipeDSLHelper
   include Chef::Mixin::ShellOut
 
   # NOTE: every single test here either needs to explicitly call flush_cache or needs to explicitly
@@ -33,7 +31,7 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
   def flush_cache
     # needed on at least fc23/fc24 sometimes to deal with the dnf cache getting out of sync with the rpm db
     FileUtils.rm_f "/var/cache/dnf/@System.solv"
-    Chef::Resource::DnfPackage.new("shouldnt-matter", run_context).run_action(:flush_cache)
+    Chef::Provider::Package::Dnf::PythonHelper.instance.reap
   end
 
   def preinstall(*rpms)
@@ -43,11 +41,17 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
     flush_cache
   end
 
+  def expect_matching_installed_version(version)
+    expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(version)
+  end
+
   before(:all) do
     shell_out!("dnf -y install dnf-plugins-core")
   end
 
   before(:each) do
+    # force errors to fail and not retry
+    ENV["DNF_HELPER_NO_RETRIES"] = "true"
     File.open("/etc/yum.repos.d/chef-dnf-localtesting.repo", "w+") do |f|
       f.write <<~EOF
         [chef-dnf-localtesting]
@@ -57,6 +61,7 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
         gpgcheck=0
       EOF
     end
+    # ensure we don't have any stray chef_rpms installed
     shell_out!("rpm -qa --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' | grep chef_rpm | xargs -r rpm -e")
     # next line is useful cleanup if you happen to have been testing both yum + dnf func tests on the same box and
     # have some yum garbage left around
@@ -68,64 +73,71 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
     FileUtils.rm_f "/etc/yum.repos.d/chef-dnf-localtesting.repo"
   end
 
-  let(:run_context) do
-    Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
-  end
-
-  let(:package_name) { "chef_rpm" }
-  let(:dnf_package) { Chef::Resource::DnfPackage.new(package_name, run_context) }
+  let(:default_options) { "--nogpgcheck --disablerepo=* --enablerepo=chef-dnf-localtesting" }
 
   def pkg_arch
-    ohai[:kernel][:machine]
+    OHAI_SYSTEM[:kernel][:machine]
   end
 
   describe ":install" do
     context "vanilla use case" do
-      let(:package_name) { "chef_rpm" }
-
       it "installs if the package is not installed" do
         flush_cache
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "does not install if the package is installed" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "does not install twice" do
         flush_cache
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "does not install if the prior version package is installed" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "does not install if the i686 package is installed", :intel_64bit do
         skip "FIXME: do nothing, or install the #{pkg_arch} version?"
         preinstall("chef_rpm-1.10-1.i686.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
       end
 
       it "does not install if the prior version i686 package is installed", :intel_64bit do
         skip "FIXME: do nothing, or install the #{pkg_arch} version?"
         preinstall("chef_rpm-1.2-1.i686.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.i686$")
       end
     end
@@ -134,72 +146,81 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
       %w{1.10 1* 1.10-1 1*-1 1.10-* 1*-* 0:1.10 0:1* 0:1.10-1 0:1*-1 *:1.10-* *:1*-*}.each do |vstring|
         it "installs the rpm when #{vstring} is in the package_name" do
           flush_cache
-          dnf_package.package_name("chef_rpm-#{vstring}")
-          dnf_package.run_action(:install)
-          expect(dnf_package.updated_by_last_action?).to be true
+          dnf_package "chef_rpm-#{vstring}" do
+            options default_options
+            action :install
+          end.should_be_updated
         end
 
         it "is idempotent when #{vstring} is in the package_name" do
           preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-          dnf_package.package_name("chef_rpm-#{vstring}")
-          dnf_package.run_action(:install)
-          expect(dnf_package.updated_by_last_action?).to be false
+          dnf_package "chef_rpm-#{vstring}" do
+            options default_options
+            action :install
+          end.should_not_be_updated
         end
 
         it "installs the rpm when #{vstring} is in the version property" do
           flush_cache
-          dnf_package.package_name("chef_rpm")
-          dnf_package.version(vstring)
-          dnf_package.run_action(:install)
-          expect(dnf_package.updated_by_last_action?).to be true
+          dnf_package "chef_rpm" do
+            options default_options
+            version vstring
+            action :install
+          end.should_be_updated
         end
 
         it "is idempotent when #{vstring} is in the version property" do
           preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-          dnf_package.package_name("chef_rpm")
-          dnf_package.version(vstring)
-          dnf_package.run_action(:install)
-          expect(dnf_package.updated_by_last_action?).to be false
+          dnf_package "chef_rpm" do
+            options default_options
+            version vstring
+            action :install
+          end.should_not_be_updated
         end
 
         it "upgrades the rpm when #{vstring} is in the package_name" do
           flush_cache
-          dnf_package.package_name("chef_rpm-#{vstring}")
-          dnf_package.run_action(:upgrade)
-          expect(dnf_package.updated_by_last_action?).to be true
+          dnf_package "chef_rpm-#{vstring}" do
+            options default_options
+            action :upgrade
+          end.should_be_updated
         end
 
         it "is idempotent when #{vstring} is in the package_name" do
           preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-          dnf_package.package_name("chef_rpm-#{vstring}")
-          dnf_package.run_action(:upgrade)
-          expect(dnf_package.updated_by_last_action?).to be false
+          dnf_package "chef_rpm-#{vstring}" do
+            options default_options
+            action :upgrade
+          end.should_not_be_updated
         end
 
         it "upgrades the rpm when #{vstring} is in the version property" do
           flush_cache
-          dnf_package.package_name("chef_rpm")
-          dnf_package.version(vstring)
-          dnf_package.run_action(:upgrade)
-          expect(dnf_package.updated_by_last_action?).to be true
+          dnf_package "chef_rpm" do
+            options default_options
+            version vstring
+            action :upgrade
+          end.should_be_updated
         end
 
         it "is idempotent when #{vstring} is in the version property" do
           preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-          dnf_package.package_name("chef_rpm")
-          dnf_package.version(vstring)
-          dnf_package.run_action(:upgrade)
-          expect(dnf_package.updated_by_last_action?).to be false
+          dnf_package "chef_rpm" do
+            options default_options
+            version vstring
+            action :upgrade
+          end.should_not_be_updated
         end
       end
 
       %w{1.2 1* 1.2-1 1*-1 1.2-* 1*-* 0:1.2 0:1* 0:1.2-1 0:1*-1 *:1.2-* *:1*-*}.each do |vstring|
         it "is idempotent when #{vstring} is in the version property and there is a candidate version" do
           preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-          dnf_package.package_name("chef_rpm")
-          dnf_package.version(vstring)
-          dnf_package.run_action(:install)
-          expect(dnf_package.updated_by_last_action?).to be false
+          dnf_package "chef_rpm" do
+            options default_options
+            version vstring
+            action :install
+          end.should_not_be_updated
           expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
         end
       end
@@ -207,10 +228,11 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
       %w{1.2 1.2-1 1.2-* 0:1.2 0:1.2-1 *:1.2-*}.each do |vstring|
         it "is idempotent when #{vstring} is in the version property on upgrade and it doesn't match the candidate version" do
           preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-          dnf_package.package_name("chef_rpm")
-          dnf_package.version(vstring)
-          dnf_package.run_action(:upgrade)
-          expect(dnf_package.updated_by_last_action?).to be false
+          dnf_package "chef_rpm" do
+            options default_options
+            version vstring
+            action :upgrade
+          end.should_not_be_updated
           expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
         end
       end
@@ -218,13 +240,17 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
       %w{1* 1*-1 1*-* 0:1* 0:1*-1 *:1*-*}.each do |vstring|
         it "upgrades when #{vstring} is in the version property on upgrade and it matches the candidate version" do
           preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-          dnf_package.package_name("chef_rpm")
-          dnf_package.version(vstring)
-          dnf_package.run_action(:upgrade)
-          expect(dnf_package.updated_by_last_action?).to be true
+          dnf_package "chef_rpm" do
+            options default_options
+            version vstring
+            action :upgrade
+          end.should_be_updated
           expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-          dnf_package.run_action(:upgrade)
-          expect(dnf_package.updated_by_last_action?).to be false
+          dnf_package "chef_rpm" do
+            options default_options
+            version vstring
+            action :upgrade
+          end.should_not_be_updated
         end
       end
     end
@@ -232,82 +258,106 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
     context "with versions or globs in the name" do
       it "works with a version" do
         flush_cache
-        dnf_package.package_name("chef_rpm-1.10")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.10" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.10" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "works with an older version" do
         flush_cache
-        dnf_package.package_name("chef_rpm-1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.2" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "works with an evra" do
         flush_cache
-        dnf_package.package_name("chef_rpm-0:1.2-1.#{pkg_arch}")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-0:1.2-1.#{pkg_arch}" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-0:1.2-1.#{pkg_arch}" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "works with version and release" do
         flush_cache
-        dnf_package.package_name("chef_rpm-1.2-1")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.2-1" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.2-1" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "works with a version glob" do
         flush_cache
-        dnf_package.package_name("chef_rpm-1*")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1*" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1*" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "works with a name glob + version glob" do
         flush_cache
-        dnf_package.package_name("chef_rp*-1*")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rp*-1*" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rp*-1*" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "upgrades when the installed version does not match the version string" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm-1.10")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.10" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.10" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "downgrades when the installed version is higher than the package_name version" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm-1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.2" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
     end
 
@@ -315,68 +365,92 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
     context "with version property" do
       it "matches the full version" do
         flush_cache
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1.10")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10"
+          action :install
+        end.should_not_be_updated
       end
 
       it "matches with a glob" do
         flush_cache
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1*")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1*"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1*"
+          action :install
+        end.should_not_be_updated
       end
 
       it "matches the vr" do
         flush_cache
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1.10-1")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10-1"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10-1"
+          action :install
+        end.should_not_be_updated
       end
 
       it "matches the evr" do
         flush_cache
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("0:1.10-1")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "0:1.10-1"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "0:1.10-1"
+          action :install
+        end.should_not_be_updated
       end
 
       it "matches with a vr glob", :rhel_gte_8 do
         flush_cache
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1.10-1*")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10-1*"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10-1*"
+          action :install
+        end.should_not_be_updated
       end
 
       it "matches with an evr glob", :rhel_gte_8 do
         flush_cache
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("0:1.10-1*")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "0:1.10-1*"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "0:1.10-1*"
+          action :install
+        end.should_not_be_updated
       end
     end
 
@@ -384,274 +458,345 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
       it "downgrades the package when allow_downgrade" do
         flush_cache
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1.2-1")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.2-1"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.2-1"
+          action :install
+        end.should_not_be_updated
       end
     end
 
     context "with arches", :intel_64bit do
       it "installs with 64-bit arch in the name" do
         flush_cache
-        dnf_package.package_name("chef_rpm.#{pkg_arch}")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "installs with 32-bit arch in the name" do
         flush_cache
-        dnf_package.package_name("chef_rpm.i686")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm.i686" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.i686" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "installs with 64-bit arch in the property" do
         flush_cache
-        dnf_package.package_name("chef_rpm")
-        dnf_package.arch((pkg_arch).to_s)
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          arch pkg_arch
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          arch pkg_arch
+          action :install
+        end.should_not_be_updated
       end
 
       it "installs with 32-bit arch in the property" do
         flush_cache
-        dnf_package.package_name("chef_rpm")
-        dnf_package.arch("i686")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          arch "i686"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          arch "i686"
+          action :install
+        end.should_not_be_updated
       end
 
       it "installs when the 32-bit arch is in the name and the version is in the property" do
         flush_cache
-        dnf_package.package_name("chef_rpm.i686")
-        dnf_package.version("1.10-1")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm.i686" do
+          options default_options
+          version "1.10-1"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.i686" do
+          options default_options
+          version "1.10-1"
+          action :install
+        end.should_not_be_updated
       end
 
       it "installs when the 64-bit arch is in the name and the version is in the property" do
         flush_cache
-        dnf_package.package_name("chef_rpm.#{pkg_arch}")
-        dnf_package.version("1.10-1")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          version "1.10-1"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          version "1.10-1"
+          action :install
+        end.should_not_be_updated
       end
     end
 
     context "with constraints" do
       it "with nothing installed, it installs the latest version" do
         flush_cache
-        dnf_package.package_name("chef_rpm >= 1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm >= 1.2" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm >= 1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "when it is met, it does nothing" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm >= 1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm >= 1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "when it is met, it does nothing" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm >= 1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm >= 1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "with nothing installed, it installs the latest version" do
         flush_cache
-        dnf_package.package_name("chef_rpm > 1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "when it is not met by an installed rpm, it upgrades" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm > 1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "with an equality constraint, when it is not met by an installed rpm, it upgrades" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm = 1.10")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm = 1.10" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm = 1.10" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "with an equality constraint, when it is met by an installed rpm, it does nothing" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm = 1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm = 1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "when it is met by an installed rpm, it does nothing" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm > 1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "when there is no solution to the contraint" do
         flush_cache
-        dnf_package.package_name("chef_rpm > 2.0")
-        expect { dnf_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          dnf_package "chef_rpm > 2.0"
+        }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
       end
 
       it "when there is no solution to the contraint but an rpm is preinstalled" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm > 2.0")
-        expect { dnf_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          dnf_package "chef_rpm > 2.0"
+        }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
       end
 
       it "with a less than constraint, when nothing is installed, it installs" do
         flush_cache
-        dnf_package.package_name("chef_rpm < 1.10")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "with a less than constraint, when the install version matches, it does nothing" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm < 1.10")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "with a less than constraint, when the install version fails, it should downgrade" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm < 1.10")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
     end
 
     context "with source arguments" do
       it "raises an exception when the package does not exist" do
         flush_cache
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/this-file-better-not-exist.rpm")
-        expect { dnf_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/this-file-better-not-exist.rpm"
+        }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
       end
 
       it "does not raise a hard exception in why-run mode when the package does not exist" do
         Chef::Config[:why_run] = true
         flush_cache
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/this-file-better-not-exist.rpm")
-        dnf_package.run_action(:install)
-        expect { dnf_package.run_action(:install) }.not_to raise_error
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/this-file-better-not-exist.rpm" do
+          options default_options
+          action :install
+        end
       end
 
       it "installs the package when using the source argument" do
         flush_cache
-        dnf_package.name "something"
-        dnf_package.package_name "somethingelse"
-        dnf_package.source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "something" do
+          source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
+          options default_options
+          package_name "somethingelse"
+          name "something"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "something" do
+          source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
+          options default_options
+          package_name "somethingelse"
+          name "something"
+          action :install
+        end.should_not_be_updated
       end
 
       it "installs the package when the name is a path to a file" do
         flush_cache
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "downgrade on a local file with allow_downgrade true works" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.version "1.2-1"
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          version "1.2-1"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          version "1.2-1"
+          action :install
+        end.should_not_be_updated
       end
 
       it "does not downgrade the package with :install" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "does not upgrade the package with :install" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "is idempotent when the package is already installed" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "is idempotent when the package is already installed and there is a version string" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.version "1.2-1"
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          version "1.2-1"
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
@@ -660,142 +805,183 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
       it "works when a package is installed" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-dnf-localtesting.repo"
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options "--nogpgcheck --disablerepo=*"
+          action :install
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "works with a local source" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-dnf-localtesting.repo"
         flush_cache
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options "--nogpgcheck --disablerepo=*"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options "--nogpgcheck --disablerepo=*"
+          action :install
+        end.should_not_be_updated
       end
     end
 
     context "multipackage with arches", :intel_64bit do
       it "installs two rpms" do
         flush_cache
-        dnf_package.package_name([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] )
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.#{pkg_arch}$/)
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.i686$/)
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "does nothing if both are installed" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm", "chef_rpm-1.10-1.i686.rpm")
         flush_cache
-        dnf_package.package_name([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] )
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "installs the second rpm if the first is installed" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] )
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.#{pkg_arch}$/)
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.i686$/)
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       it "installs the first rpm if the second is installed" do
         preinstall("chef_rpm-1.10-1.i686.rpm")
-        dnf_package.package_name([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] )
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.#{pkg_arch}$/)
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.i686$/)
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       # unlikely to work consistently correct, okay to deprecate the arch-array in favor of the arch in the name
       it "installs two rpms with multi-arch" do
         flush_cache
-        dnf_package.package_name(%w{chef_rpm chef_rpm} )
-        dnf_package.arch([pkg_arch, "i686"])
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.#{pkg_arch}$/)
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.i686$/)
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+          action :install
+        end.should_not_be_updated
       end
 
       # unlikely to work consistently correct, okay to deprecate the arch-array in favor of the arch in the name
       it "installs the second rpm if the first is installed (muti-arch)" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name(%w{chef_rpm chef_rpm} )
-        dnf_package.arch([pkg_arch, "i686"])
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.#{pkg_arch}$/)
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.i686$/)
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package %w{chef_rpm chef_rpm} do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       # unlikely to work consistently correct, okay to deprecate the arch-array in favor of the arch in the name
       it "installs the first rpm if the second is installed (muti-arch)" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name(%w{chef_rpm chef_rpm} )
-        dnf_package.arch([pkg_arch, "i686"])
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.#{pkg_arch}$/)
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match(/^chef_rpm-1.10-1.i686$/)
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package %w{chef_rpm chef_rpm} do
+          options default_options
+          action :install
+        end.should_not_be_updated
       end
 
       # unlikely to work consistently correct, okay to deprecate the arch-array in favor of the arch in the name
       it "does nothing if both are installed (muti-arch)" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm", "chef_rpm-1.10-1.i686.rpm")
-        dnf_package.package_name(%w{chef_rpm chef_rpm} )
-        dnf_package.arch([pkg_arch, "i686"])
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+          action :install
+        end.should_not_be_updated
       end
     end
 
     context "repo controls" do
       it "should fail with the repo disabled" do
         flush_cache
-        dnf_package.options("--disablerepo=chef-dnf-localtesting")
-        expect { dnf_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          dnf_package "chef_rpm" do
+            options "--nogpgcheck --disablerepo=chef-dnf-localtesting"
+            action :install
+          end
+        }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
       end
 
       it "should work with disablerepo first" do
         flush_cache
-        dnf_package.options(["--disablerepo=*", "--enablerepo=chef-dnf-localtesting"])
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options ["--nogpgcheck", "--disablerepo=*", "--enablerepo=chef-dnf-localtesting"]
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options ["--nogpgcheck", "--disablerepo=*", "--enablerepo=chef-dnf-localtesting"]
+          action :install
+        end.should_not_be_updated
       end
 
       it "should work to enable a disabled repo" do
         shell_out!("dnf config-manager --set-disabled chef-dnf-localtesting")
         flush_cache
-        expect { dnf_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          dnf_package "chef_rpm" do
+            options "--nogpgcheck"
+            action :install
+          end
+        }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
         flush_cache
-        dnf_package.options("--enablerepo=chef-dnf-localtesting")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options "--nogpgcheck --enablerepo=chef-dnf-localtesting"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options "--nogpgcheck --enablerepo=chef-dnf-localtesting"
+          action :install
+        end.should_not_be_updated
       end
 
       it "when an idempotent install action is run, does not leave repos disabled" do
@@ -805,19 +991,22 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
         # accomplishes both those goals (it would be easier if we had other rpms in this repo, but with
         # one rpm we need to do this).
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.options("--disablerepo=chef-dnf-localtesting")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options "--nogpgcheck --disablerepo=chef-dnf-localtesting"
+          action :upgrade
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
         # now we're still using the same cache in the dnf_helper.py cache and we test to see if the
         # repo that we temporarily disabled is enabled on this pass.
-        dnf_package.package_name("chef_rpm-1.10-1.#{pkg_arch}")
-        dnf_package.options(nil)
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.10-1.#{pkg_arch}" do
+          options "--nogpgcheck"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.10-1.#{pkg_arch}" do
+          options "--nogpgcheck"
+          action :install
+        end.should_not_be_updated
       end
     end
   end
@@ -826,76 +1015,102 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
     context "downgrades" do
       it "just work with DNF" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.version("1.2")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.2"
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.2"
+          action :install
+        end.should_not_be_updated
       end
 
       it "throws a deprecation warning with allow_downgrade" do
         Chef::Config[:treat_deprecation_warnings_as_errors] = false
-        expect(Chef).to receive(:deprecated).with(:dnf_package_allow_downgrade, /^the allow_downgrade property on the dnf_package provider is not used/)
+        expect(Chef).to receive(:deprecated).at_least(:once).with(:dnf_package_allow_downgrade, /^the allow_downgrade property on the dnf_package provider is not used/)
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.version("1.2")
-        dnf_package.allow_downgrade true
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.2"
+          allow_downgrade true
+          action :install
+        end.should_be_updated
         expect(shell_out("rpm -q chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}")
-        dnf_package.run_action(:install)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.2"
+          allow_downgrade true
+          action :install
+        end.should_not_be_updated
       end
     end
 
     context "with source arguments" do
       it "installs the package when using the source argument" do
         flush_cache
-        dnf_package.name "something"
-        dnf_package.package_name "somethingelse"
-        dnf_package.source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "something" do
+          options default_options
+          package_name "somethingelse"
+          source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "something" do
+          options default_options
+          package_name "somethingelse"
+          source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "installs the package when the name is a path to a file" do
         flush_cache
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "downgrades the package when allow_downgrade is true" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "upgrades the package" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "is idempotent when the package is already installed" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
@@ -904,295 +1119,382 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
       it "works when a package is installed" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-dnf-localtesting.repo"
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options "--nogpgcheck --disablerepo=*"
+          action :upgrade
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "works with a local source" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-dnf-localtesting.repo"
         flush_cache
-        dnf_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options "--nogpgcheck --disablerepo=*"
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
     end
 
     context "version pinning" do
       it "with a full version pin it installs a later package" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1.10-1")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10-1"
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10-1"
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a full version pin in the name it downgrades the package" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1.2-1")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.2-1"
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.2-1"
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a partial (no release) version pin it installs a later package" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1.10")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10"
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version "1.10"
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a partial (no release) version pin in the name it downgrades the package" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm")
-        dnf_package.version("1.2")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          version("1.2")
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          version("1.2")
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a full version pin it installs a later package" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm-1.10-1")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.10-1" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.10-1" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a full version pin in the name it downgrades the package" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm-1.2-1")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.2-1" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.2-1" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a partial (no release) version pin it installs a later package" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm-1.10")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.10" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.10" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a partial (no release) version pin in the name it downgrades the package" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm-1.2")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm-1.2" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm-1.2" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a prco equality pin in the name it upgrades a prior package" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm = 1.10")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm = 1.10" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm = 1.10" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a prco equality pin in the name it downgrades a later package" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm = 1.2")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm = 1.2" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm = 1.2" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a > pin in the name and no rpm installed it installs" do
         flush_cache
-        dnf_package.package_name("chef_rpm > 1.2")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a < pin in the name and no rpm installed it installs" do
         flush_cache
-        dnf_package.package_name("chef_rpm < 1.10")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a > pin in the name and matching rpm installed it does nothing" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm > 1.2")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "with a < pin in the name and no rpm installed it installs" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm < 1.10")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "with a > pin in the name and non-matching rpm installed it upgrades" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm > 1.2")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm > 1.2" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
 
       it "with a < pin in the name and non-matching rpm installed it downgrades" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.package_name("chef_rpm < 1.10")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :upgrade
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
-        dnf_package.run_action(:upgrade)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm < 1.10" do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
       end
     end
   end
 
   describe ":remove" do
     context "vanilla use case" do
-      let(:package_name) { "chef_rpm" }
       it "does nothing if the package is not installed" do
         flush_cache
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
       end
 
       it "removes the package if the package is installed" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
       end
 
       it "does not remove the package twice" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
       end
 
       it "removes the package if the prior version package is installed" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
       end
 
       it "removes the package if the i686 package is installed", :intel_64bit do
         skip "FIXME: should this be fixed or is the current behavior correct?"
         preinstall("chef_rpm-1.10-1.i686.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
       end
 
       it "removes the package if the prior version i686 package is installed", :intel_64bit do
         skip "FIXME: should this be fixed or is the current behavior correct?"
         preinstall("chef_rpm-1.2-1.i686.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
       end
     end
 
     context "with 64-bit arch", :intel_64bit do
-      let(:package_name) { "chef_rpm.#{pkg_arch}" }
       it "does nothing if the package is not installed" do
         flush_cache
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
       end
 
       it "removes the package if the package is installed" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
       end
 
       it "removes the package if the prior version package is installed" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
       end
 
       it "does nothing if the i686 package is installed" do
         preinstall("chef_rpm-1.10-1.i686.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
       end
 
       it "does nothing if the prior version i686 package is installed" do
         preinstall("chef_rpm-1.2-1.i686.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.i686$")
       end
     end
 
     context "with 32-bit arch", :intel_64bit do
-      let(:package_name) { "chef_rpm.i686" }
       it "removes only the 32-bit arch if both are installed" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm", "chef_rpm-1.10-1.i686.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm.i686" do
+          options default_options
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm.i686" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
       end
     end
 
@@ -1200,11 +1502,15 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
       it "works when a package is installed" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-dnf-localtesting.repo"
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be true
+        dnf_package "chef_rpm" do
+          options "--nogpgcheck --disablerepo=*"
+          action :remove
+        end.should_be_updated
         expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
-        dnf_package.run_action(:remove)
-        expect(dnf_package.updated_by_last_action?).to be false
+        dnf_package "chef_rpm" do
+          options "--nogpgcheck --disablerepo=*"
+          action :remove
+        end.should_not_be_updated
       end
     end
   end
@@ -1220,61 +1526,75 @@ describe Chef::Resource::DnfPackage, :requires_root, external: exclude_test do
 
     it "locks an rpm" do
       flush_cache
-      dnf_package.package_name("chef_rpm")
-      dnf_package.run_action(:lock)
-      expect(dnf_package.updated_by_last_action?).to be true
+      dnf_package "chef_rpm" do
+        options default_options
+        action :lock
+      end.should_be_updated
       expect(shell_out("dnf versionlock list").stdout.chomp).to match("^chef_rpm-0:")
-      dnf_package.run_action(:lock)
-      expect(dnf_package.updated_by_last_action?).to be false
+      dnf_package "chef_rpm" do
+        options default_options
+        action :lock
+      end.should_not_be_updated
     end
 
     it "does not lock if its already locked" do
       flush_cache
       shell_out!("dnf versionlock add chef_rpm")
-      dnf_package.package_name("chef_rpm")
-      dnf_package.run_action(:lock)
-      expect(dnf_package.updated_by_last_action?).to be false
+      dnf_package "chef_rpm" do
+        options default_options
+        action :lock
+      end.should_not_be_updated
       expect(shell_out("dnf versionlock list").stdout.chomp).to match("^chef_rpm-0:")
     end
 
     it "unlocks an rpm" do
       flush_cache
       shell_out!("dnf versionlock add chef_rpm")
-      dnf_package.package_name("chef_rpm")
-      dnf_package.run_action(:unlock)
-      expect(dnf_package.updated_by_last_action?).to be true
+      dnf_package "chef_rpm" do
+        options default_options
+        action :unlock
+      end.should_be_updated
       expect(shell_out("dnf versionlock list").stdout.chomp).not_to match("^chef_rpm-0:")
-      dnf_package.run_action(:unlock)
-      expect(dnf_package.updated_by_last_action?).to be false
+      dnf_package "chef_rpm" do
+        options default_options
+        action :unlock
+      end.should_not_be_updated
     end
 
     it "does not unlock an already locked rpm" do
       flush_cache
-      dnf_package.package_name("chef_rpm")
-      dnf_package.run_action(:unlock)
-      expect(dnf_package.updated_by_last_action?).to be false
+      dnf_package "chef_rpm" do
+        options default_options
+        action :unlock
+      end.should_not_be_updated
       expect(shell_out("dnf versionlock list").stdout.chomp).not_to match("^chef_rpm-0:")
     end
 
     it "check that we can lock based on provides" do
       flush_cache
-      dnf_package.package_name("chef_rpm_provides")
-      dnf_package.run_action(:lock)
-      expect(dnf_package.updated_by_last_action?).to be true
+      dnf_package "chef_rpm_provides" do
+        options default_options
+        action :lock
+      end.should_be_updated
       expect(shell_out("dnf versionlock list").stdout.chomp).to match("^chef_rpm-0:")
-      dnf_package.run_action(:lock)
-      expect(dnf_package.updated_by_last_action?).to be false
+      dnf_package "chef_rpm_provides" do
+        options default_options
+        action :lock
+      end.should_not_be_updated
     end
 
     it "check that we can unlock based on provides" do
       flush_cache
       shell_out!("dnf versionlock add chef_rpm")
-      dnf_package.package_name("chef_rpm_provides")
-      dnf_package.run_action(:unlock)
-      expect(dnf_package.updated_by_last_action?).to be true
+      dnf_package "chef_rpm_provides" do
+        options default_options
+        action :unlock
+      end.should_be_updated
       expect(shell_out("dnf versionlock list").stdout.chomp).not_to match("^chef_rpm-0:")
-      dnf_package.run_action(:unlock)
-      expect(dnf_package.updated_by_last_action?).to be false
+      dnf_package "chef_rpm_provides" do
+        options default_options
+        action :unlock
+      end.should_not_be_updated
     end
   end
 end