chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/spec/unit/provider/subversion_spec.rb

@@ -27,6 +27,7 @@ describe Chef::Provider::Subversion do
     @resource.revision "12345"
     @resource.svn_arguments(false)
     @resource.svn_info_args(false)
+    @resource.svn_binary "svn"
     @node = Chef::Node.new
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
@@ -63,28 +64,18 @@ describe Chef::Provider::Subversion do
                           "Last Changed Rev: 11410\n" + # Last Changed Rev is preferred to Revision
                           "Last Changed Date: 2009-03-25 06:09:56 -0600 (Wed, 25 Mar 2009)\n\n"
       expect(::File).to receive(:exist?).at_least(1).times.with("/my/deploy/dir/.svn").and_return(true)
-      expect(::File).to receive(:directory?).with("/my/deploy/dir").and_return(true)
-      expect(::Dir).to receive(:chdir).with("/my/deploy/dir").and_yield
-      allow(@stdout).to receive(:string).and_return(example_svn_info)
-      allow(@stderr).to receive(:string).and_return("")
-      allow(@exitstatus).to receive(:exitstatus).and_return(0)
-      expected_command = ["svn info", {:cwd=>"/my/deploy/dir"}]
-      expect(@provider).to receive(:popen4).with(*expected_command).
-                                        and_yield("no-pid", "no-stdin", @stdout,@stderr).
-                                        and_return(@exitstatus)
+      expected_command = ["svn info", {:cwd => '/my/deploy/dir', :returns => [0,1]}]
+      expect(@provider).to receive(:shell_out!).with(*expected_command).
+                             and_return(double("ShellOut result", :stdout => example_svn_info, :stderr => ""))
       expect(@provider.find_current_revision).to eql("11410")
     end
 
     it "gives nil as the current revision if the deploy dir isn't a SVN working copy" do
       example_svn_info = "svn: '/tmp/deploydir' is not a working copy\n"
       expect(::File).to receive(:exist?).with("/my/deploy/dir/.svn").and_return(true)
-      expect(::File).to receive(:directory?).with("/my/deploy/dir").and_return(true)
-      expect(::Dir).to receive(:chdir).with("/my/deploy/dir").and_yield
-      allow(@stdout).to receive(:string).and_return(example_svn_info)
-      allow(@stderr).to receive(:string).and_return("")
-      allow(@exitstatus).to receive(:exitstatus).and_return(1)
-      expect(@provider).to receive(:popen4).and_yield("no-pid", "no-stdin", @stdout,@stderr).
-                                        and_return(@exitstatus)
+      expected_command = ["svn info", {:cwd => '/my/deploy/dir', :returns => [0,1]}]
+      expect(@provider).to receive(:shell_out!).with(*expected_command).
+                             and_return(double("ShellOut result", :stdout => example_svn_info, :stderr => ""))
       expect(@provider.find_current_revision).to be_nil
     end
 
@@ -127,28 +118,20 @@ describe Chef::Provider::Subversion do
                           "Last Changed Author: codeninja\n" +
                           "Last Changed Rev: 11410\n" + # Last Changed Rev is preferred to Revision
                           "Last Changed Date: 2009-03-25 06:09:56 -0600 (Wed, 25 Mar 2009)\n\n"
-      exitstatus = double("exitstatus")
-      allow(exitstatus).to receive(:exitstatus).and_return(0)
       @resource.revision "HEAD"
-      allow(@stdout).to receive(:string).and_return(example_svn_info)
-      allow(@stderr).to receive(:string).and_return("")
-      expected_command = ["svn info http://svn.example.org/trunk/ --no-auth-cache  -rHEAD", {:cwd=>Dir.tmpdir}]
-      expect(@provider).to receive(:popen4).with(*expected_command).
-                                        and_yield("no-pid","no-stdin",@stdout,@stderr).
-                                        and_return(exitstatus)
+      expected_command = ["svn info http://svn.example.org/trunk/ --no-auth-cache  -rHEAD", {:cwd => '/my/deploy/dir', :returns => [0,1]}]
+      expect(@provider).to receive(:shell_out!).with(*expected_command).
+                                        and_return(double("ShellOut result", :stdout => example_svn_info, :stderr => ""))
       expect(@provider.revision_int).to eql("11410")
     end
 
     it "returns a helpful message if data from `svn info` can't be parsed" do
       example_svn_info =  "some random text from an error message\n"
-      exitstatus = double("exitstatus")
-      allow(exitstatus).to receive(:exitstatus).and_return(0)
       @resource.revision "HEAD"
-      allow(@stdout).to receive(:string).and_return(example_svn_info)
-      allow(@stderr).to receive(:string).and_return("")
-      expect(@provider).to receive(:popen4).and_yield("no-pid","no-stdin",@stdout,@stderr).
-                                        and_return(exitstatus)
-      expect {@provider.revision_int}.to raise_error(RuntimeError, "Could not parse `svn info` data: some random text from an error message")
+      expected_command = ["svn info http://svn.example.org/trunk/ --no-auth-cache  -rHEAD", {:cwd => '/my/deploy/dir', :returns => [0,1]}]
+      expect(@provider).to receive(:shell_out!).with(*expected_command).
+                             and_return(double("ShellOut result", :stdout => example_svn_info, :stderr => ""))
+      expect {@provider.revision_int}.to raise_error(RuntimeError, "Could not parse `svn info` data: some random text from an error message\n")
 
     end
 
@@ -277,4 +260,40 @@ describe Chef::Provider::Subversion do
     expect(@resource).to be_updated
   end
 
+  context "selects the correct svn binary" do
+    before do
+    end
+
+    it "selects 'svn' as the binary by default" do
+      @resource.svn_binary nil
+      allow(ChefConfig).to receive(:windows?) { false }
+      expect(@provider).to receive(:svn_binary).and_return('svn')
+      expect(@provider.export_command).to eql(
+        'svn export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir')
+    end
+
+    it "selects an svn binary with an exe extension on windows" do
+      @resource.svn_binary nil
+      allow(ChefConfig).to receive(:windows?) { true }
+      expect(@provider).to receive(:svn_binary).and_return('svn.exe')
+      expect(@provider.export_command).to eql(
+        'svn.exe export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir')
+    end
+
+    it "uses a custom svn binary as part of the svn command" do
+      @resource.svn_binary 'teapot'
+      expect(@provider).to receive(:svn_binary).and_return('teapot')
+      expect(@provider.export_command).to eql(
+        'teapot export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir')
+    end
+
+    it "wraps custom svn binary with quotes if it contains whitespace" do
+      @resource.svn_binary 'c:/program files (x86)/subversion/svn.exe'
+      expect(@provider).to receive(:svn_binary).and_return('c:/program files (x86)/subversion/svn.exe')
+      expect(@provider.export_command).to eql(
+        '"c:/program files (x86)/subversion/svn.exe" export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir')
+    end
+
+  end
+
 end

data/spec/unit/provider/template/content_spec.rb

@@ -20,10 +20,24 @@ require 'spec_helper'
 
 describe Chef::Provider::Template::Content do
 
+  let(:enclosing_directory) {
+    canonicalize_path(Dir.mktmpdir)
+  }
+
+  let(:resource_path) {
+    canonicalize_path(File.expand_path(File.join(enclosing_directory, "openldap_stuff.conf")))
+  }
+
   let(:new_resource) do
     double("Chef::Resource::Template (new)",
          :cookbook_name => 'openldap',
+         :recipe_name => 'default',
+         :source_line => "/Users/lamont/solo/cookbooks/openldap/recipes/default.rb:2:in `from_file'",
+         :source_line_file => "/Users/lamont/solo/cookbooks/openldap/recipes/default.rb",
+         :source_line_number => "2",
          :source => 'openldap_stuff.conf.erb',
+         :name => 'openldap_stuff.conf',
+         :path => resource_path,
          :local => false,
          :cookbook => nil,
          :variables => {},
@@ -32,7 +46,10 @@ describe Chef::Provider::Template::Content do
          :helper_modules => [])
   end
 
-  let(:rendered_file_location) { Dir.tmpdir + '/openldap_stuff.conf' }
+  let(:rendered_file_locations) {
+    [Dir.tmpdir + '/openldap_stuff.conf',
+     enclosing_directory + '/openldap_stuff.conf']
+  }
 
   let(:run_context) do
     cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
