chef 16.10.17-universal-mingw32 → 17.1.35-universal-mingw32

data/spec/functional/resource/group_spec.rb

@@ -72,7 +72,7 @@ describe Chef::Resource::Group, :requires_root_or_running_windows do
   end
 
   def windows_domain_user?(user_name)
-    domain, user = user_name.split('\\')
+    domain, user = user_name.split("\\")
 
     if user && domain != "."
       computer_name = ENV["computername"]

data/spec/functional/resource/link_spec.rb

@@ -84,7 +84,7 @@ describe Chef::Resource::Link do
   end
 
   def canonicalize(path)
-    windows? ? path.tr("/", '\\') : path
+    windows? ? path.tr("/", "\\") : path
   end
 
   def symlink(a, b)

data/spec/functional/resource/registry_spec.rb

@@ -127,12 +127,12 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     @new_resource.cookbook_version(@cookbook_version)
   end
 
-  after (:all) do
+  after(:all) do
     clean_registry
   end
 
   context "when action is create" do
-    before (:all) do
+    before(:all) do
       reset_registry
     end
     it "creates registry key, value if the key is missing" do
@@ -290,7 +290,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     context "while running in whyrun mode" do
-      before (:each) do
+      before(:each) do
         Chef::Config[:why_run] = true
       end
 
@@ -342,7 +342,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
   end
 
   context "when action is create_if_missing" do
-    before (:all) do
+    before(:all) do
       reset_registry
     end
 
@@ -454,7 +454,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     context "while running in whyrun mode" do
-      before (:each) do
+      before(:each) do
         Chef::Config[:why_run] = true
       end
 
@@ -576,7 +576,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
     end
 
     context "while running in whyrun mode" do
-      before (:each) do
+      before(:each) do
         Chef::Config[:why_run] = true
       end
       it "does nothing if the action is delete" do
@@ -591,7 +591,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
   end
 
   context "when the action is delete_key" do
-    before (:all) do
+    before(:all) do
       reset_registry
       create_deletable_keys
     end
@@ -653,7 +653,7 @@ describe Chef::Resource::RegistryKey, :windows_only, broken: true do
       expect(@report["total_res_count"]).to eq("1")
     end
     context "while running in whyrun mode" do
-      before (:each) do
+      before(:each) do
         Chef::Config[:why_run] = true
       end
 

data/spec/functional/resource/remote_file_spec.rb

@@ -155,7 +155,7 @@ describe Chef::Resource::RemoteFile do
       before do
         shell_out("net.exe share #{smb_share_name} /delete")
         File.write(smb_file_local_path, smb_file_content )
-        shell_out!("net.exe share #{smb_share_name}=\"#{smb_share_root_directory.tr("/", '\\')}\" /grant:\"authenticated users\",read")
+        shell_out!("net.exe share #{smb_share_name}=\"#{smb_share_root_directory.tr("/", "\\")}\" /grant:\"authenticated users\",read")
       end
 
       after do

data/spec/functional/resource/user/mac_user_spec.rb

@@ -19,9 +19,9 @@ require "spec_helper"
 require "chef/mixin/shell_out"
 
 metadata = {
-  macos_gte_1014: true,
   requires_root: true,
-}
+  macos_only: true,
+ }
 
 describe "Chef::Resource::User with Chef::Provider::User::MacUser provider", metadata do
   include Chef::Mixin::ShellOut

data/spec/functional/resource/windows_certificate_spec.rb

@@ -22,26 +22,44 @@ require "chef/resource/windows_certificate"
 describe Chef::Resource::WindowsCertificate, :windows_only do
   include Chef::Mixin::PowershellExec
 
-  def create_store
+  def create_store(store_location: "LocalMachine", store_name: store)
     powershell_exec <<~EOC
-      New-Item -Path Cert:\\LocalMachine\\#{store}
+      New-Item -Path Cert:\\#{store_location}\\#{store_name}
     EOC
   end
 
-  def delete_store
+  def delete_store(store_location: "LocalMachine", store_name: store)
     powershell_exec <<~EOC
-      Remove-Item -Path Cert:\\LocalMachine\\#{store} -Recurse
+      Remove-Item -Path Cert:\\#{store_location}\\#{store_name} -Recurse
     EOC
   end
 
