chef 12.4.0.rc.0-universal-mingw32 → 12.4.0.rc.2-universal-mingw32

data/spec/unit/provider/remote_file/local_file_spec.rb

@@ -25,26 +25,45 @@ describe Chef::Provider::RemoteFile::LocalFile do
   let(:new_resource) { Chef::Resource::RemoteFile.new("local file backend test (new_resource)") }
   let(:current_resource) { Chef::Resource::RemoteFile.new("local file backend test (current_resource)") }
   subject(:fetcher) { Chef::Provider::RemoteFile::LocalFile.new(uri, new_resource, current_resource) }
-  
-  context "when parsing source path" do
+
+  context "when parsing source path on windows" do
+
+    before do
+      allow(Chef::Platform).to receive(:windows?).and_return(true)
+    end
+
     describe "when given local unix path" do
       let(:uri) { URI.parse("file:///nyan_cat.png") }
       it "returns a correct unix path" do
-        expect(fetcher.fix_windows_path(uri.path)).to eq("/nyan_cat.png")
+        expect(fetcher.source_path).to eq("/nyan_cat.png")
       end
     end
 
     describe "when given local windows path" do
       let(:uri) { URI.parse("file:///z:/windows/path/file.txt") }
       it "returns a valid windows local path" do
-        expect(fetcher.fix_windows_path(uri.path)).to eq("z:/windows/path/file.txt")
+        expect(fetcher.source_path).to eq("z:/windows/path/file.txt")
+      end
+    end
+
+    describe "when given local windows path with spaces" do
+      let(:uri) { URI.parse(URI.escape("file:///z:/windows/path/foo & bar.txt")) }
+      it "returns a valid windows local path" do
+        expect(fetcher.source_path).to eq("z:/windows/path/foo & bar.txt")
       end
     end
 
     describe "when given unc windows path" do
       let(:uri) { URI.parse("file:////server/share/windows/path/file.txt") }
       it "returns a valid windows unc path" do
-        expect(fetcher.fix_windows_path(uri.path)).to eq("//server/share/windows/path/file.txt")
+        expect(fetcher.source_path).to eq("//server/share/windows/path/file.txt")
+      end
+    end
+
+    describe "when given unc windows path with spaces" do
+      let(:uri) { URI.parse(URI.escape("file:////server/share/windows/path/foo & bar.txt")) }
+      it "returns a valid windows unc path" do
+        expect(fetcher.source_path).to eq("//server/share/windows/path/foo & bar.txt")
       end
     end
   end
@@ -73,7 +92,7 @@ describe Chef::Provider::RemoteFile::LocalFile do
     it "stages the local file to a temporary file" do
       expect(Chef::FileContentManagement::Tempfile).to receive(:new).with(new_resource).and_return(chef_tempfile)
       expect(::FileUtils).to receive(:cp).with(uri.path, tempfile.path)
-      expect(tempfile).to receive(:close)            
+      expect(tempfile).to receive(:close)
 
       result = fetcher.fetch
       expect(result).to eq(tempfile)

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

@@ -189,18 +189,6 @@ PS_SAMPLE
         expect(provider.status_load_success).to be_nil
       end
 
-      context "when ps command is nil" do
-        before do
-          node.automatic_attrs[:command] = {:ps => nil}
-        end
-
-        it "should set running to nil" do
-          pending "superclass raises no conversion of nil to string which seems broken"
-          provider.determine_current_status!
-          expect(current_resource.running).to be_nil
-        end
-      end
-
       context "when ps is empty string" do
         before do
           node.automatic_attrs[:command] = {:ps => ""}

data/spec/unit/provider/user_spec.rb

@@ -143,8 +143,8 @@ describe Chef::Provider::User do
         begin
           require 'rubygems'
           require 'shadow'
-        rescue LoadError => e
-          pending "ruby-shadow gem not installed for dynamic load test"
+        rescue LoadError
+          skip "ruby-shadow gem not installed for dynamic load test"
           true
         else
           false
@@ -161,7 +161,7 @@ describe Chef::Provider::User do
 
       unless shadow_lib_unavail?
         context "and we have the ruby-shadow gem" do
-          pending "and we are not root (rerun this again as root)", :requires_unprivileged_user => true
+          skip "and we are not root (rerun this again as root)", :requires_unprivileged_user => true
 
           context "and we are root", :requires_root => true do
             it "should pass assertions when ruby-shadow can be loaded" do

data/spec/unit/provider_resolver_spec.rb

@@ -19,9 +19,13 @@
 require 'spec_helper'
 require 'chef/mixin/convert_to_class_name'
 require 'chef/provider_resolver'