@@ -50,7 +67,9 @@ describe Chef::Provider::Template::Content do
   end
 
   after do
-    FileUtils.rm(rendered_file_location) if ::File.exist?(rendered_file_location)
+    rendered_file_locations.each do |file|
+      FileUtils.rm(file) if ::File.exist?(file)
+    end
   end
 
   it "finds the template file in the cookbook cache if it isn't local" do
@@ -70,9 +89,81 @@ describe Chef::Provider::Template::Content do
     expect(content.template_location).to eq(CHEF_SPEC_DATA + '/cookbooks/openldap/templates/default/test.erb')
   end
 
+  it "returns a tempfile in the tempdir when :file_staging_uses_destdir is not set" do
+    Chef::Config[:file_staging_uses_destdir] = false
+    expect(content.tempfile.path.start_with?(Dir::tmpdir)).to be true
+    expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be false
+  end
+
+  it "returns a tempfile in the destdir when :file_staging_uses_destdir is set" do
+    Chef::Config[:file_staging_uses_destdir] = true
+    expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be true
+  end
+
+  context "when creating a tempfile in destdir fails" do
+    let(:enclosing_directory) {
+      canonicalize_path("/nonexisting/path")
+    }
+
+    it "returns a tempfile in the tempdir when :file_deployment_uses_destdir is set to :auto" do
+      Chef::Config[:file_staging_uses_destdir] = :auto
+      expect(content.tempfile.path.start_with?(Dir::tmpdir)).to be true
+      expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be false
+    end
+
+    it "fails when :file_desployment_uses_destdir is set" do
+      Chef::Config[:file_staging_uses_destdir] = true
+      expect{content.tempfile}.to raise_error(Chef::Exceptions::FileContentStagingError)
+    end
+
+    it "returns a tempfile in the tempdir when :file_desployment_uses_destdir is not set" do
+      expect(content.tempfile.path.start_with?(Dir::tmpdir)).to be true
+      expect(canonicalize_path(content.tempfile.path).start_with?(enclosing_directory)).to be false
+    end
+  end
+
   it "creates the template with the rendered content" do
     run_context.node.normal[:slappiness] = "a warm gun"
     expect(IO.read(content.tempfile.path)).to eq("slappiness is a warm gun")
   end
 
+  describe "when using location helpers" do
+    let(:new_resource) do
+      double("Chef::Resource::Template (new)",
+             :cookbook_name => 'openldap',
+             :recipe_name => 'default',
+             :source_line => CHEF_SPEC_DATA + "/cookbooks/openldap/recipes/default.rb:2:in `from_file'",
+             :source_line_file => CHEF_SPEC_DATA + "/cookbooks/openldap/recipes/default.rb",
+             :source_line_number => "2",
+             :source => 'helpers.erb',
+             :name => 'helpers.erb',
+             :path => CHEF_SPEC_DATA + '/cookbooks/openldap/templates/default/helpers.erb',
+             :local => false,
+             :cookbook => nil,
+             :variables => {},
+             :inline_helper_blocks => {},
+             :inline_helper_modules => [],
+             :helper_modules => [])
+    end
+
+    it "creates the template with the rendered content" do
+      expect(IO.read(content.tempfile.path)).to eql <<EOF
+openldap
+default
+#{CHEF_SPEC_DATA}/cookbooks/openldap/recipes/default.rb:2:in `from_file'
+#{CHEF_SPEC_DATA}/cookbooks/openldap/recipes/default.rb
+2
+helpers.erb
+#{CHEF_SPEC_DATA}/cookbooks/openldap/templates/default/helpers.erb
+openldap
+default
+#{CHEF_SPEC_DATA}/cookbooks/openldap/recipes/default.rb:2:in `from_file'
+#{CHEF_SPEC_DATA}/cookbooks/openldap/recipes/default.rb
+2
+helpers.erb
+#{CHEF_SPEC_DATA}/cookbooks/openldap/templates/default/helpers.erb
+EOF
+    end
+
+  end
 end

data/spec/unit/provider/user/solaris_spec.rb

@@ -1,7 +1,9 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Dave Eddy (<dave@daveeddy.com>)
 # Copyright:: Copyright (c) 2008, 2010 Opscode, Inc.
+# Copyright:: Copyright (c) 2015, Dave Eddy
 #
 # License:: Apache License, Version 2.0
 #
@@ -18,6 +20,9 @@
 # limitations under the License.
 #
 
+ShellCmdResult = Struct.new(:stdout, :stderr, :exitstatus)
+
+require 'mixlib/shellout'
 require 'spec_helper'
 
 describe Chef::Provider::User::Solaris do
@@ -31,15 +36,6 @@ describe Chef::Provider::User::Solaris do
     p
   end
 
-  supported_useradd_options = {
-    'comment' => "-c",
-    'gid' => "-g",
-    'uid' => "-u",
-    'shell' => "-s"
-  }
-
-  include_examples "a useradd-based user provider", supported_useradd_options
-
   describe "when we want to set a password" do
     before(:each) do
       @node = Chef::Node.new
@@ -77,4 +73,65 @@ describe Chef::Provider::User::Solaris do
     end
   end
 
+  describe 'when managing user locked status' do
+    before(:each) do
+      @node = Chef::Node.new
+      @events = Chef::EventDispatch::Dispatcher.new
+      @run_context = Chef::RunContext.new(@node, {}, @events)
+
+      @new_resource = Chef::Resource::User.new('dave')
+      @current_resource = @new_resource.dup
+
+      @provider = Chef::Provider::User::Solaris.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+    end
+    describe 'when determining if the user is locked' do
+
+      # locked shadow lines
+      [
+        'dave:LK:::::::',
+        'dave:*LK*:::::::',
+        'dave:*LK*foobar:::::::',
+        'dave:*LK*bahamas10:::::::',
+        'dave:*LK*L....:::::::',
+      ].each do |shadow|
+        it "should return true if user is locked with #{shadow}" do
+          shell_return = ShellCmdResult.new(shadow + "\n", '', 0)
+          expect(provider).to receive(:shell_out!).with('getent', 'shadow', @new_resource.username).and_return(shell_return)
+          expect(provider.check_lock).to eql(true)
+        end
+      end
+
+      # unlocked shadow lines
+      [
+        'dave:NP:::::::',
+        'dave:*NP*:::::::',
+        'dave:foobar:::::::',
+        'dave:bahamas10:::::::',
+        'dave:L...:::::::',
+      ].each do |shadow|
+        it "should return false if user is unlocked with #{shadow}" do
+          shell_return = ShellCmdResult.new(shadow + "\n", '', 0)
+          expect(provider).to receive(:shell_out!).with('getent', 'shadow', @new_resource.username).and_return(shell_return)
+          expect(provider.check_lock).to eql(false)
+        end
+      end
+    end
+
+    describe 'when locking the user' do
+      it 'should run passwd -l with the new resources username' do
+        shell_return = ShellCmdResult.new('', '', 0)
+        expect(provider).to receive(:shell_out!).with('passwd', '-l', @new_resource.username).and_return(shell_return)
+        provider.lock_user
+      end
+    end
+
+    describe 'when unlocking the user' do
+      it 'should run passwd -u with the new resources username' do
+        shell_return = ShellCmdResult.new('', '', 0)
+        expect(provider).to receive(:shell_out!).with('passwd', '-u', @new_resource.username).and_return(shell_return)
+        provider.unlock_user
+      end
+    end
+  end
 end

data/spec/unit/provider_resolver_spec.rb

@@ -20,6 +20,9 @@ require 'spec_helper'
 require 'chef/mixin/convert_to_class_name'
 require 'chef/provider_resolver'
 require 'chef/platform/service_helpers'
+require 'support/shared/integration/integration_helper'
+require 'tmpdir'
+require 'fileutils'
 
 include Chef::Mixin::ConvertToClassName
 
@@ -27,833 +30,887 @@ include Chef::Mixin::ConvertToClassName
 #module Chef::Provider
 
 describe Chef::ProviderResolver do
+  include IntegrationSupport
 