-  def certificate_count
+  def certificate_count(store_location: "LocalMachine", store_name: store)
     powershell_exec(<<~EOC).result.to_i
-      (Get-ChildItem -Force -Path Cert:\\LocalMachine\\#{store} | measure).Count
+      (Get-ChildItem -Force -Path Cert:\\#{store_location}\\#{store_name} | measure).Count
+    EOC
+  end
+
+  def list_certificates(store_location: "LocalMachine", store_name: store)
+    powershell_exec(<<~EOC)
+      Get-ChildItem -Force -Path Cert:\\#{store_location}\\#{store_name} -Recurse
+    EOC
+  end
+
+  def refresh_certstore(store_location: "LocalMachine")
+    powershell_exec(<<~EOC)
+      Get-ChildItem -Force -Path Cert:\\#{store_location} -Recurse
     EOC
   end
 
   let(:password) { "P@ssw0rd!" }
   let(:store) { "Chef-Functional-Test" }
+  let(:store_name) { "MY" }
+  let(:store_location) { "LocalMachine" }
+  let(:download_cert_url) { "https://testingchef.blob.core.windows.net/files/test.cer" }
+  let(:cert_output_path) { ::File.join(Chef::Config[:file_cache_path], "output.cer") }
+  let(:pfx_output_path) { ::File.join(Chef::Config[:file_cache_path], "output.pfx") }
+  let(:key_output_path) { ::File.join(Chef::Config[:file_cache_path], "output.key") }
   let(:cer_path) { File.join(CHEF_SPEC_DATA, "windows_certificates", "test.cer") }
   let(:base64_path) { File.join(CHEF_SPEC_DATA, "windows_certificates", "base64_test.cer") }
   let(:pem_path) { File.join(CHEF_SPEC_DATA, "windows_certificates", "test.pem") }
@@ -68,12 +86,16 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
       .and_return(true)
 
     create_store
+
   end
 
   after { delete_store }
 
   describe "action: create" do
     it "starts with no certificates" do
+      delete_store
+      create_store
+      foo = list_certificates
       expect(certificate_count).to eq(0)
     end
 
@@ -103,6 +125,14 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
       expect(resource).to be_updated_by_last_action
     end
 
+    it "can add a certificate from a valid url" do
+      resource.source = download_cert_url
+      resource.run_action(:create)
+
+      expect(certificate_count).to eq(1)
+      expect(resource).to be_updated_by_last_action
+    end
+
     it "can add a base64 encoded certificate idempotently" do
       resource.source = base64_path
       resource.run_action(:create)
@@ -157,9 +187,13 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
 
       expect { resource.run_action(:create) }.to raise_error(OpenSSL::PKCS12::PKCS12Error)
     end
+    after { delete_store }
   end
 
   describe "action: verify" do
+    before do
+      create_store
+    end
     it "fails with no certificates in the store" do
       expect(Chef::Log).to receive(:info).with("Certificate not found")
 
@@ -230,13 +264,13 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
   end
 
   describe "action: fetch" do
-    it "does nothing with no certificates in the store" do
-      expect(Chef::Log).not_to receive(:info)
-
-      resource.source = tests_thumbprint
-      resource.run_action(:fetch)
-
-      expect(resource).not_to be_updated_by_last_action
+    context "with no certificate in the store" do
+      it "throws an error with no certificates in the store" do
+        expect(Chef::Log).not_to receive(:info)
+        resource.source = others_thumbprint
+        resource.output_path = cert_output_path
+        expect { resource.run_action :fetch }.to raise_error(ArgumentError)
+      end
     end
 
     context "with a certificate in the store" do
@@ -247,18 +281,10 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
 
       it "succeeds with a valid thumbprint" do
         resource.source = tests_thumbprint
-
-        Dir.mktmpdir do |dir|
-          path = File.join(dir, "test.pem")
-          expect(Chef::Log).to receive(:info).with("Certificate export in #{path}")
-
-          resource.cert_path = path
-          resource.run_action(:fetch)
-
-          expect(File.exist?(path)).to be_truthy
-        end
-
-        expect(resource).not_to be_updated_by_last_action
+        local_output_path = ::File.join(Chef::Config[:file_cache_path], "test.pem")
+        resource.output_path = local_output_path
+        resource.run_action(:fetch)
+        expect(File.exist?(local_output_path)).to be_truthy
       end
 
       it "fails with an invalid thumbprint" do
@@ -269,23 +295,54 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
         Dir.mktmpdir do |dir|
           path = File.join(dir, "test.pem")
 
-          resource.cert_path = path
-          resource.run_action(:fetch)
-
-          expect(File.exist?(path)).to be_falsy
+          resource.output_path = path
+          expect { resource.run_action :fetch }.to raise_error(ArgumentError)
         end
 
-        expect(resource).not_to be_updated_by_last_action
       end
     end
+
+    context "with a pfx/pkcs12 object in the store" do
+      before do
+        create_store
+        refresh_certstore
+        resource.source = pfx_path
+        resource.pfx_password = password
+        resource.exportable = true
+        resource.run_action(:create)
+      end
+
+      it "exports a PFX file with a valid thumbprint" do
+        resource.source = tests_thumbprint
+        resource.pfx_password = password
+        resource.output_path = pfx_output_path
+        resource.run_action(:fetch)
+        expect(File.exist?(pfx_output_path)).to be_truthy
+      end
+
+      it "exports a key file with a valid thumbprint" do
+        resource.source = tests_thumbprint
+        resource.pfx_password = password
+        resource.output_path = key_output_path
+        resource.run_action(:fetch)
+        expect(File.exist?(key_output_path)).to be_truthy
+      end
+
+      it "throws an exception when output_path is not specified" do
+        resource.source = tests_thumbprint
+        resource.pfx_password = password
+        expect { resource.run_action :fetch }.to raise_error(::Chef::Exceptions::ResourceNotFound)
+      end
+
+      after { delete_store }
+
+    end
   end
 
   describe "action: delete" do
-    it "does nothing when attempting to delete a certificate that doesn't exist" do
-      expect(Chef::Log).to receive(:debug).with("Certificate not found")
-
+    it "throws an argument error when attempting to delete a certificate that doesn't exist" do
       resource.source = tests_thumbprint
-      resource.run_action(:delete)
+      expect { resource.run_action :delete }.to raise_error(ArgumentError)
     end
 
     it "deletes an existing certificate while leaving other certificates alone" do
@@ -303,7 +360,7 @@ describe Chef::Resource::WindowsCertificate, :windows_only do
       expect(certificate_count).to eq(1)
       expect(resource).to be_updated_by_last_action
 
-      resource.run_action(:delete)
+      expect { resource.run_action :delete }.to raise_error(ArgumentError)
       expect(certificate_count).to eq(1)
       expect(resource).not_to be_updated_by_last_action
 

data/spec/functional/resource/windows_env_spec.rb

@@ -38,7 +38,7 @@ describe Chef::Resource::WindowsEnv, :windows_only do
       if environment_variables && environment_variables.length > 0
         environment_variables.each do |env|
           env_obj = env.wmi_ole_object
-          return env_obj if env_obj.username.split('\\').last.casecmp(test_resource.user) == 0
+          return env_obj if env_obj.username.split("\\").last.casecmp(test_resource.user) == 0
         end
       end
       nil
@@ -93,7 +93,7 @@ describe Chef::Resource::WindowsEnv, :windows_only do
         test_resource.value(env_value1)
         test_resource.user(env_user)
         test_resource.run_action(:create)
-        expect(env_obj.username.split('\\').last.upcase).to eq(env_user)
+        expect(env_obj.username.split("\\").last.upcase).to eq(env_user)
       end
 
       context "when env variable exist with same name" do

data/spec/functional/resource/yum_package_spec.rb

@@ -19,8 +19,9 @@ require "spec_helper"
 require "chef/mixin/shell_out"
 
 # run this test only for following platforms.
-exclude_test = !(%w{rhel fedora amazon}.include?(ohai[:platform_family]) && !File.exist?("/usr/bin/dnf"))
+exclude_test = !(%w{rhel fedora amazon}.include?(OHAI_SYSTEM[:platform_family]) && !File.exist?("/usr/bin/dnf"))
 describe Chef::Resource::YumPackage, :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
@@ -38,11 +39,17 @@ describe Chef::Resource::YumPackage, :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!("yum -y install yum-utils")
   end
 
   before(:each) do
+    # force errors to fail and not retry
+    ENV["YUM_HELPER_NO_RETRIES"] = "true"
     File.open("/etc/yum.repos.d/chef-yum-localtesting.repo", "w+") do |f|
       f.write <<~EOF
         [chef-yum-localtesting]
@@ -52,6 +59,7 @@ describe Chef::Resource::YumPackage, :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 dnf garbage left around
@@ -63,137 +71,133 @@ describe Chef::Resource::YumPackage, :requires_root, external: exclude_test do
     FileUtils.rm_f "/etc/yum.repos.d/chef-yum-localtesting.repo"
   end
 
-  let(:run_context) do
-    Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
-  end
-
-  let(:package_name) { "chef_rpm" }
-  let(:yum_package) do
-    r = Chef::Resource::YumPackage.new(package_name, run_context)
-    r.options("--nogpgcheck")
-    r
-  end
+  let(:default_options) { "--nogpgcheck --disablerepo=* --enablerepo=chef-yum-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
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "does not install twice" do
         flush_cache
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
+        yum_package("chef_rpm") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.i686$")
+        yum_package("chef_rpm") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.i686$")
       end
     end
 
     context "with versions or globs in the name" do
       it "works with a version" do
         flush_cache
-        yum_package.package_name("chef_rpm-1.10")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm-1.10") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "works with an older version" do
         flush_cache
-        yum_package.package_name("chef_rpm-1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm-1.2") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "works with an evra" do
         flush_cache
-        yum_package.package_name("chef_rpm-0:1.2-1.#{pkg_arch}")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm-0:1.2-1.#{pkg_arch}") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "works with version and release" do
         flush_cache
-        yum_package.package_name("chef_rpm-1.2-1")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm-1.2-1") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "works with a version glob" do
         flush_cache
-        yum_package.package_name("chef_rpm-1*")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm-1*") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "works with a name glob + version glob" do
         flush_cache
-        yum_package.package_name("chef_rp*-1*")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rp*-1*") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "upgrades when the installed version does not match the version string" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.package_name("chef_rpm-1.10")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}")
+        yum_package("chef_rpm-1.10") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}")
       end
 
       it "downgrades when the installed version is higher than the package_name version" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.allow_downgrade true
-        yum_package.package_name("chef_rpm-1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm-1.2") do
+          allow_downgrade true
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
 
@@ -201,11 +205,11 @@ describe Chef::Resource::YumPackage, :requires_root, external: exclude_test do
     context "with version property" do
       it "matches the full version" do
         flush_cache
-        yum_package.package_name("chef_rpm")
-        yum_package.version("1.10")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+          version("1.10")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "matches with a glob" do
@@ -213,49 +217,49 @@ describe Chef::Resource::YumPackage, :requires_root, external: exclude_test do
         # the name field rather than trying to use a name of "tcpdump" and a version of "4*".
         pending "this does not work, is not easily supported by the underlying yum libraries, but does work in the new dnf_package provider"
         flush_cache
-        yum_package.package_name("chef_rpm")
-        yum_package.version("1*")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+          version("1*")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "matches the vr" do
         flush_cache
-        yum_package.package_name("chef_rpm")
-        yum_package.version("1.10-1")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+          version("1.10-1")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "matches the evr" do
         flush_cache
-        yum_package.package_name("chef_rpm")
-        yum_package.version("0:1.10-1")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+          version("0:1.10-1")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "matches with a vr glob" do
         pending "doesn't work on command line either"
         flush_cache
-        yum_package.package_name("chef_rpm")
-        yum_package.version("1.10-1*")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+          version("1.10-1*")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "matches with an evr glob" do
         pending "doesn't work on command line either"
         flush_cache
-        yum_package.package_name("chef_rpm")
-        yum_package.version("0:1.10-1*")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+          version("0:1.10-1*")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
     end
 
@@ -263,249 +267,257 @@ describe Chef::Resource::YumPackage, :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")
-        yum_package.package_name("chef_rpm")
-        yum_package.allow_downgrade true
-        yum_package.version("1.2-1")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+          allow_downgrade true
+          version("1.2-1")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
 
     context "with arches", :intel_64bit do
       it "installs with 64-bit arch in the name" do
         flush_cache
-        yum_package.package_name("chef_rpm.#{pkg_arch}")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm.#{pkg_arch}") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "installs with 32-bit arch in the name" do
         flush_cache
-        yum_package.package_name("chef_rpm.i686")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
+        yum_package("chef_rpm.i686") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.i686$")
       end
 
       it "installs with 64-bit arch in the property" do
         flush_cache
-        yum_package.package_name("chef_rpm")
-        yum_package.arch((pkg_arch).to_s)
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm") do
+          options default_options
+          arch((pkg_arch).to_s)
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "installs with 32-bit arch in the property" do
         flush_cache
-        yum_package.package_name("chef_rpm")
-        yum_package.arch("i686")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
+        yum_package("chef_rpm") do
+          options default_options
+          arch("i686")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.i686$")
       end
     end
 
     context "with constraints" do
       it "with nothing installed, it installs the latest version" do
         flush_cache
-        yum_package.package_name("chef_rpm >= 1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm >= 1.2") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "when it is met, it does nothing" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.package_name("chef_rpm >= 1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm >= 1.2") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.package_name("chef_rpm >= 1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm >= 1.2") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "with nothing intalled, it installs the latest version" do
         flush_cache
-        yum_package.package_name("chef_rpm > 1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm > 1.2") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "when it is not met by an installed rpm, it upgrades" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.package_name("chef_rpm > 1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm > 1.2") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       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")
-        yum_package.package_name("chef_rpm = 1.10")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm = 1.10") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       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")
-        yum_package.package_name("chef_rpm = 1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm = 1.2") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.package_name("chef_rpm > 1.2")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm > 1.2") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
-      it "when there is no solution to the contraint" do
+      it "when there is no solution to the constraint" do
         flush_cache