+require 'chef/platform/service_helpers'
 
 include Chef::Mixin::ConvertToClassName
 
+# Open up Provider so we can write things down easier in here
+#module Chef::Provider
+
 describe Chef::ProviderResolver do
 
   let(:node) do
@@ -50,6 +54,51 @@ describe Chef::ProviderResolver do
     allow(resource).to receive(:is_a?).with(Chef::Resource).and_return(true)
   end
 
+  def self.on_platform(platform, *tags,
+    platform_version: '11.0.1',
+    platform_family: nil,
+    os: nil,
+    &block)
+    Array(platform).each do |platform|
+      Array(platform_version).each do |platform_version|
+        on_one_platform(platform, platform_version, platform_family || platform, os || platform_family || platform, *tags, &block)
+      end
+    end
+  end
+
+  def self.on_one_platform(platform, platform_version, platform_family, os, *tags, &block)
+    describe "on #{platform} #{platform_version}, platform_family: #{platform_family}, os: #{os}", *tags do
+      let(:os)               { os }
+      let(:platform)         { platform }
+      let(:platform_family)  { platform_family }
+      let(:platform_version) { platform_version }
+
+      define_singleton_method(:os) { os }
+      define_singleton_method(:platform) { platform }
+      define_singleton_method(:platform_family) { platform_family }
+      define_singleton_method(:platform_version) { platform_version }
+
+      instance_eval(&block)
+    end
+  end
+
+  def self.expect_providers(**providers)
+    providers.each do |name, provider|
+      describe name.to_s do
+        let(:resource_name) { name }
+        if provider
+          it "resolves to a #{provider}" do
+            expect(resolved_provider).to eql(provider)
+          end
+        else
+          it "Fails to resolve (since #{name.inspect} is unsupported on #{platform} #{platform_version})" do
+            expect { resolved_provider }.to raise_error /Cannot find a provider/
+          end
+        end
+      end
+    end
+  end
+
   describe "resolving service resource" do
     def stub_service_providers(*services)
       services ||= []
@@ -64,7 +113,6 @@ describe Chef::ProviderResolver do
     end
 
     before do
-      expect(provider_resolver).not_to receive(:maybe_chef_platform_lookup)
       allow(resource).to receive(:service_name).and_return("ntp")
     end
 
@@ -301,389 +349,477 @@ describe Chef::ProviderResolver do
       end
     end
 
-    describe "on Ubuntu 14.10" do
-      let(:os) { "linux" }
-      let(:platform) { "ubuntu" }
-      let(:platform_family) { "debian" }
-      let(:platform_version) { "14.04" }
-
+    on_platform "ubuntu", platform_version: "14.10", platform_family: "debian", os: "linux" do
       it_behaves_like "an ubuntu platform with upstart, update-rc.d and systemd"
     end
 
-    describe "on Ubuntu 14.04" do
-      let(:os) { "linux" }
-      let(:platform) { "ubuntu" }
-      let(:platform_family) { "debian" }
-      let(:platform_version) { "14.04" }
-
+    on_platform "ubuntu", platform_version: "14.04", platform_family: "debian", os: "linux" do
       it_behaves_like "an ubuntu platform with upstart and update-rc.d"
     end
 
-    describe "on Ubuntu 10.04" do
-      let(:os) { "linux" }
-      let(:platform) { "ubuntu" }
-      let(:platform_family) { "debian" }
-      let(:platform_version) { "10.04" }
-
+    on_platform "ubuntu", platform_version: "10.04", platform_family: "debian", os: "linux" do
       it_behaves_like "an ubuntu platform with upstart and update-rc.d"
     end
 
     # old debian uses the Debian provider (does not have insserv or upstart, or update-rc.d???)
-    describe "on Debian 4.0" do
-      let(:os) { "linux" }
-      let(:platform) { "debian" }
-      let(:platform_family) { "debian" }
-      let(:platform_version) { "4.0" }
-
+    on_platform "debian", platform_version: "4.0", os: "linux" do
       #it_behaves_like "a debian platform using the debian provider"
     end
 
     # Debian replaced the debian provider with insserv in the FIXME:VERSION distro
-    describe "on Debian 7.0" do
-      let(:os) { "linux" }
-      let(:platform) { "debian" }
-      let(:platform_family) { "debian" }
-      let(:platform_version) { "7.0" }
-
+    on_platform "debian", platform_version: "7.0", os: "linux" do
       it_behaves_like "a debian platform using the insserv provider"
     end
 