-  let(:resource_name) { :service }
-  let(:provider) { nil }
-  let(:action) { :start }
-
-  let(:node) do
-    node = Chef::Node.new
-    node.automatic[:os] = os
-    node.automatic[:platform_family] = platform_family
-    node.automatic[:platform] = platform
-    node.automatic[:platform_version] = platform_version
-    node.automatic[:kernel] = { machine: 'i386' }
-    node
-  end
-  let(:run_context) { Chef::RunContext.new(node, nil, nil) }
-
-  let(:provider_resolver) { Chef::ProviderResolver.new(node, resource, action) }
-  let(:resolved_provider) do
-    begin
-      resource ? resource.provider_for_action(action).class : nil
-    rescue Chef::Exceptions::ProviderNotFound
-      nil
+  # Root the filesystem under a temp directory so Chef.path_to will point at it
+  when_the_repository "is empty" do
+    before do
+      allow(Chef).to receive(:path_to) { |path| File.join(path_to(""), path) }
     end
-  end
 
-  let(:resource) do
-    resource_class = Chef::ResourceResolver.resolve(resource_name, node: node)
-    if resource_class
-      resource = resource_class.new('test', run_context)
-      resource.provider = provider if provider
+    let(:resource_name) { :service }
+    let(:provider) { nil }
+    let(:action) { :start }
+
+    let(:node) do
+      node = Chef::Node.new
+      node.automatic[:os] = os
+      node.automatic[:platform_family] = platform_family
+      node.automatic[:platform] = platform
+      node.automatic[:platform_version] = platform_version
+      node.automatic[:kernel] = { machine: 'i386' }
+      node
     end
-    resource
-  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)
+    let(:run_context) { Chef::RunContext.new(node, nil, nil) }
+
+    let(:provider_resolver) { Chef::ProviderResolver.new(node, resource, action) }
+    let(:resolved_provider) do
+      begin
+        resource ? resource.provider_for_action(action).class : nil
+      rescue Chef::Exceptions::ProviderNotFound
+        nil
       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)
+    let(:service_name) { "test" }
+    let(:resource) do
+      resource_class = Chef::ResourceResolver.resolve(resource_name, node: node)
+      if resource_class
+        resource = resource_class.new(service_name, run_context)
+        resource.provider = provider if provider
+      end
+      resource
     end
-  end
 
-  def self.expect_providers(**providers)
-    providers.each do |name, expected|
-      describe name.to_s do
-        let(:resource_name) { name }
-
-        tags = []
-        expected_provider = nil
-        expected_resource = nil
-        Array(expected).each do |p|
-          if p.is_a?(Class) && p <= Chef::Provider
-            expected_provider = p
-          elsif p.is_a?(Class) && p <= Chef::Resource
-            expected_resource = p
-          else
-            tags << p
-          end
-        end
-
-        if expected_resource && expected_provider
-          it "'#{name}' resolves to resource #{expected_resource} and provider #{expected_provider}", *tags do
-            expect(resource.class).to eql(expected_resource)
-            provider = double(expected_provider, class: expected_provider)
-            expect(provider).to receive(:action=).with(action)
-            expect(expected_provider).to receive(:new).with(resource, run_context).and_return(provider)
-            expect(resolved_provider).to eql(expected_provider)
-          end
-        elsif expected_provider
-          it "'#{name}' resolves to provider #{expected_provider}", *tags do
-            provider = double(expected_provider)
-            expect(provider).to receive(:action=).with(action)
-            expect(expected_provider).to receive(:new).with(resource, run_context).and_return(provider)
-            expect(resolved_provider).to eql(expected_provider)
-          end
-        else
-          it "'#{name}' fails to resolve (since #{name.inspect} is unsupported on #{platform} #{platform_version})", *tags do
-            expect(resolved_provider).to be_nil
-          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
-  end
-
-  describe "resolving service resource" do
-    def stub_service_providers(*services)
-      services ||= []
-      allow(Chef::Platform::ServiceHelpers).to receive(:service_resource_providers)
-        .and_return(services)
-    end
-
-    def stub_service_configs(*configs)
-      configs ||= []
-      allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-        .and_return(configs)
-    end
-
-    before do
-      allow(resource).to receive(:service_name).and_return("ntp")
-    end
-
-    shared_examples_for "an ubuntu platform with upstart, update-rc.d and systemd" do
-      before do
-        stub_service_providers(:debian, :invokercd, :upstart, :systemd)
-      end
 
-      it "when only the SysV init script exists, it returns a Service::Debian provider" do
-        allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-          .and_return( [ :initd, :systemd ] )
-        expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
-      end
-
-      it "when both SysV and Upstart scripts exist, it returns a Service::Upstart provider" do
-        allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-          .and_return( [ :initd, :upstart, :systemd ] )
-        expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
-      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 }
 
-      it "when only the Upstart script exists, it returns a Service::Upstart provider" do
-        allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-          .and_return( [ :upstart, :systemd ] )
-        expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
-      end
+        define_singleton_method(:os) { os }
+        define_singleton_method(:platform) { platform }
+        define_singleton_method(:platform_family) { platform_family }
+        define_singleton_method(:platform_version) { platform_version }
 
-      it "when both do not exist, it calls the old style provider resolver and returns a Debian Provider" do
-        allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-          .and_return( [ :systemd ] )
-        expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
-      end
-      it "when only the SysV init script exists, it returns a Service::Debian provider" do
-        allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-          .and_return( [ :initd ] )
-        expect(resolved_provider).to eql(Chef::Provider::Service::Debian)
+        instance_eval(&block)
       end
+    end
 
-      it "when both SysV and Upstart scripts exist, it returns a Service::Upstart provider" do
-        allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-          .and_return( [ :initd, :upstart ] )
-        expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
-      end
+    def self.expect_providers(**providers)
+      providers.each do |name, expected|
+        describe name.to_s do
+          let(:resource_name) { name }
+
+          tags = []
+          expected_provider = nil
+          expected_resource = nil
+          Array(expected).each do |p|
+            if p.is_a?(Class) && p <= Chef::Provider
+              expected_provider = p
+            elsif p.is_a?(Class) && p <= Chef::Resource
+              expected_resource = p
+            else
+              tags << p
+            end
+          end
 
-      it "when only the Upstart script exists, it returns a Service::Upstart provider" do
-        allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-          .and_return( [ :upstart ] )
-        expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+          if expected_resource && expected_provider
+            it "'#{name}' resolves to resource #{expected_resource} and provider #{expected_provider}", *tags do
+              expect(resource.class).to eql(expected_resource)
+              provider = double(expected_provider, class: expected_provider)
+              expect(provider).to receive(:action=).with(action)
+              expect(expected_provider).to receive(:new).with(resource, run_context).and_return(provider)
+              expect(resolved_provider).to eql(expected_provider)
+            end
+          elsif expected_provider
+            it "'#{name}' resolves to provider #{expected_provider}", *tags do
+              provider = double(expected_provider)
+              expect(provider).to receive(:action=).with(action)
+              expect(expected_provider).to receive(:new).with(resource, run_context).and_return(provider)
+              expect(resolved_provider).to eql(expected_provider)
+            end
+          else
+            it "'#{name}' fails to resolve (since #{name.inspect} is unsupported on #{platform} #{platform_version})", *tags do
+              expect(resolved_provider).to be_nil
+            end
+          end
+        end
       end
+    end
 
-      it "when both do not exist, it calls the old style provider resolver and returns a Debian Provider" do
-        allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-          .and_return( [ ] )
-        expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
+    describe "resolving service resource" do
+      def stub_service_providers(*services)
+        services.each do |service|
+          case service
+          when :debian
+            directory 'usr/sbin/update-rc.d'
+          when :invokercd
+            directory 'usr/sbin/invoke-rc.d'
+          when :insserv
+            directory 'sbin/insserv'
+          when :upstart
+            directory 'etc/init'
+            directory 'sbin/start'
+          when :redhat
+            directory 'sbin/chkconfig'
+          when :systemd
+            file 'bin/systemctl', ''
+            # Make systemctl executable
+            File.chmod(0755, path_to('bin/systemctl'))
+            # Windows doesn't respect executable bit, do this to let Windows users see if they've broken the resolver
+            allow(::File).to receive(:executable?) { |p| p == path_to('bin/systemctl') } if windows?
+            file 'proc/1/comm', "systemd\n"
+            mock_shellout_command("/bin/systemctl --all", stdout: "")
+            mock_shellout_command("/bin/systemctl list-unit-files", stdout: "")
+          else
+            raise ArgumentError, service
+          end
+        end
       end