-        yum_package.package_name("chef_rpm > 2.0")
-        expect { yum_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          yum_package("chef_rpm > 2.0") do
+            options default_options
+          end
+        }.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
+      it "when there is no solution to the constraint but an rpm is preinstalled" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.package_name("chef_rpm > 2.0")
-        expect { yum_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          yum_package("chef_rpm > 2.0") do
+            options default_options
+          end
+        }.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
-        yum_package.allow_downgrade true
-        yum_package.package_name("chef_rpm < 1.10")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm < 1.10") do
+          allow_downgrade true
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       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")
-        yum_package.allow_downgrade true
-        yum_package.package_name("chef_rpm < 1.10")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm < 1.10") do
+          allow_downgrade true
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.allow_downgrade true
-        yum_package.package_name("chef_rpm < 1.10")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm < 1.10") do
+          allow_downgrade true
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
 
     context "with source arguments" do
       it "raises an exception when the package does not exist" do
         flush_cache
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/this-file-better-not-exist.rpm")
-        expect { yum_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/this-file-better-not-exist.rpm") do
+            options default_options
+          end
+        }.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
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/this-file-better-not-exist.rpm")
-        yum_package.run_action(:install)
-        expect { yum_package.run_action(:install) }.not_to raise_error
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/this-file-better-not-exist.rpm") do
+          options default_options
+        end
       end
 
       it "installs the package when using the source argument" do
         flush_cache