-    %w{solaris2 openindiana opensolaris nexentacore omnios smartos}.each do |platform|
-      describe "on #{platform}" do
-        let(:os) { "solaris2" }
-        let(:platform) { platform }
-        let(:platform_family) { platform }
-        let(:platform_version) { "5.11" }
-
-        it "returns a Solaris provider" do
-          stub_service_providers
-          stub_service_configs
-          expect(resolved_provider).to eql(Chef::Provider::Service::Solaris)
-        end
+    on_platform %w{solaris2 openindiana opensolaris nexentacore omnios smartos}, os: "solaris2", platform_version: "5.11" do
+      it "returns a Solaris provider" do
+        stub_service_providers
+        stub_service_configs
+        expect(resolved_provider).to eql(Chef::Provider::Service::Solaris)
+      end
 
-        it "always returns a Solaris provider" do
-          # no matter what we stub on the next two lines we should get a Solaris provider
-          stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
-          stub_service_configs(:initd, :upstart, :xinetd, :user_local_etc_rcd, :systemd)
-          expect(resolved_provider).to eql(Chef::Provider::Service::Solaris)
-        end
+      it "always returns a Solaris provider" do
+        # no matter what we stub on the next two lines we should get a Solaris provider
+        stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
+        stub_service_configs(:initd, :upstart, :xinetd, :user_local_etc_rcd, :systemd)
+        expect(resolved_provider).to eql(Chef::Provider::Service::Solaris)
       end
     end
 
-    %w{mswin mingw32 windows}.each do |platform|
-      describe "on #{platform}" do
-        let(:os) { "windows" }
-        let(:platform) { platform }
-        let(:platform_family) { "windows" }
-        let(:platform_version) { "5.11" }
-
-        it "returns a Windows provider" do
-          stub_service_providers
-          stub_service_configs
-          expect(resolved_provider).to eql(Chef::Provider::Service::Windows)
-        end
+    on_platform %w{mswin mingw32 windows}, platform_family: "windows", platform_version: "5.11" do
+      it "returns a Windows provider" do
+        stub_service_providers
+        stub_service_configs
+        expect(resolved_provider).to eql(Chef::Provider::Service::Windows)
+      end
 
-        it "always returns a Windows provider" do
-          # no matter what we stub on the next two lines we should get a Windows provider
-          stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
-          stub_service_configs(:initd, :upstart, :xinetd, :user_local_etc_rcd, :systemd)
-          expect(resolved_provider).to eql(Chef::Provider::Service::Windows)
-        end
+      it "always returns a Windows provider" do
+        # no matter what we stub on the next two lines we should get a Windows provider
+        stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
+        stub_service_configs(:initd, :upstart, :xinetd, :user_local_etc_rcd, :systemd)
+        expect(resolved_provider).to eql(Chef::Provider::Service::Windows)
       end
     end
 
-    %w{mac_os_x mac_os_x_server}.each do |platform|
-      describe "on #{platform}" do
-        let(:os) { "darwin" }
-        let(:platform) { platform }
-        let(:platform_family) { "mac_os_x" }
-        let(:platform_version) { "10.9.2" }
-
-        it "returns a Macosx provider" do
-          stub_service_providers
-          stub_service_configs
-          expect(resolved_provider).to eql(Chef::Provider::Service::Macosx)
-        end
+    on_platform %w{mac_os_x mac_os_x_server}, os: "darwin", platform_family: "mac_os_x", platform_version: "10.9.2" do
+      it "returns a Macosx provider" do
+        stub_service_providers
+        stub_service_configs
+        expect(resolved_provider).to eql(Chef::Provider::Service::Macosx)
+      end
 
-        it "always returns a Macosx provider" do
-          # no matter what we stub on the next two lines we should get a Macosx provider
-          stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
-          stub_service_configs(:initd, :upstart, :xinetd, :user_local_etc_rcd, :systemd)
-          expect(resolved_provider).to eql(Chef::Provider::Service::Macosx)
-        end
+      it "always returns a Macosx provider" do
+        # no matter what we stub on the next two lines we should get a Macosx provider
+        stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
+        stub_service_configs(:initd, :upstart, :xinetd, :user_local_etc_rcd, :systemd)
+        expect(resolved_provider).to eql(Chef::Provider::Service::Macosx)
       end
     end
 