-    end
 
-    shared_examples_for "an ubuntu platform with upstart and update-rc.d" do
-      before do
-        stub_service_providers(:debian, :invokercd, :upstart)
+      def stub_service_configs(*configs)
+        configs.each do |config|
+          case config
+          when :initd
+            file "etc/init.d/#{service_name}", ""
+          when :upstart
+            file "etc/init/#{service_name}.conf", ""
+          when :xinetd
+            file "etc/xinetd.d/#{service_name}", ""
+          when :etc_rcd
+            file "etc/rc.d/#{service_name}", ""
+          when :usr_local_etc_rcd
+            file "usr/local/etc/rc.d/#{service_name}", ""
+          when :systemd
+            file 'bin/systemctl', ''
+            # Make systemctl executable
+            File.chmod(0755, path_to("bin/systemctl"))
+            # Windows doesn't respect executable bit, do this to let Windows users see if they've broken the resolver
+            allow(::File).to receive(:executable?) { |p| p == path_to('bin/systemctl') } if windows?
+            file 'proc/1/comm', "systemd\n"
+            mock_shellout_command("/bin/systemctl --all", stdout: <<-EOM)
+  superv  loaded
+  stinky  something-else
+  #{service_name} loaded
+  blargh  not-found
+  EOM
+            mock_shellout_command("/bin/systemctl list-unit-files", stdout: <<-EOM)
+  usuperv  loaded
+  ustinky  something-else
+  u#{service_name}    loaded
+  ublargh  not-found
+  EOM
+          else
+            raise ArgumentError, config
+          end
+        end
       end
 
-      # needs to be handled by the highest priority init.d handler
-      context "when only the SysV init script exists" do
+      shared_examples_for "an ubuntu platform with upstart, update-rc.d and systemd" do
         before do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ :initd ] )
+          stub_service_providers(:debian, :invokercd, :upstart, :systemd)
         end
 
-        it "enables init, invokercd, debian and upstart providers" do
-          expect(provider_resolver.enabled_handlers).to include(
-            Chef::Provider::Service::Debian,
-            Chef::Provider::Service::Init,
-            Chef::Provider::Service::Invokercd,
-            Chef::Provider::Service::Upstart,
-          )
+        it "when only the SysV init script exists, it returns a Service::Debian provider" do
+          stub_service_configs(:initd, :systemd)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
         end
 
-        it "supports all the enabled handlers except for upstart" do
-          expect(provider_resolver.supported_handlers).to include(
-            Chef::Provider::Service::Debian,
-            Chef::Provider::Service::Init,
-            Chef::Provider::Service::Invokercd,
-          )
-          expect(provider_resolver.supported_handlers).to_not include(
-            Chef::Provider::Service::Upstart,
-          )
+        it "when both SysV and Upstart scripts exist, it returns a Service::Upstart provider" do
+          stub_service_configs(:initd, :upstart, :systemd)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
         end
 
-        it "returns a Service::Debian provider" do
-          expect(resolved_provider).to eql(Chef::Provider::Service::Debian)
+        it "when only the Upstart script exists, it returns a Service::Upstart provider" do
+          stub_service_configs(:upstart, :systemd)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
         end
-      end
 
-      # on ubuntu this must be handled by upstart, the init script will exit 1 and fail
-      context "when both SysV and Upstart scripts exist" do
-        before do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ :initd, :upstart ] )
+        it "when both do not exist, it calls the old style provider resolver and returns a Debian Provider" do
+          stub_service_configs(:systemd)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
         end
 
-        it "enables init, invokercd, debian and upstart providers" do
-          expect(provider_resolver.enabled_handlers).to include(
-            Chef::Provider::Service::Debian,
-            Chef::Provider::Service::Init,
-            Chef::Provider::Service::Invokercd,
-            Chef::Provider::Service::Upstart,
-          )
+        it "when only the SysV init script exists, it returns a Service::Debian provider" do
+          stub_service_configs(:initd)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Debian)
         end
 
-        it "supports all the enabled handlers" do
-          expect(provider_resolver.supported_handlers).to include(
-            Chef::Provider::Service::Debian,
-            Chef::Provider::Service::Init,
-            Chef::Provider::Service::Invokercd,
-            Chef::Provider::Service::Upstart,
-          )
+        it "when both SysV and Upstart scripts exist, it returns a Service::Upstart provider" do
+          stub_service_configs(:initd, :upstart)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
         end
 
-        it "returns a Service::Upstart provider" do
+        it "when only the Upstart script exists, it returns a Service::Upstart provider" do
+          stub_service_configs(:upstart)
           expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
         end
+
+        it "when both do not exist, it calls the old style provider resolver and returns a Debian Provider" do
+          stub_service_configs
+          expect(resolved_provider).to eql(Chef::Provider::Service::Systemd)
+        end
       end
 
-      # this case is a pure-upstart script which is easy
-      context "when only the Upstart script exists" do
+      shared_examples_for "an ubuntu platform with upstart and update-rc.d" do
         before do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ :upstart ] )
+          stub_service_providers(:debian, :invokercd, :upstart)
         end
 
-        it "enables init, invokercd, debian and upstart providers" do
-          expect(provider_resolver.enabled_handlers).to include(
-            Chef::Provider::Service::Debian,
-            Chef::Provider::Service::Init,
-            Chef::Provider::Service::Invokercd,
-            Chef::Provider::Service::Upstart,
-          )
-        end
+        # needs to be handled by the highest priority init.d handler
+        context "when only the SysV init script exists" do
+          before do
+            stub_service_configs(:initd)
+          end
 
-        it "supports only the upstart handler" do
-          expect(provider_resolver.supported_handlers).to include(
-            Chef::Provider::Service::Upstart,
-          )
-          expect(provider_resolver.supported_handlers).to_not include(
-            Chef::Provider::Service::Debian,
-            Chef::Provider::Service::Init,
-            Chef::Provider::Service::Invokercd,
-          )
-        end
+          it "enables init, invokercd, debian and upstart providers" do
+            expect(provider_resolver.enabled_handlers).to include(
+              Chef::Provider::Service::Debian,
+              Chef::Provider::Service::Init,
+              Chef::Provider::Service::Invokercd,
+              Chef::Provider::Service::Upstart,
+            )
+          end
 
-        it "returns a Service::Upstart provider" do
-          expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
-        end
-      end
+          it "supports all the enabled handlers except for upstart" do
+            expect(provider_resolver.supported_handlers).to include(
+              Chef::Provider::Service::Debian,
+              Chef::Provider::Service::Init,
+              Chef::Provider::Service::Invokercd,
+            )
+            expect(provider_resolver.supported_handlers).to_not include(
+              Chef::Provider::Service::Upstart,
+            )
+          end
 
-      # this case is important to get correct for why-run when no config is setup
-      context "when both do not exist" do
-        before do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ ] )
+          it "returns a Service::Debian provider" do
+            expect(resolved_provider).to eql(Chef::Provider::Service::Debian)
+          end
         end
 
-        it "enables init, invokercd, debian and upstart providers" do
-          expect(provider_resolver.enabled_handlers).to include(
-            Chef::Provider::Service::Debian,
-            Chef::Provider::Service::Init,
-            Chef::Provider::Service::Invokercd,
-            Chef::Provider::Service::Upstart,
-          )
-        end
+        # on ubuntu this must be handled by upstart, the init script will exit 1 and fail
+        context "when both SysV and Upstart scripts exist" do
+          before do
+            stub_service_configs(:initd, :upstart)
+          end
 
-        it "no providers claim to support the resource" do
-          expect(provider_resolver.supported_handlers).to_not include(
-            Chef::Provider::Service::Upstart,
-            Chef::Provider::Service::Debian,
-            Chef::Provider::Service::Init,
-            Chef::Provider::Service::Invokercd,
-          )
-        end
+          it "enables init, invokercd, debian and upstart providers" do
+            expect(provider_resolver.enabled_handlers).to include(
+              Chef::Provider::Service::Debian,
+              Chef::Provider::Service::Init,
+              Chef::Provider::Service::Invokercd,
+              Chef::Provider::Service::Upstart,
+            )
+          end
 