-        yum_package.name "something"
-        yum_package.package_name "somethingelse"
-        yum_package.source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package "something" do
+          package_name "somethingelse"
+          source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "installs the package when the name is a path to a file" do
         flush_cache
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "downgrade on a local file is ignored when allow_downgrade is false" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.allow_downgrade false
-        yum_package.version "1.2-1"
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          allow_downgrade false
+          version "1.2-1"
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "downgrade on a local file with allow_downgrade true works" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.version "1.2-1"
-        yum_package.allow_downgrade true
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          version "1.2-1"
+          allow_downgrade true
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "does not downgrade the package with :install" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.version "1.2-1"
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          version "1.2-1"
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "is idempotent when the package is already installed and there is a version string with arch" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.version "1.2-1.#{pkg_arch}"
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          version "1.2-1.#{pkg_arch}"
+          options default_options
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
 
@@ -513,124 +525,132 @@ describe Chef::Resource::YumPackage, :requires_root, external: exclude_test do
       it "works when a package is installed" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-yum-localtesting.repo"
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package "chef_rpm" do
+          options "--nogpgcheck"
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "works with a local source" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-yum-localtesting.repo"
         flush_cache
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          options "--nogpgcheck"
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
 
     context "multipackage with arches", :intel_64bit do
       it "installs two rpms" do
         flush_cache