-    %w{freebsd netbsd}.each do |platform|
-      describe "on #{platform}" do
-        let(:os) { platform }
-        let(:platform) { platform }
-        let(:platform_family) { platform }
-        let(:platform_version) { "10.0-RELEASE" }
-
-        it "returns a Freebsd provider if it finds the /usr/local/etc/rc.d initscript" do
-          stub_service_providers
-          stub_service_configs(:usr_local_etc_rcd)
-          expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
-        end
+    on_platform %w(freebsd netbsd), platform_version: '3.1.4' do
+      it "returns a Freebsd provider if it finds the /usr/local/etc/rc.d initscript" do
+        stub_service_providers
+        stub_service_configs(:usr_local_etc_rcd)
+        expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
+      end
 
-        it "returns a Freebsd provider if it finds the /etc/rc.d initscript" do
-          stub_service_providers
-          stub_service_configs(:etc_rcd)
-          expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
-        end
+      it "returns a Freebsd provider if it finds the /etc/rc.d initscript" do
+        stub_service_providers
+        stub_service_configs(:etc_rcd)
+        expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
+      end
 
-        it "always returns a Freebsd provider if it finds the /usr/local/etc/rc.d initscript" do
-          # should only care about :usr_local_etc_rcd stub in the service configs
-          stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
-          stub_service_configs(:usr_local_etc_rcd, :initd, :upstart, :xinetd, :systemd)
-          expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
-        end
+      it "always returns a Freebsd provider if it finds the /usr/local/etc/rc.d initscript" do
+        # should only care about :usr_local_etc_rcd stub in the service configs
+        stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
+        stub_service_configs(:usr_local_etc_rcd, :initd, :upstart, :xinetd, :systemd)
+        expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
+      end
 
-        it "always returns a Freebsd provider if it finds the /usr/local/etc/rc.d initscript" do
-          # should only care about :etc_rcd stub in the service configs
-          stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
-          stub_service_configs(:etc_rcd, :initd, :upstart, :xinetd, :systemd)
-          expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
-        end
+      it "always returns a Freebsd provider if it finds the /usr/local/etc/rc.d initscript" do
+        # should only care about :etc_rcd stub in the service configs
+        stub_service_providers(:debian, :invokercd, :insserv, :upstart, :redhat, :systemd)
+        stub_service_configs(:etc_rcd, :initd, :upstart, :xinetd, :systemd)
+        expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
+      end
 
-        it "foo" do
-          stub_service_providers
-          stub_service_configs
-          expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
-        end
+      it "foo" do
+        stub_service_providers
+        stub_service_configs
+        expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
       end
     end
 
   end
 