-        it "returns a Debian Provider" do
-          expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
-        end
-      end
-    end
+          it "supports all the enabled handlers" do
+            expect(provider_resolver.supported_handlers).to include(
+              Chef::Provider::Service::Debian,
+              Chef::Provider::Service::Init,
+              Chef::Provider::Service::Invokercd,
+              Chef::Provider::Service::Upstart,
+            )
+          end
 
-    shared_examples_for "a debian platform using the insserv provider" do
-      context "with a default install" do
-        before do
-          stub_service_providers(:debian, :invokercd, :insserv)
+          it "returns a Service::Upstart provider" do
+            expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+          end
         end
 
-        it "uses the Service::Insserv Provider to manage sysv init scripts" do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ :initd ] )
-          expect(resolved_provider).to eql(Chef::Provider::Service::Insserv)
-        end
+        # this case is a pure-upstart script which is easy
+        context "when only the Upstart script exists" do
+          before do
+            stub_service_configs(:upstart)
+          end
 
-        it "uses the Service::Insserv Provider when there is no config" do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ ] )
-          expect(resolved_provider).to eql(Chef::Provider::Service::Insserv)
-        end
-      end
+          it "enables init, invokercd, debian and upstart providers" do
+            expect(provider_resolver.enabled_handlers).to include(
+              Chef::Provider::Service::Debian,
+              Chef::Provider::Service::Init,
+              Chef::Provider::Service::Invokercd,
+              Chef::Provider::Service::Upstart,
+            )
+          end
 
-      context "when the user has installed upstart" do
-        before do
-          stub_service_providers(:debian, :invokercd, :insserv, :upstart)
-        end
+          it "supports only the upstart handler" do
+            expect(provider_resolver.supported_handlers).to include(
+              Chef::Provider::Service::Upstart,
+            )
+            expect(provider_resolver.supported_handlers).to_not include(
+              Chef::Provider::Service::Debian,
+              Chef::Provider::Service::Init,
+              Chef::Provider::Service::Invokercd,
+            )
+          end
 
-        it "when only the SysV init script exists, it returns an Insserv  provider" do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ :initd ] )
-          expect(resolved_provider).to eql(Chef::Provider::Service::Insserv)
+          it "returns a Service::Upstart provider" do
+            expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+          end
         end
 
-        it "when both SysV and Upstart scripts exist, it returns a Service::Upstart provider" do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ :initd, :upstart ] )
-          expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
-        end
+        # this case is important to get correct for why-run when no config is setup
+        context "when both do not exist" do
+          before do
+            stub_service_configs
+          end
 
-        it "when only the Upstart script exists, it returns a Service::Upstart provider" do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ :upstart ] )
-          expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
-        end
+          it "enables init, invokercd, debian and upstart providers" do
+            expect(provider_resolver.enabled_handlers).to include(
+              Chef::Provider::Service::Debian,
+              Chef::Provider::Service::Init,
+              Chef::Provider::Service::Invokercd,
+              Chef::Provider::Service::Upstart,
+            )
+          end
 
-        it "when both do not exist, it calls the old style provider resolver and returns a Debian Provider" do
-          allow(Chef::Platform::ServiceHelpers).to receive(:config_for_service).with("ntp")
-            .and_return( [ ] )
-          expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+          it "no providers claim to support the resource" do
+            expect(provider_resolver.supported_handlers).to_not include(
+              Chef::Provider::Service::Upstart,
+              Chef::Provider::Service::Debian,
+              Chef::Provider::Service::Init,
+              Chef::Provider::Service::Invokercd,
+            )
+          end
+
+          it "returns a Debian Provider" do
+            expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+          end
         end
       end
-    end
 
-    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
+      shared_examples_for "a debian platform using the insserv provider" do
+        context "with a default install" do
+          before do
+            stub_service_providers(:debian, :invokercd, :insserv)
+          end
 
-    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
+          it "uses the Service::Insserv Provider to manage sysv init scripts" do
+            stub_service_configs(:initd)
+            expect(resolved_provider).to eql(Chef::Provider::Service::Insserv)
+          end
 
-    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
+          it "uses the Service::Insserv Provider when there is no config" do
+            stub_service_configs
+            expect(resolved_provider).to eql(Chef::Provider::Service::Insserv)
+          end
+        end
 
-    # old debian uses the Debian provider (does not have insserv or upstart, or update-rc.d???)
-    on_platform "debian", platform_version: "4.0", os: "linux" do
-      #it_behaves_like "a debian platform using the debian provider"
-    end
+        context "when the user has installed upstart" do
+          before do
+            stub_service_providers(:debian, :invokercd, :insserv, :upstart)
+          end
 
-    # Debian replaced the debian provider with insserv in the FIXME:VERSION distro
-    on_platform "debian", platform_version: "7.0", os: "linux" do
-      it_behaves_like "a debian platform using the insserv provider"
-    end
+          it "when only the SysV init script exists, it returns an Insserv  provider" do
+            stub_service_configs(:initd)
+            expect(resolved_provider).to eql(Chef::Provider::Service::Insserv)
+          end
+
+          it "when both SysV and Upstart scripts exist, it returns a Service::Upstart provider" do
+            stub_service_configs(:initd, :upstart)
+            expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+          end
+
+          it "when only the Upstart script exists, it returns a Service::Upstart provider" do
+            stub_service_configs(:upstart)
+            expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+          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)
+          it "when both do not exist, it calls the old style provider resolver and returns a Debian Provider" do
+            stub_service_configs
+            expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+          end
+        end
       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)
+      on_platform "ubuntu", platform_version: "15.10", platform_family: "debian", os: "linux" do
+        it_behaves_like "an ubuntu platform with upstart, update-rc.d and systemd"
+
+        it "when the unit-files are missing and system-ctl list-unit-files returns an error" do
+          stub_service_providers(:debian, :invokercd, :upstart, :systemd)
+          stub_service_configs(:initd, :upstart)
+          mock_shellout_command("/bin/systemctl list-unit-files", exitstatus: 1)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Upstart)
+        end
       end
-    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)
+      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
 
-      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)
+      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
-    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)
+      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
 
-      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)
+      # old debian uses the Debian provider (does not have insserv or upstart, or update-rc.d???)
+      on_platform "debian", platform_version: "4.0", os: "linux" do
+        #it_behaves_like "a debian platform using the debian provider"
       end
-    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)
+      # Debian replaced the debian provider with insserv in the FIXME:VERSION distro
+      on_platform "debian", platform_version: "7.0", os: "linux" do
+        it_behaves_like "a debian platform using the insserv provider"
       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)
+      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, :usr_local_etc_rcd, :systemd)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Solaris)
+        end
       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)
+      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, :usr_local_etc_rcd, :systemd)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Windows)
+        end
       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)
+      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, :usr_local_etc_rcd, :systemd)
+          expect(resolved_provider).to eql(Chef::Provider::Service::Macosx)
+        end
       end
 
-      it "foo" do
-        stub_service_providers
-        stub_service_configs
-        expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
+      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 "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 "foo" do
+          stub_service_providers
+          stub_service_configs
+          expect(resolved_provider).to eql(Chef::Provider::Service::Freebsd)
+        end
       end
-    end
 
-  end
+    end
 