-        yum_package.package_name([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] )
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        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$/)
+        yum_package([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] ) do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version(/^chef_rpm-1.10-1.#{pkg_arch}$/)
+        expect_matching_installed_version(/^chef_rpm-1.10-1.i686$/)
       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
-        yum_package.package_name([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] )
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
+        yum_package([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] ) do
+          options default_options
+        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")
-        yum_package.package_name([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] )
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        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$/)
+        yum_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version(/^chef_rpm-1.10-1.#{pkg_arch}$/)
+        expect_matching_installed_version(/^chef_rpm-1.10-1.i686$/)
       end
 
       it "installs the first rpm if the second is installed" do
         preinstall("chef_rpm-1.10-1.i686.rpm")
-        yum_package.package_name([ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] )
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        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$/)
+        yum_package [ "chef_rpm.#{pkg_arch}", "chef_rpm.i686" ] do
+          options default_options
+        end.should_be_updated
+        expect_matching_installed_version(/^chef_rpm-1.10-1.#{pkg_arch}$/)
+        expect_matching_installed_version(/^chef_rpm-1.10-1.i686$/)
       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
-        yum_package.package_name(%w{chef_rpm chef_rpm} )
-        yum_package.arch([pkg_arch, "i686"])
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        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$/)
+        yum_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+        end.should_be_updated
+        expect_matching_installed_version(/^chef_rpm-1.10-1.#{pkg_arch}$/)
+        expect_matching_installed_version(/^chef_rpm-1.10-1.i686$/)
       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")
-        yum_package.package_name(%w{chef_rpm chef_rpm} )
-        yum_package.arch([pkg_arch, "i686"])
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        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$/)
+        yum_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+        end.should_be_updated
+        expect_matching_installed_version(/^chef_rpm-1.10-1.#{pkg_arch}$/)
+        expect_matching_installed_version(/^chef_rpm-1.10-1.i686$/)
       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")
-        yum_package.package_name(%w{chef_rpm chef_rpm} )
-        yum_package.arch([pkg_arch, "i686"])
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        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$/)
+        yum_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+        end.should_be_updated
+        expect_matching_installed_version(/^chef_rpm-1.10-1.#{pkg_arch}$/)
+        expect_matching_installed_version(/^chef_rpm-1.10-1.i686$/)
       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")
-        yum_package.package_name(%w{chef_rpm chef_rpm} )
-        yum_package.arch([pkg_arch, "i686"])
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be false
+        yum_package %w{chef_rpm chef_rpm} do
+          options default_options
+          arch [pkg_arch, "i686"]
+        end.should_not_be_updated
       end
     end
 
     context "repo controls" do
       it "should fail with the repo disabled" do
         flush_cache
-        yum_package.options("--disablerepo=chef-yum-localtesting")
-        expect { yum_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          yum_package "chef_rpm" do
+            options "--nogpgcheck --disablerepo=chef-yum-localtesting"
+          end
+        }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
       end
 
       it "should work with disablerepo first" do
         flush_cache
-        yum_package.options(["--disablerepo=*", "--enablerepo=chef-yum-localtesting"])
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package "chef_rpm" do
+          options "--nogpgcheck --disablerepo=* --enablerepo=chef-yum-localtesting"
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "should work to enable a disabled repo" do
         shell_out!("yum-config-manager --disable chef-yum-localtesting")
         flush_cache
-        expect { yum_package.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
+        expect {
+          yum_package "chef_rpm" do
+            options "--nogpgcheck"
+          end
+        }.to raise_error(Chef::Exceptions::Package, /No candidate version available/)
         flush_cache
-        yum_package.options("--enablerepo=chef-yum-localtesting")
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package "chef_rpm" do
+          options "--nogpgcheck --enablerepo=chef-yum-localtesting"
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "when an idempotent install action is run, does not leave repos disabled" do
@@ -640,17 +660,17 @@ describe Chef::Resource::YumPackage, :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")
-        yum_package.options("--disablerepo=chef-yum-localtesting")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package "chef_rpm" do
+          options "--nogpgcheck --disablerepo=chef-yum-localtesting"
+          action :upgrade
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
         # now we're still using the same cache in the yum_helper.py cache and we test to see if the
         # repo that we temporarily disabled is enabled on this pass.
-        yum_package.package_name("chef_rpm-1.10-1.#{pkg_arch}")
-        yum_package.options(nil)
-        yum_package.run_action(:install)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm-1.10-1.#{pkg_arch}") do
+          options "--nogpgcheck"
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
     end
   end
@@ -660,45 +680,49 @@ describe Chef::Resource::YumPackage, :requires_root, external: exclude_test do
     context "with source arguments" do
       it "installs the package when using the source argument" do
         flush_cache
-        yum_package.name "something"
-        yum_package.package_name "somethingelse"
-        yum_package.source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package "something" do
+          package_name "somethingelse"
+          source("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "installs the package when the name is a path to a file" do
         flush_cache
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "downgrades the package when allow_downgrade is true" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.allow_downgrade true
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          allow_downgrade true
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "upgrades the package" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.10-1.#{pkg_arch}.rpm") do
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "is idempotent when the package is already installed" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_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_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
 
@@ -706,204 +730,239 @@ describe Chef::Resource::YumPackage, :requires_root, external: exclude_test do
       it "works when a package is installed" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-yum-localtesting.repo"
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          options "--nogpgcheck"
+          action :upgrade
+        end.should_not_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "works with a local source" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-yum-localtesting.repo"
         flush_cache
-        yum_package.package_name("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("#{CHEF_SPEC_ASSETS}/yumrepo/chef_rpm-1.2-1.#{pkg_arch}.rpm") do
+          options "--nogpgcheck"
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
     end
 
     context "version pinning" do
       it "with an equality pin in the name it upgrades a prior package" do
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.package_name("chef_rpm-1.10")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm-1.10") do
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       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")
-        yum_package.package_name("chef_rpm == 1.10")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm == 1.10") do
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "with an equality pin in the name it downgrades a later package" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.allow_downgrade true
-        yum_package.package_name("chef_rpm-1.2")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm-1.2") do
+          allow_downgrade true
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       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")
-        yum_package.allow_downgrade true
-        yum_package.package_name("chef_rpm == 1.2")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm == 1.2") do
+          allow_downgrade true
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       end
 
       it "with a > pin in the name and no rpm installed it installs" do
         flush_cache
-        yum_package.package_name("chef_rpm > 1.2")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm > 1.2") do
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
 
       it "with a < pin in the name and no rpm installed it installs" do
         flush_cache
-        yum_package.package_name("chef_rpm < 1.10")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm < 1.10") do
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       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")
-        yum_package.package_name("chef_rpm > 1.2")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm > 1.2") do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.package_name("chef_rpm < 1.10")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm < 1.10") do
+          options default_options
+          action :upgrade
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.package_name("chef_rpm > 1.2")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package("chef_rpm > 1.2") do
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       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")
-        yum_package.allow_downgrade true
-        yum_package.package_name("chef_rpm < 1.10")
-        yum_package.run_action(:upgrade)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.#{pkg_arch}$")
+        yum_package("chef_rpm < 1.10") do
+          allow_downgrade true
+          options default_options
+          action :upgrade
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.2-1.#{pkg_arch}$")
       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
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^package chef_rpm is not installed$")
       end
 
       it "does not remove the package twice" do
         preinstall("chef_rpm-1.10-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^package chef_rpm is not installed$")
+        yum_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^package chef_rpm is not installed$")
       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")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^package chef_rpm is not installed$")
       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")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm" do
+          options default_options
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^package chef_rpm is not installed$")
       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
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^package chef_rpm is not installed$")
       end
 
       it "does nothing if the i686 package is installed" do
         preinstall("chef_rpm-1.10-1.i686.rpm")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.i686$")
+        yum_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be false
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.2-1.i686$")
+        yum_package "chef_rpm.#{pkg_arch}" do
+          options default_options
+          action :remove
+        end.should_not_be_updated
+        expect_matching_installed_version("^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")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^chef_rpm-1.10-1.#{pkg_arch}$")
+        yum_package "chef_rpm.i686" do
+          options default_options
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^chef_rpm-1.10-1.#{pkg_arch}$")
       end
     end
 
@@ -911,9 +970,11 @@ describe Chef::Resource::YumPackage, :requires_root, external: exclude_test do
       it "works when a package is installed" do
         FileUtils.rm_f "/etc/yum.repos.d/chef-yum-localtesting.repo"
         preinstall("chef_rpm-1.2-1.#{pkg_arch}.rpm")
-        yum_package.run_action(:remove)
-        expect(yum_package.updated_by_last_action?).to be true
-        expect(shell_out("rpm -q --queryformat '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}\n' chef_rpm").stdout.chomp).to match("^package chef_rpm is not installed$")
+        yum_package "chef_rpm" do
+          options "--nogpgcheck"
+          action :remove
+        end.should_be_updated
+        expect_matching_installed_version("^package chef_rpm is not installed$")
       end
     end
   end
@@ -929,52 +990,58 @@ describe Chef::Resource::YumPackage, :requires_root, external: exclude_test do
 
     it "locks an rpm" do
       flush_cache
-      yum_package.package_name("chef_rpm")
-      yum_package.run_action(:lock)
-      expect(yum_package.updated_by_last_action?).to be true
+      yum_package("chef_rpm") do
+        options default_options
+        action :lock
+      end.should_be_updated
       expect(shell_out("yum versionlock list").stdout.chomp).to match("^0:chef_rpm-")
     end
 
     it "does not lock if its already locked" do
       flush_cache
       shell_out!("yum versionlock add chef_rpm")
-      yum_package.package_name("chef_rpm")
-      yum_package.run_action(:lock)
-      expect(yum_package.updated_by_last_action?).to be false
+      yum_package("chef_rpm") do
+        options default_options
+        action :lock
+      end.should_not_be_updated
       expect(shell_out("yum versionlock list").stdout.chomp).to match("^0:chef_rpm-")
     end
 
     it "unlocks an rpm" do
       flush_cache
       shell_out!("yum versionlock add chef_rpm")
-      yum_package.package_name("chef_rpm")
-      yum_package.run_action(:unlock)
-      expect(yum_package.updated_by_last_action?).to be true
+      yum_package("chef_rpm") do
+        options default_options
+        action :unlock
+      end.should_be_updated
       expect(shell_out("yum versionlock list").stdout.chomp).not_to match("^0:chef_rpm-")
     end
 
     it "does not unlock an already locked rpm" do
       flush_cache
-      yum_package.package_name("chef_rpm")
-      yum_package.run_action(:unlock)
-      expect(yum_package.updated_by_last_action?).to be false
+      yum_package("chef_rpm") do
+        options default_options
+        action :unlock
+      end.should_not_be_updated
       expect(shell_out("yum versionlock list").stdout.chomp).not_to match("^0:chef_rpm-")
     end
 
     it "check that we can lock based on provides" do
       flush_cache
-      yum_package.package_name("chef_rpm_provides")
-      yum_package.run_action(:lock)
-      expect(yum_package.updated_by_last_action?).to be true
+      yum_package("chef_rpm_provides") do
+        options default_options
+        action :lock
+      end.should_be_updated
       expect(shell_out("yum versionlock list").stdout.chomp).to match("^0:chef_rpm-")
     end
 
     it "check that we can unlock based on provides" do
       flush_cache
       shell_out!("yum versionlock add chef_rpm")
-      yum_package.package_name("chef_rpm_provides")
-      yum_package.run_action(:unlock)
-      expect(yum_package.updated_by_last_action?).to be true
+      yum_package("chef_rpm_provides") do
+        options default_options
+        action :unlock
+      end.should_be_updated
       expect(shell_out("yum versionlock list").stdout.chomp).not_to match("^0:chef_rpm-")
     end
   end