-  describe "for the package provider" do
-    let(:resource_name) { :package }
-
-    before do
-      expect(provider_resolver).not_to receive(:maybe_chef_platform_lookup)
-    end
-
-    %w{mac_os_x mac_os_x_server}.each do |platform|
-      describe "on #{platform}" do
-        let(:os) { "darwin" }
-        let(:platform) { platform }
-        let(:platform_family) { "mac_os_x" }
-        let(:platform_version) { "10.9.2" }
-
-
-        it "returns a Chef::Provider::Package::Homebrew provider" do
-          expect(resolved_provider).to eql(Chef::Provider::Package::Homebrew)
-        end
-      end
-    end
-  end
+  PROVIDERS =
+  {
+    bash: Chef::Provider::Script,
+    breakpoint: Chef::Provider::Breakpoint,
+    chef_gem: Chef::Provider::Package::Rubygems,
+    cookbook_file: Chef::Provider::CookbookFile,
+    csh: Chef::Provider::Script,
+    deploy: Chef::Provider::Deploy::Timestamped,
+    deploy_revision: Chef::Provider::Deploy::Revision,
+    directory: Chef::Provider::Directory,
+    easy_install_package: Chef::Provider::Package::EasyInstall,
+    erl_call: Chef::Provider::ErlCall,
+    execute: Chef::Provider::Execute,
+    file: Chef::Provider::File,
+    gem_package: Chef::Provider::Package::Rubygems,
+    git: Chef::Provider::Git,
+    group: Chef::Provider::Group::Gpasswd,
+    homebrew_package: Chef::Provider::Package::Homebrew,
+    http_request: Chef::Provider::HttpRequest,
+    ifconfig: Chef::Provider::Ifconfig,
+    link: Chef::Provider::Link,
+    log: Chef::Provider::Log::ChefLog,
+    macports_package: Chef::Provider::Package::Macports,
+    mdadm: Chef::Provider::Mdadm,
+    mount: Chef::Provider::Mount::Mount,
+    perl: Chef::Provider::Script,
+    portage_package: Chef::Provider::Package::Portage,
+    python: Chef::Provider::Script,
+    remote_directory: Chef::Provider::RemoteDirectory,
+    route: Chef::Provider::Route,
+    rpm_package: Chef::Provider::Package::Rpm,
+    ruby: Chef::Provider::Script,
+    ruby_block: Chef::Provider::RubyBlock,
+    script: Chef::Provider::Script,
+    subversion: Chef::Provider::Subversion,
+    template: Chef::Provider::Template,
+    timestamped_deploy: Chef::Provider::Deploy::Timestamped,
+    user: Chef::Provider::User::Useradd,
+    whyrun_safe_ruby_block: Chef::Provider::WhyrunSafeRubyBlock,
+
+    # We want to check that these are unsupported:
+    apt_package: nil,
+    bff_package: nil,
+    dsc_script: nil,
+    dpkg_package: nil,
+    ips_package: nil,
+    pacman_package: nil,
+    paludis_package: nil,
+    rpm_package: nil,
+    smartos_package: nil,
+    solaris_package: nil,
+    yum_package: nil,
+    windows_package: nil,
+    windows_service: nil,
+
+    "linux" => {
+      apt_package: Chef::Provider::Package::Apt,
+      dpkg_package: Chef::Provider::Package::Dpkg,
+      pacman_package: Chef::Provider::Package::Pacman,
+      paludis_package: Chef::Provider::Package::Paludis,
+      rpm_package: Chef::Provider::Package::Rpm,
+      yum_package: Chef::Provider::Package::Yum,
+
+      "debian" => {
+        ifconfig: Chef::Provider::Ifconfig::Debian,
+        package: Chef::Provider::Package::Apt,
+#        service: Chef::Provider::Service::Debian,
+
+        "debian" => {
+          "7.0" => {
+          },
+          "6.0" => {
+            ifconfig: Chef::Provider::Ifconfig,
+#            service: Chef::Provider::Service::Insserv,
+          },
+          "5.0" => {
+            ifconfig: Chef::Provider::Ifconfig,
+          },
+        },
+        "gcel" => {
+          "3.1.4" => {
+            ifconfig: Chef::Provider::Ifconfig,
+          },
+        },
+        "linaro" => {
+          "3.1.4" => {
+            ifconfig: Chef::Provider::Ifconfig,
+          },
+        },
+        "linuxmint" => {
+          "3.1.4" => {
+            ifconfig: Chef::Provider::Ifconfig,
+#            service: Chef::Provider::Service::Upstart,
+          },
+        },
+        "raspbian" => {
+          "3.1.4" => {
+            ifconfig: Chef::Provider::Ifconfig,
+          },
+        },
+        "ubuntu" => {
+          "11.10" => {
+          },
+          "10.04" => {
+            ifconfig: Chef::Provider::Ifconfig,
+          },
+        },
+      },
+
+      "arch" => {
+        package: Chef::Provider::Package::Pacman,
+
+        "arch" => {
+          "3.1.4" => {
+          }
+        },
+      },
+
+      "freebsd" => {
+        group: Chef::Provider::Group::Pw,
+        user: Chef::Provider::User::Pw,
+
+        "freebsd" => {
+          "3.1.4" => {
+          },
+        },
+      },
+      "suse" => {
+        group: Chef::Provider::Group::Gpasswd,
+        "suse" => {
+          "12.0" => {
+          },
+          %w(11.1 11.2 11.3) => {
+            group: Chef::Provider::Group::Suse,
+          },
+        },
+        "opensuse" => {
+#          service: Chef::Provider::Service::Redhat,
+          package: Chef::Provider::Package::Zypper,
+          group: Chef::Provider::Group::Usermod,
+          "12.3" => {
+          },
+          "12.2" => {
+            group: Chef::Provider::Group::Suse,
+          },
+        },
+      },
+
+      "gentoo" => {
+        package: Chef::Provider::Package::Portage,
+        portage_package: Chef::Provider::Package::Portage,
+#        service: Chef::Provider::Service::Gentoo,
+
+        "gentoo" => {
+          "3.1.4" => {
+          },
+        },
+      },
+
+      "rhel" => {
+#        service: Chef::Provider::Service::Systemd,
+        package: Chef::Provider::Package::Yum,
+        ifconfig: Chef::Provider::Ifconfig::Redhat,
+
+        %w(amazon xcp xenserver ibm_powerkvm cloudlinux parallels) => {
+          "3.1.4" => {
+#            service: Chef::Provider::Service::Redhat,
+          },
+        },
+        %w(redhat centos scientific oracle) => {
+          "7.0" => {
+          },
+          "6.0" => {
+#            service: Chef::Provider::Service::Redhat,
+          },
+        },
+        "fedora" => {
+          "15.0" => {
+          },
+          "14.0" => {
+#            service: Chef::Provider::Service::Redhat,
+          },
+        },
+      },
 
-  provider_mapping = {
-    "mac_os_x" => {
-      :package => Chef::Provider::Package::Homebrew,
-      :user => Chef::Provider::User::Dscl,
-      :group => Chef::Provider::Group::Dscl,
     },
-    "mac_os_x_server" => {
-      :package => Chef::Provider::Package::Homebrew,
-      :user => Chef::Provider::User::Dscl,
-      :group => Chef::Provider::Group::Dscl,
-    },
-    "mswin" => {
-      :env =>  Chef::Provider::Env::Windows,
-      :user => Chef::Provider::User::Windows,
-      :group => Chef::Provider::Group::Windows,
-      :mount => Chef::Provider::Mount::Windows,
-      :batch => Chef::Provider::Batch,
-      :powershell_script => Chef::Provider::PowershellScript,
-    },
-    "mingw32" => {
-      :env =>  Chef::Provider::Env::Windows,
-      :user => Chef::Provider::User::Windows,
-      :group => Chef::Provider::Group::Windows,
-      :mount => Chef::Provider::Mount::Windows,
-      :batch => Chef::Provider::Batch,
-      :powershell_script => Chef::Provider::PowershellScript,
+
+    "darwin" => {
+      %w(mac_os_x mac_os_x_server) => {
+        group:   Chef::Provider::Group::Dscl,
+        package: Chef::Provider::Package::Homebrew,
+        user:    Chef::Provider::User::Dscl,
+
+        "mac_os_x" => {
+          "10.9.2" => {
+          },
+        },
+      },
     },
+
     "windows" => {
-      :env =>  Chef::Provider::Env::Windows,
-      :user => Chef::Provider::User::Windows,
-      :group => Chef::Provider::Group::Windows,
-      :mount => Chef::Provider::Mount::Windows,
-      :batch => Chef::Provider::Batch,
-      :powershell_script => Chef::Provider::PowershellScript,
+      batch: Chef::Provider::Batch,
+      dsc_script: Chef::Provider::DscScript,
+      env: Chef::Provider::Env::Windows,
+      group: Chef::Provider::Group::Windows,
+      mount: Chef::Provider::Mount::Windows,
+      package: Chef::Provider::Package::Windows,
+      powershell_script: Chef::Provider::PowershellScript,
+      service: Chef::Provider::Service::Windows,
+      user: Chef::Provider::User::Windows,
+      windows_package: Chef::Provider::Package::Windows,
+      windows_service: Chef::Provider::Service::Windows,
+
+      "windows" => {
+        %w(mswin mingw32 windows) => {
+          "10.9.2" => {
+          },
+        },
+      },
     },
+
     "aix" => {
-      :cron => Chef::Provider::Cron::Aix,
-    },
-    "netbsd"=> {
-      :group => Chef::Provider::Group::Groupmod,
+      bff_package: Chef::Provider::Package::Aix,
+      cron: Chef::Provider::Cron::Aix,
+      group: Chef::Provider::Group::Aix,
+      ifconfig: Chef::Provider::Ifconfig::Aix,
+      mount: Chef::Provider::Mount::Aix,
+      package: Chef::Provider::Package::Aix,
+      rpm_package: Chef::Provider::Package::Rpm,
+      user: Chef::Provider::User::Aix,
+#      service: Chef::Provider::Service::Aix,
+
+      "aix" => {
+        "aix" => {
+          "5.6" => {
+          },
+        },
+      },
     },
-    "openbsd" => {
-      :group => Chef::Provider::Group::Usermod,
-      :package => Chef::Provider::Package::Openbsd,
-    },
-  }
 
-  def self.do_platform(platform_hash)
-    platform_hash.each do |resource, provider|
-      describe "for #{resource}" do
-        let(:resource_name) { resource }
-
-        it "resolves to a #{provider}" do
-          expect(resolved_provider).to eql(provider)
-        end
-      end
-    end
-  end
-
-  describe "individual platform mappings" do
-    let(:resource_name) { :user }
-
-    before do
-      expect(provider_resolver).not_to receive(:maybe_chef_platform_lookup)
-    end
-
-    %w{mac_os_x mac_os_x_server}.each do |platform|
-      describe "on #{platform}" do
-        let(:os) { "darwin" }
-        let(:platform) { platform }
-        let(:platform_family) { "mac_os_x" }
-        let(:platform_version) { "10.9.2" }
-
-        do_platform(provider_mapping[platform])
-      end
-    end
-
-    %w{mswin mingw32 windows}.each do |platform|
-      describe "on #{platform}" do
-        let(:os) { "windows" }
-        let(:platform) { platform }
-        let(:platform_family) { "windows" }
-        let(:platform_version) { "10.9.2" }
+    "hpux" => {
+      "hpux" => {
+        "hpux" => {
+          "3.1.4" => {
+            group: Chef::Provider::Group::Usermod
+          }
+        }
+      }
+    },
 
-        do_platform(provider_mapping[platform])
-      end
-    end
+    "netbsd" => {
+      "netbsd" => {
+        "netbsd" => {
+          "3.1.4" => {
+            group: Chef::Provider::Group::Groupmod,
+          },
+        },
+      },
+    },
 
-    describe "on AIX" do
-      let(:os) { "aix" }
-      let(:platform) { "aix" }
-      let(:platform_family) { "aix" }
-      let(:platform_version) { "6.2" }
+    "openbsd" => {
+      group: Chef::Provider::Group::Usermod,
+      package: Chef::Provider::Package::Openbsd,
+
+      "openbsd" => {
+        "openbsd" => {
+          "3.1.4" => {
+          },
+        },
+      },
+    },
 
-      do_platform(provider_mapping['aix'])
-    end
+    "solaris2" => {
+      group: Chef::Provider::Group::Usermod,
+      ips_package: Chef::Provider::Package::Ips,
+      package: Chef::Provider::Package::Ips,
+      mount: Chef::Provider::Mount::Solaris,
+      solaris_package: Chef::Provider::Package::Solaris,
+
+      "smartos" => {
+        smartos_package: Chef::Provider::Package::SmartOS,
+        package: Chef::Provider::Package::SmartOS,
+
+        "smartos" => {
+          "3.1.4" => {
+          },
+        },
+      },
+
+      "solaris2" => {
+        "nexentacore" => {
+          "3.1.4" => {
+            package: Chef::Provider::Package::Solaris,
+          },
+        },
+        "omnios" => {
+          "3.1.4" => {
+            user: Chef::Provider::User::Solaris,
+          }
+        },
+        "openindiana" => {
+          "3.1.4" => {
+          },
+        },
+        "opensolaris" => {
+          "3.1.4" => {
+          },
+        },
+        "solaris2" => {
+          user: Chef::Provider::User::Solaris,
+          "5.11" => {
+          },
+          "5.9" => {
+            package: Chef::Provider::Package::Solaris,
+          },
+        },
+      },
 
-    %w{netbsd openbsd}.each do |platform|
-      describe "on #{platform}" do
-        let(:os) { platform }
-        let(:platform) { platform }
-        let(:platform_family) { platform }
-        let(:platform_version) { "10.0-RELEASE" }
+    },
 
-        do_platform(provider_mapping[platform])
-      end
-    end
-  end
+    "solaris" => {
+      "solaris" => {
+        "solaris" => {
+          "3.1.4" => {
+          },
+        },
+      },
+    },
 
-  describe "resolving static providers" do
-    def resource_class(resource)
-      Chef::Resource.const_get(convert_to_class_name(resource.to_s))
-    end
-      static_mapping = {
-        apt_package:  Chef::Provider::Package::Apt,
-        bash: Chef::Provider::Script,
-        bff_package: Chef::Provider::Package::Aix,
-        breakpoint:  Chef::Provider::Breakpoint,
-        chef_gem: Chef::Provider::Package::Rubygems,
-        cookbook_file:  Chef::Provider::CookbookFile,
-        csh:  Chef::Provider::Script,
-        deploy:   Chef::Provider::Deploy::Timestamped,
-        deploy_revision:  Chef::Provider::Deploy::Revision,
-        directory:  Chef::Provider::Directory,
-        dpkg_package: Chef::Provider::Package::Dpkg,
-        dsc_script: Chef::Provider::DscScript,
-        easy_install_package:  Chef::Provider::Package::EasyInstall,
-        erl_call: Chef::Provider::ErlCall,
-        execute:  Chef::Provider::Execute,
-        file: Chef::Provider::File,
-        gem_package: Chef::Provider::Package::Rubygems,
-        git:  Chef::Provider::Git,
-        homebrew_package: Chef::Provider::Package::Homebrew,
-        http_request: Chef::Provider::HttpRequest,
-        ips_package: Chef::Provider::Package::Ips,
-        link:  Chef::Provider::Link,
-        log:  Chef::Provider::Log::ChefLog,
-        macports_package:  Chef::Provider::Package::Macports,
-        mdadm:  Chef::Provider::Mdadm,
-        pacman_package: Chef::Provider::Package::Pacman,
-        paludis_package: Chef::Provider::Package::Paludis,
-        perl: Chef::Provider::Script,
-        portage_package:  Chef::Provider::Package::Portage,
-        python: Chef::Provider::Script,
-        remote_directory: Chef::Provider::RemoteDirectory,
-        route:  Chef::Provider::Route,
-        rpm_package:  Chef::Provider::Package::Rpm,
-        ruby:  Chef::Provider::Script,
-        ruby_block:   Chef::Provider::RubyBlock,
-        script:   Chef::Provider::Script,
-        smartos_package:  Chef::Provider::Package::SmartOS,
-        solaris_package:  Chef::Provider::Package::Solaris,
-        subversion:   Chef::Provider::Subversion,
-        template:   Chef::Provider::Template,
-        timestamped_deploy:  Chef::Provider::Deploy::Timestamped,
-        whyrun_safe_ruby_block:  Chef::Provider::WhyrunSafeRubyBlock,
-        windows_package:  Chef::Provider::Package::Windows,
-        windows_service:  Chef::Provider::Service::Windows,
-        yum_package:  Chef::Provider::Package::Yum,
+    "exherbo" => {
+      "exherbo" => {
+        "exherbo" => {
+          "3.1.4" => {
+            package: Chef::Provider::Package::Paludis
+          }
+        }
       }
+    }
+  }
 
-    describe "on Ubuntu 14.04" do
-      let(:os) { "linux" }
-      let(:platform) { "ubuntu" }
-      let(:platform_family) { "debian" }
-      let(:platform_version) { "14.04" }
-
-      supported_providers = [
-        :apt_package, :bash, :breakpoint, :chef_gem, :cookbook_file, :csh, :deploy,
-        :deploy_revision, :directory, :dpkg_package, :easy_install_package, :erl_call,
-        :execute, :file, :gem_package, :git, :homebrew_package, :http_request, :link,
-        :log, :macports_package, :pacman_package, :paludis_package, :perl, :python,
-        :remote_directory, :route, :rpm_package, :ruby, :ruby_block, :script, :subversion,
-        :template, :timestamped_deploy, :whyrun_safe_ruby_block, :yum_package,
-      ]
-
-      supported_providers.each do |static_resource|
-        static_provider = static_mapping[static_resource]
-        context "when the resource is a #{static_resource}" do
-          let(:resource) { double(Chef::Resource, provider: nil, resource_name: static_resource) }
-          let(:action) { :start }  # in reality this doesn't matter much
-          it "should resolve to a #{static_provider} provider" do
-            expect(provider_resolver).not_to receive(:maybe_chef_platform_lookup)
-            expect(resolved_provider).to eql(static_provider)
+  def self.create_provider_tests(providers, test, expected, filter)
+    expected = expected.merge(providers.select { |key, value| key.is_a?(Symbol) })
+    providers.each do |key, value|
+      if !key.is_a?(Symbol)
+        next_test = test.merge({ filter => key })
+        next_filter =
+          case filter
+          when :os
+            :platform_family
+          when :platform_family
+            :platform
+          when :platform
+            :platform_version
+          when :platform_version
+            nil
+          else
+            raise "Hash too deep; only os, platform_family, platform and platform_version supported"
           end
-        end
+        create_provider_tests(value, next_test, expected, next_filter)
       end
-
-      unsupported_providers = [
-        :bff_package, :dsc_script, :ips_package, :smartos_package,
-        :solaris_package, :windows_package, :windows_service,
-      ]
-
-      unsupported_providers.each do |static_resource|
-        static_provider = static_mapping[static_resource]
-        context "when the resource is a #{static_resource}" do
-          let(:resource) { double(Chef::Resource, provider: nil, resource_name: static_resource) }
-          let(:action) { :start }  # in reality this doesn't matter much
-          it "should fall back into the old provider mapper code and hooks" do
-            retval = Object.new
-            expect(provider_resolver).to receive(:maybe_chef_platform_lookup).and_return(retval)
-            expect(resolved_provider).to equal(retval)
-          end
-        end
+    end
+    # If there is no filter, we're as deep as we need to go
+    if !filter
+      on_platform test.delete(:platform), test do
+        expect_providers(expected)
       end
     end
   end
+
+  create_provider_tests(PROVIDERS, {}, {}, :os)
 end