-  PROVIDERS =
-  {
-    bash:                   [ Chef::Resource::Bash, Chef::Provider::Script ],
-    breakpoint:             [ Chef::Resource::Breakpoint, Chef::Provider::Breakpoint ],
-    chef_gem:               [ Chef::Resource::ChefGem, Chef::Provider::Package::Rubygems ],
-    cookbook_file:          [ Chef::Resource::CookbookFile, Chef::Provider::CookbookFile ],
-    csh:                    [ Chef::Resource::Csh, Chef::Provider::Script ],
-    deploy:                 [ Chef::Resource::Deploy, Chef::Provider::Deploy::Timestamped ],
-    deploy_revision:        [ Chef::Resource::DeployRevision, Chef::Provider::Deploy::Revision ],
-    directory:              [ Chef::Resource::Directory, Chef::Provider::Directory ],
-    easy_install_package:   [ Chef::Resource::EasyInstallPackage, Chef::Provider::Package::EasyInstall ],
-    erl_call:               [ Chef::Resource::ErlCall, Chef::Provider::ErlCall ],
-    execute:                [ Chef::Resource::Execute, Chef::Provider::Execute ],
-    file:                   [ Chef::Resource::File, Chef::Provider::File ],
-    gem_package:            [ Chef::Resource::GemPackage, Chef::Provider::Package::Rubygems ],
-    git:                    [ Chef::Resource::Git, Chef::Provider::Git ],
-    group:                  [ Chef::Resource::Group, Chef::Provider::Group::Gpasswd ],
-    homebrew_package:       [ Chef::Resource::HomebrewPackage, Chef::Provider::Package::Homebrew ],
-    http_request:           [ Chef::Resource::HttpRequest, Chef::Provider::HttpRequest ],
-    ifconfig:               [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
-    link:                   [ Chef::Resource::Link, Chef::Provider::Link ],
-    log:                    [ Chef::Resource::Log, Chef::Provider::Log::ChefLog ],
-    macports_package:       [ Chef::Resource::MacportsPackage, Chef::Provider::Package::Macports ],
-    mdadm:                  [ Chef::Resource::Mdadm, Chef::Provider::Mdadm ],
-    mount:                  [ Chef::Resource::Mount, Chef::Provider::Mount::Mount ],
-    perl:                   [ Chef::Resource::Perl, Chef::Provider::Script ],
-    portage_package:        [ Chef::Resource::PortagePackage, Chef::Provider::Package::Portage ],
-    python:                 [ Chef::Resource::Python, Chef::Provider::Script ],
-    remote_directory:       [ Chef::Resource::RemoteDirectory, Chef::Provider::RemoteDirectory ],
-    route:                  [ Chef::Resource::Route, Chef::Provider::Route ],
-    ruby:                   [ Chef::Resource::Ruby, Chef::Provider::Script ],
-    ruby_block:             [ Chef::Resource::RubyBlock, Chef::Provider::RubyBlock ],
-    script:                 [ Chef::Resource::Script, Chef::Provider::Script ],
-    subversion:             [ Chef::Resource::Subversion, Chef::Provider::Subversion ],
-    template:               [ Chef::Resource::Template, Chef::Provider::Template ],
-    timestamped_deploy:     [ Chef::Resource::TimestampedDeploy, Chef::Provider::Deploy::Timestamped ],
-    user:                   [ Chef::Resource::User, Chef::Provider::User::Useradd ],
-    whyrun_safe_ruby_block: [ Chef::Resource::WhyrunSafeRubyBlock, Chef::Provider::WhyrunSafeRubyBlock ],
-
-    # We want to check that these are unsupported:
-    apt_package: nil,
-    bff_package: nil,
-    dpkg_package: nil,
-    dsc_script: 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::Resource::AptPackage, Chef::Provider::Package::Apt ],
-      dpkg_package:    [ Chef::Resource::DpkgPackage, Chef::Provider::Package::Dpkg ],
-      pacman_package:  [ Chef::Resource::PacmanPackage, Chef::Provider::Package::Pacman ],
-      paludis_package: [ Chef::Resource::PaludisPackage, Chef::Provider::Package::Paludis ],
-      rpm_package:     [ Chef::Resource::RpmPackage, Chef::Provider::Package::Rpm ],
-      yum_package:     [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
-
-      "debian" => {
-        ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Debian ],
-        package:  [ Chef::Resource::AptPackage, Chef::Provider::Package::Apt ],
-#        service: [ Chef::Resource::DebianService, Chef::Provider::Service::Debian ],
+    PROVIDERS =
+    {
+      bash:                   [ Chef::Resource::Bash, Chef::Provider::Script ],
+      breakpoint:             [ Chef::Resource::Breakpoint, Chef::Provider::Breakpoint ],
+      chef_gem:               [ Chef::Resource::ChefGem, Chef::Provider::Package::Rubygems ],
+      cookbook_file:          [ Chef::Resource::CookbookFile, Chef::Provider::CookbookFile ],
+      csh:                    [ Chef::Resource::Csh, Chef::Provider::Script ],
+      deploy:                 [ Chef::Resource::Deploy, Chef::Provider::Deploy::Timestamped ],
+      deploy_revision:        [ Chef::Resource::DeployRevision, Chef::Provider::Deploy::Revision ],
+      directory:              [ Chef::Resource::Directory, Chef::Provider::Directory ],
+      easy_install_package:   [ Chef::Resource::EasyInstallPackage, Chef::Provider::Package::EasyInstall ],
+      erl_call:               [ Chef::Resource::ErlCall, Chef::Provider::ErlCall ],
+      execute:                [ Chef::Resource::Execute, Chef::Provider::Execute ],
+      file:                   [ Chef::Resource::File, Chef::Provider::File ],
+      gem_package:            [ Chef::Resource::GemPackage, Chef::Provider::Package::Rubygems ],
+      git:                    [ Chef::Resource::Git, Chef::Provider::Git ],
+      group:                  [ Chef::Resource::Group, Chef::Provider::Group::Gpasswd ],
+      homebrew_package:       [ Chef::Resource::HomebrewPackage, Chef::Provider::Package::Homebrew ],
+      http_request:           [ Chef::Resource::HttpRequest, Chef::Provider::HttpRequest ],
+      ifconfig:               [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+      link:                   [ Chef::Resource::Link, Chef::Provider::Link ],
+      log:                    [ Chef::Resource::Log, Chef::Provider::Log::ChefLog ],
+      macports_package:       [ Chef::Resource::MacportsPackage, Chef::Provider::Package::Macports ],
+      mdadm:                  [ Chef::Resource::Mdadm, Chef::Provider::Mdadm ],
+      mount:                  [ Chef::Resource::Mount, Chef::Provider::Mount::Mount ],
+      perl:                   [ Chef::Resource::Perl, Chef::Provider::Script ],
+      portage_package:        [ Chef::Resource::PortagePackage, Chef::Provider::Package::Portage ],
+      python:                 [ Chef::Resource::Python, Chef::Provider::Script ],
+      remote_directory:       [ Chef::Resource::RemoteDirectory, Chef::Provider::RemoteDirectory ],
+      route:                  [ Chef::Resource::Route, Chef::Provider::Route ],
+      ruby:                   [ Chef::Resource::Ruby, Chef::Provider::Script ],
+      ruby_block:             [ Chef::Resource::RubyBlock, Chef::Provider::RubyBlock ],
+      script:                 [ Chef::Resource::Script, Chef::Provider::Script ],
+      subversion:             [ Chef::Resource::Subversion, Chef::Provider::Subversion ],
+      template:               [ Chef::Resource::Template, Chef::Provider::Template ],
+      timestamped_deploy:     [ Chef::Resource::TimestampedDeploy, Chef::Provider::Deploy::Timestamped ],
+      user:                   [ Chef::Resource::User, Chef::Provider::User::Useradd ],
+      whyrun_safe_ruby_block: [ Chef::Resource::WhyrunSafeRubyBlock, Chef::Provider::WhyrunSafeRubyBlock ],
+
+      # We want to check that these are unsupported:
+      apt_package: nil,
+      bff_package: nil,
+      dpkg_package: nil,
+      dsc_script: 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::Resource::AptPackage, Chef::Provider::Package::Apt ],
+        dpkg_package:    [ Chef::Resource::DpkgPackage, Chef::Provider::Package::Dpkg ],
+        pacman_package:  [ Chef::Resource::PacmanPackage, Chef::Provider::Package::Pacman ],
+        paludis_package: [ Chef::Resource::PaludisPackage, Chef::Provider::Package::Paludis ],
+        rpm_package:     [ Chef::Resource::RpmPackage, Chef::Provider::Package::Rpm ],
+        yum_package:     [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
 
         "debian" => {
-          "7.0" => {
-          },
-          "6.0" => {
-            ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
-#            service: [ Chef::Resource::InsservService, Chef::Provider::Service::Insserv ],
-          },
-          "5.0" => {
-            ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+          ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Debian ],
+          package:  [ Chef::Resource::AptPackage, Chef::Provider::Package::Apt ],
+  #        service: [ Chef::Resource::DebianService, Chef::Provider::Service::Debian ],
+
+          "debian" => {
+            "7.0" => {
+            },
+            "6.0" => {
+              ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+  #            service: [ Chef::Resource::InsservService, Chef::Provider::Service::Insserv ],
+            },
+            "5.0" => {
+              ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+            },
+          },
+          "gcel" => {
+            "3.1.4" => {
+              ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+            },
+          },
+          "linaro" => {
+            "3.1.4" => {
+              ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+            },
+          },
+          "linuxmint" => {
+            "3.1.4" => {
+              ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+  #            service: [ Chef::Resource::UpstartService, Chef::Provider::Service::Upstart ],
+            },
+          },
+          "raspbian" => {
+            "3.1.4" => {
+              ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+            },
+          },
+          "ubuntu" => {
+            "11.10" => {
+            },
+            "10.04" => {
+              ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
+            },
           },
         },
-        "gcel" => {
-          "3.1.4" => {
-            ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
-          },
-        },
-        "linaro" => {
-          "3.1.4" => {
-            ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
-          },
-        },
-        "linuxmint" => {
-          "3.1.4" => {
-            ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
-#            service: [ Chef::Resource::UpstartService, Chef::Provider::Service::Upstart ],
-          },
-        },
-        "raspbian" => {
-          "3.1.4" => {
-            ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
-          },
-        },
-        "ubuntu" => {
-          "11.10" => {
-          },
-          "10.04" => {
-            ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig ],
-          },
-        },
-      },
-
-      "arch" => {
-        # TODO should be Chef::Resource::PacmanPackage
-        package: [ Chef::Resource::Package, Chef::Provider::Package::Pacman ],
 
         "arch" => {
-          "3.1.4" => {
-          }
-        },
-      },
+          # TODO should be Chef::Resource::PacmanPackage
+          package: [ Chef::Resource::Package, Chef::Provider::Package::Pacman ],
 
-      "freebsd" => {
-        group: [ Chef::Resource::Group, Chef::Provider::Group::Pw ],
-        user:  [ Chef::Resource::User, Chef::Provider::User::Pw ],
+          "arch" => {
+            "3.1.4" => {
+            }
+          },
+        },
 
         "freebsd" => {
-          "3.1.4" => {
+          group: [ Chef::Resource::Group, Chef::Provider::Group::Pw ],
+          user:  [ Chef::Resource::User, Chef::Provider::User::Pw ],
+
+          "freebsd" => {
+            "3.1.4" => {
+            },
           },
         },
-      },
-      "suse" => {
-        group: [ Chef::Resource::Group, Chef::Provider::Group::Gpasswd ],
         "suse" => {
-          "12.0" => {
-          },
-          %w(11.1 11.2 11.3) => {
-            group: [ Chef::Resource::Group, Chef::Provider::Group::Suse ],
-          },
-        },
-        "opensuse" => {
-#          service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
-          package: [ Chef::Resource::ZypperPackage, Chef::Provider::Package::Zypper ],
-          group:   [ Chef::Resource::Group, Chef::Provider::Group::Usermod ],
-          "12.3" => {
-          },
-          "12.2" => {
-            group: [ Chef::Resource::Group, Chef::Provider::Group::Suse ],
+          group: [ Chef::Resource::Group, Chef::Provider::Group::Gpasswd ],
+          "suse" => {
+            "12.0" => {
+            },
+            %w(11.1 11.2 11.3) => {
+              group: [ Chef::Resource::Group, Chef::Provider::Group::Suse ],
+            },
+          },
+          "opensuse" => {
+  #          service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
+            package: [ Chef::Resource::ZypperPackage, Chef::Provider::Package::Zypper ],
+            group:   [ Chef::Resource::Group, Chef::Provider::Group::Usermod ],
+            "12.3" => {
+            },
+            "12.2" => {
+              group: [ Chef::Resource::Group, Chef::Provider::Group::Suse ],
+            },
           },
         },
-      },
-
-      "gentoo" => {
-        # TODO should be Chef::Resource::PortagePackage
-        package:         [ Chef::Resource::Package, Chef::Provider::Package::Portage ],
-        portage_package: [ Chef::Resource::PortagePackage, Chef::Provider::Package::Portage ],
-#        service: [ Chef::Resource::GentooService, Chef::Provider::Service::Gentoo ],
 
         "gentoo" => {
-          "3.1.4" => {
-          },
-        },
-      },
+          # TODO should be Chef::Resource::PortagePackage
+          package:         [ Chef::Resource::Package, Chef::Provider::Package::Portage ],
+          portage_package: [ Chef::Resource::PortagePackage, Chef::Provider::Package::Portage ],
+  #        service: [ Chef::Resource::GentooService, Chef::Provider::Service::Gentoo ],
 
-      "rhel" => {
-#        service: [ Chef::Resource::SystemdService, Chef::Provider::Service::Systemd ],
-        package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
-        ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Redhat ],
-
-        %w(amazon xcp xenserver ibm_powerkvm cloudlinux parallels) => {
-          "3.1.4" => {
-#            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
+          "gentoo" => {
+            "3.1.4" => {
+            },
           },
         },
-        %w(redhat centos scientific oracle) => {
-          "7.0" => {
-          },
-          "6.0" => {
-#            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
-          },
-        },
-        "fedora" => {
-          "15.0" => {
-          },
-          "14.0" => {
-#            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
+
+        "rhel" => {
+  #        service: [ Chef::Resource::SystemdService, Chef::Provider::Service::Systemd ],
+          package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
+          ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Redhat ],
+
+          %w(amazon xcp xenserver ibm_powerkvm cloudlinux parallels) => {
+            "3.1.4" => {
+  #            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
+            },
+          },
+          %w(redhat centos scientific oracle) => {
+            "7.0" => {
+            },
+            "6.0" => {
+  #            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
+            },
+          },
+          "fedora" => {
+            "15.0" => {
+            },
+            "14.0" => {
+  #            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
+            },
           },
         },
-      },
 
-    },
+      },
 
-    "darwin" => {
-      %w(mac_os_x mac_os_x_server) => {
-        group:   [ Chef::Resource::Group, Chef::Provider::Group::Dscl ],
-        package: [ Chef::Resource::HomebrewPackage, Chef::Provider::Package::Homebrew ],
-        user:    [ Chef::Resource::User, Chef::Provider::User::Dscl ],
+      "darwin" => {
+        %w(mac_os_x mac_os_x_server) => {
+          group:   [ Chef::Resource::Group, Chef::Provider::Group::Dscl ],
+          package: [ Chef::Resource::HomebrewPackage, Chef::Provider::Package::Homebrew ],
+          user:    [ Chef::Resource::User, Chef::Provider::User::Dscl ],
 
-        "mac_os_x" => {
-          "10.9.2" => {
+          "mac_os_x" => {
+            "10.9.2" => {
+            },
           },
         },
       },
-    },
-
-    "windows" => {
-      batch:             [ Chef::Resource::Batch, Chef::Provider::Batch ],
-      dsc_script:        [ Chef::Resource::DscScript, Chef::Provider::DscScript ],
-      env:               [ Chef::Resource::Env, Chef::Provider::Env::Windows ],
-      group:             [ Chef::Resource::Group, Chef::Provider::Group::Windows ],
-      mount:             [ Chef::Resource::Mount, Chef::Provider::Mount::Windows ],
-      package:           [ Chef::Resource::WindowsPackage, Chef::Provider::Package::Windows ],
-      powershell_script: [ Chef::Resource::PowershellScript, Chef::Provider::PowershellScript ],
-      service:           [ Chef::Resource::WindowsService, Chef::Provider::Service::Windows ],
-      user:              [ Chef::Resource::User, Chef::Provider::User::Windows ],
-      windows_package:   [ Chef::Resource::WindowsPackage, Chef::Provider::Package::Windows ],
-      windows_service:   [ Chef::Resource::WindowsService, Chef::Provider::Service::Windows ],
 
       "windows" => {
-        %w(mswin mingw32 windows) => {
-          "10.9.2" => {
+        batch:             [ Chef::Resource::Batch, Chef::Provider::Batch ],
+        dsc_script:        [ Chef::Resource::DscScript, Chef::Provider::DscScript ],
+        env:               [ Chef::Resource::Env, Chef::Provider::Env::Windows ],
+        group:             [ Chef::Resource::Group, Chef::Provider::Group::Windows ],
+        mount:             [ Chef::Resource::Mount, Chef::Provider::Mount::Windows ],
+        package:           [ Chef::Resource::WindowsPackage, Chef::Provider::Package::Windows ],
+        powershell_script: [ Chef::Resource::PowershellScript, Chef::Provider::PowershellScript ],
+        service:           [ Chef::Resource::WindowsService, Chef::Provider::Service::Windows ],
+        user:              [ Chef::Resource::User, Chef::Provider::User::Windows ],
+        windows_package:   [ Chef::Resource::WindowsPackage, Chef::Provider::Package::Windows ],
+        windows_service:   [ Chef::Resource::WindowsService, Chef::Provider::Service::Windows ],
+
+        "windows" => {
+          %w(mswin mingw32 windows) => {
+            "10.9.2" => {
+            },
           },
         },
       },
-    },
-
-    "aix" => {
-      bff_package: [ Chef::Resource::BffPackage, Chef::Provider::Package::Aix ],
-      cron: [ Chef::Resource::Cron, Chef::Provider::Cron::Aix ],
-      group: [ Chef::Resource::Group, Chef::Provider::Group::Aix ],
-      ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Aix ],
-      mount: [ Chef::Resource::Mount, Chef::Provider::Mount::Aix ],
-      # TODO should be Chef::Resource::BffPackage
-      package: [ Chef::Resource::Package, Chef::Provider::Package::Aix ],
-      rpm_package: [ Chef::Resource::RpmPackage, Chef::Provider::Package::Rpm ],
-      user: [ Chef::Resource::User, Chef::Provider::User::Aix ],
-#      service: [ Chef::Resource::AixService, Chef::Provider::Service::Aix ],
 
       "aix" => {
+        bff_package: [ Chef::Resource::BffPackage, Chef::Provider::Package::Aix ],
+        cron: [ Chef::Resource::Cron, Chef::Provider::Cron::Aix ],
+        group: [ Chef::Resource::Group, Chef::Provider::Group::Aix ],
+        ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Aix ],
+        mount: [ Chef::Resource::Mount, Chef::Provider::Mount::Aix ],
+        # TODO should be Chef::Resource::BffPackage
+        package: [ Chef::Resource::Package, Chef::Provider::Package::Aix ],
+        rpm_package: [ Chef::Resource::RpmPackage, Chef::Provider::Package::Rpm ],
+        user: [ Chef::Resource::User, Chef::Provider::User::Aix ],
+  #      service: [ Chef::Resource::AixService, Chef::Provider::Service::Aix ],
+
         "aix" => {
-          "5.6" => {
+          "aix" => {
+            "5.6" => {
+            },
           },
         },
       },
-    },
 
-    "hpux" => {
       "hpux" => {
         "hpux" => {
-          "3.1.4" => {
-            group: [ Chef::Resource::Group, Chef::Provider::Group::Usermod ]
+          "hpux" => {
+            "3.1.4" => {
+              group: [ Chef::Resource::Group, Chef::Provider::Group::Usermod ]
+            }
           }
         }
-      }
-    },
+      },
 
-    "netbsd" => {
       "netbsd" => {
         "netbsd" => {
-          "3.1.4" => {
-            group: [ Chef::Resource::Group, Chef::Provider::Group::Groupmod ],
+          "netbsd" => {
+            "3.1.4" => {
+              group: [ Chef::Resource::Group, Chef::Provider::Group::Groupmod ],
+            },
           },
         },
       },
-    },
-
-    "openbsd" => {
-      group: [ Chef::Resource::Group, Chef::Provider::Group::Usermod ],
-      package: [ Chef::Resource::OpenbsdPackage, Chef::Provider::Package::Openbsd ],
 
       "openbsd" => {
+        group: [ Chef::Resource::Group, Chef::Provider::Group::Usermod ],
+        package: [ Chef::Resource::OpenbsdPackage, Chef::Provider::Package::Openbsd ],
+
         "openbsd" => {
-          "3.1.4" => {
+          "openbsd" => {
+            "3.1.4" => {
+            },
           },
         },
       },
-    },
 
-    "solaris2" => {
-      group:           [ Chef::Resource::Group, Chef::Provider::Group::Usermod ],
-      ips_package:     [ Chef::Resource::IpsPackage, Chef::Provider::Package::Ips ],
-      package:         [ Chef::Resource::SolarisPackage, Chef::Provider::Package::Solaris ],
-      mount:           [ Chef::Resource::Mount, Chef::Provider::Mount::Solaris ],
-      solaris_package: [ Chef::Resource::SolarisPackage, Chef::Provider::Package::Solaris ],
-
-      "smartos" => {
-        smartos_package: [ Chef::Resource::SmartosPackage, Chef::Provider::Package::SmartOS ],
-        package:         [ Chef::Resource::SmartosPackage, Chef::Provider::Package::SmartOS ],
+      "solaris2" => {
+        group:           [ Chef::Resource::Group, Chef::Provider::Group::Usermod ],
+        ips_package:     [ Chef::Resource::IpsPackage, Chef::Provider::Package::Ips ],
+        package:         [ Chef::Resource::SolarisPackage, Chef::Provider::Package::Solaris ],
+        mount:           [ Chef::Resource::Mount, Chef::Provider::Mount::Solaris ],
+        solaris_package: [ Chef::Resource::SolarisPackage, Chef::Provider::Package::Solaris ],
 
         "smartos" => {
-          "3.1.4" => {
+          smartos_package: [ Chef::Resource::SmartosPackage, Chef::Provider::Package::SmartOS ],
+          package:         [ Chef::Resource::SmartosPackage, Chef::Provider::Package::SmartOS ],
+
+          "smartos" => {
+            "3.1.4" => {
+            },
           },
         },
-      },
 
-      "solaris2" => {
-        "nexentacore" => {
-          "3.1.4" => {
+        "solaris2" => {
+          "nexentacore" => {
+            "3.1.4" => {
+            },
           },
-        },
-        "omnios" => {
-          "3.1.4" => {
-            user: [ Chef::Resource::User, Chef::Provider::User::Solaris ],
-          }
-        },
-        "openindiana" => {
-          "3.1.4" => {
+          "omnios" => {
+            "3.1.4" => {
+              user: [ Chef::Resource::User, Chef::Provider::User::Solaris ],
+            }
           },
-        },
-        "opensolaris" => {
-          "3.1.4" => {
+          "openindiana" => {
+            "3.1.4" => {
+            },
           },
-        },
-        "solaris2" => {
-          user: [ Chef::Resource::User, Chef::Provider::User::Solaris ],
-          "5.11" => {
-            package: [ Chef::Resource::IpsPackage, Chef::Provider::Package::Ips ],
+          "opensolaris" => {
+            "3.1.4" => {
+            },
           },
-          "5.9" => {
+          "solaris2" => {
+            user: [ Chef::Resource::User, Chef::Provider::User::Solaris ],
+            "5.11" => {
+              package: [ Chef::Resource::IpsPackage, Chef::Provider::Package::Ips ],
+            },
+            "5.9" => {
+            },
           },
         },
-      },
 
-    },
+      },
 
-    "solaris" => {
       "solaris" => {
         "solaris" => {
-          "3.1.4" => {
+          "solaris" => {
+            "3.1.4" => {
+            },
           },
         },
       },
-    },
 
-    "exherbo" => {
       "exherbo" => {
         "exherbo" => {
-          "3.1.4" => {
-            # TODO should be Chef::Resource::PaludisPackage
-            package: [ Chef::Resource::Package, Chef::Provider::Package::Paludis ]
+          "exherbo" => {
+            "3.1.4" => {
+              # TODO should be Chef::Resource::PaludisPackage
+              package: [ Chef::Resource::Package, Chef::Provider::Package::Paludis ]
+            }
           }
         }
       }
     }
-  }
-
-  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
-        create_provider_tests(value, next_test, expected, next_filter)
+
+    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
+          create_provider_tests(value, next_test, expected, next_filter)
+        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)
+      # 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
-  end
 
-  create_provider_tests(PROVIDERS, {}, {}, :os)
+    create_provider_tests(PROVIDERS, {}, {}, :os)
+  end
 end