chef 11.12.0.alpha.1-x86-mingw32 → 11.12.0.rc.1-x86-mingw32

data/spec/unit/knife/ssl_fetch_spec.rb

@@ -0,0 +1,151 @@
+#
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'chef/knife/ssl_fetch'
+
+describe Chef::Knife::SslFetch do
+
+  let(:name_args) { [] }
+  let(:stdout_io) { StringIO.new }
+  let(:stderr_io) { StringIO.new }
+
+  def stderr
+    stderr_io.string
+  end
+
+  def stdout
+    stdout_io.string
+  end
+
+  subject(:ssl_fetch) do
+    s = Chef::Knife::SslFetch.new
+    s.name_args = name_args
+    s.ui.stub(:stdout).and_return(stdout_io)
+    s.ui.stub(:stderr).and_return(stderr_io)
+    s
+  end
+
+  context "when no arguments are given" do
+
+    before do
+      Chef::Config.chef_server_url = "https://example.com:8443/chef-server"
+    end
+
+    it "uses the chef_server_url as the host to fetch" do
+      expect(ssl_fetch.host).to eq("example.com")
+      expect(ssl_fetch.port).to eq(8443)
+    end
+  end
+
+  context "when a specific URI is given" do
+    let(:name_args) { %w{https://example.test:10443/foo} }
+
+    it "fetchs the SSL configuration against the given host" do
+      expect(ssl_fetch.host).to eq("example.test")
+      expect(ssl_fetch.port).to eq(10443)
+    end
+  end
+
+  context "when an invalid URI is given" do
+
+    let(:name_args) { %w{foo.test} }
+
+    it "prints an error and exits" do
+      expect { ssl_fetch.run }.to raise_error(SystemExit)
+      expected_stdout=<<-E
+USAGE: knife ssl fetch [URL] (options)
+E
+      expected_stderr=<<-E
+ERROR: Given URI: `foo.test' is invalid
+E
+      expect(stdout_io.string).to eq(expected_stdout)
+      expect(stderr_io.string).to eq(expected_stderr)
+    end
+
+    context "and its malformed enough to make URI.parse barf" do
+
+      let(:name_args) { %w{ftp://lkj\\blah:example.com/blah} }
+
+      it "prints an error and exits" do
+        expect { ssl_fetch.run }.to raise_error(SystemExit)
+        expected_stdout=<<-E
+USAGE: knife ssl fetch [URL] (options)
+E
+        expected_stderr=<<-E
+ERROR: Given URI: `#{name_args[0]}' is invalid
+E
+        expect(stdout_io.string).to eq(expected_stdout)
+        expect(stderr_io.string).to eq(expected_stderr)
+      end
+    end
+  end
+
+  describe "normalizing CNs for use as paths" do
+
+    it "normalizes '*' to 'wildcard'" do
+      expect(ssl_fetch.normalize_cn("*.example.com")).to eq("wildcard_example_com")
+    end
+
+    it "normalizes non-alnum and hyphen characters to underscores" do
+      expect(ssl_fetch.normalize_cn("Billy-Bob's Super Awesome CA!")).to eq("Billy-Bob_s_Super_Awesome_CA_")
+    end
+
+  end
+
+  describe "fetching the remote cert chain" do
+
+    let(:name_args) { %w{https://foo.example.com:8443} }
+
+    let(:tcp_socket) { double(TCPSocket) }
+    let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket) }
+
+    let(:self_signed_crt_path) { File.join(CHEF_SPEC_DATA, "trusted_certs", "example.crt") }
+    let(:self_signed_crt) { OpenSSL::X509::Certificate.new(File.read(self_signed_crt_path)) }
+
+    let(:trusted_certs_dir) { Dir.mktmpdir }
+
+    def run
+      ssl_fetch.run
+    rescue Exception
+      puts "OUT: #{stdout_io.string}"
+      puts "ERR: #{stderr_io.string}"
+      raise
+    end
+
+    before do
+      Chef::Config.trusted_certs_dir = trusted_certs_dir
+
+      TCPSocket.should_receive(:new).with("foo.example.com", 8443).and_return(tcp_socket)
+      OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_fetch.noverify_peer_ssl_context).and_return(ssl_socket)
+      ssl_socket.should_receive(:connect)
+      ssl_socket.should_receive(:peer_cert_chain).and_return([self_signed_crt])
+    end
+
+    after do
+      FileUtils.rm_rf(trusted_certs_dir)
+    end
+
+    it "fetches the cert chain and writes the certs to the trusted_certs_dir" do
+      run
+      stored_cert_path = File.join(trusted_certs_dir, "example_local.crt")
+      expect(File).to exist(stored_cert_path)
+      expect(File.read(stored_cert_path)).to eq(File.read(self_signed_crt_path))
+    end
+  end
+end

data/spec/unit/mixin/deep_merge_spec.rb

@@ -284,6 +284,10 @@ describe Chef::Mixin::DeepMerge do
       ret.should == {"property" => ["1","2","3","4","5","6"]}
     end
 
+    it "should not error merging un-dupable objects" do
+      @dm.deep_merge(nil, 4)
+    end
+
   end
 
   describe "role_merge" do
@@ -347,5 +351,18 @@ describe Chef::Mixin::DeepMerge do
       merged_result["top_level_a"]["1_deep_b"].should == %w[B B B]
     end
 
+    it "does not mutate deeply-nested original hashes by default" do
+      merge_ee_hash =   {"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_a" => "foo" }}}}
+      merge_with_hash = {"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_b" => "bar" }}}}
+      @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
+      merge_ee_hash.should == {"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_a" => "foo" }}}}
+      merge_with_hash.should == {"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_b" => "bar" }}}}
+    end
+
+    it "does not error merging un-dupable items" do
+      merge_ee_hash = {"top_level_a" => 1, "top_level_b" => false}
+      merge_with_hash = {"top_level_a" => 2, "top_level_b" => true }
+      @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
+    end
   end
 end

data/spec/unit/node/immutable_collections_spec.rb

@@ -54,6 +54,32 @@ describe Chef::Node::ImmutableMash do
     @immutable_mash[:top_level_4][:level2].should be_a(Chef::Node::ImmutableMash)
   end
 
+  describe "to_hash" do
+    before do
+      @copy = @immutable_mash.to_hash
+    end
+
+    it "converts an immutable mash to a new mutable hash" do
+      @copy.should be_instance_of(Hash)
+    end
+
+    it "converts an immutable nested mash to a new mutable hash" do
+      @copy['top_level_4']['level2'].should be_instance_of(Hash)
+    end
+
+    it "converts an immutable nested array to a new mutable array" do
+      @copy['top_level_2'].should be_instance_of(Array)
+    end
+
+    it "should create a mash with the same content" do
+      @copy.should == @immutable_mash
+    end
+
+    it 'should allow mutation' do
+      lambda { @copy['m'] = 'm' }.should_not raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+
+  end
 
   [
     :[]=,
@@ -87,6 +113,8 @@ describe Chef::Node::ImmutableArray do
 
   before do
     @immutable_array = Chef::Node::ImmutableArray.new(%w[foo bar baz] + Array(1..3) + [nil, true, false, [ "el", 0, nil ] ])
+    immutable_mash = Chef::Node::ImmutableMash.new({:m => 'm'})
+    @immutable_nested_array = Chef::Node::ImmutableArray.new(["level1",@immutable_array, immutable_mash])
   end
 
   ##
@@ -139,5 +167,32 @@ describe Chef::Node::ImmutableArray do
     mutable[0] = :value
     mutable[0].should == :value
   end
+
+  describe "to_a" do
+    before do
+      @copy = @immutable_nested_array.to_a
+    end
+
+    it "converts an immutable array to a new mutable array" do
+      @copy.should be_instance_of(Array)
+    end
+
+    it "converts an immutable nested array to a new mutable array" do
+      @copy[1].should be_instance_of(Array)
+    end
+
+    it "converts an immutable nested mash to a new mutable hash" do
+      @copy[2].should be_instance_of(Hash)
+    end
+
+    it "should create an array with the same content" do
+      @copy.should == @immutable_nested_array
+    end
+
+    it 'should allow mutation' do
+      lambda { @copy << 'm' }.should_not raise_error(Chef::Exceptions::ImmutableAttributeModification)
+    end
+  end
+
 end
 

data/spec/unit/node_spec.rb

@@ -724,6 +724,15 @@ describe Chef::Node do
       json.should =~ /\"run_list\":\[\"role\[Cthulu\]\",\"role\[Hastur\]\"\]/
     end
 
+    it "should serialize the correct run list", :json => true do
+      node.run_list << "role[marxist]"
+      node.run_list << "role[leninist]"
+      node.override_runlist << "role[stalinist]"
+      node.run_list.should be_include("role[stalinist]")
+      json = Chef::JSONCompat.to_json(node)
+      json.should =~ /\"run_list\":\[\"role\[marxist\]\",\"role\[leninist\]\"\]/
+    end
+
     it "merges the override components into a combined override object" do
       node.attributes.role_override["role override"] = "role override"
       node.attributes.env_override["env override"] = "env override"

data/spec/unit/platform/query_helpers_spec.rb

@@ -0,0 +1,32 @@
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe "Chef::Platform#windows_server_2003?" do
+  it "returns false early when not on windows" do
+    Chef::Platform.stub(:windows?).and_return(false)
+    expect(Chef::Platform).not_to receive(:require) 
+    expect(Chef::Platform.windows_server_2003?).to be_false
+  end
+
+  # CHEF-4888: Need to call WIN32OLE.ole_initialize in new threads
+  it "does not raise an exception" do
+    expect { Thread.fork { Chef::Platform.windows_server_2003? }.join }.not_to raise_error
+  end
+end

data/spec/unit/platform_spec.rb

@@ -37,7 +37,8 @@ describe "Chef::Platform supports" do
     :mswin,
     :mingw32,
     :windows,
-    :gcel
+    :gcel,
+    :ibm_powerkvm
   ].each do |platform|
     it "#{platform}" do
       Chef::Platform.platforms.should have_key(platform)
@@ -47,209 +48,226 @@ end
 
 describe Chef::Platform do
 
-  before :all do
-    @original_platform_map = Chef::Platform.platforms
-  end
+  context "while testing with fake data" do
 
-  after :all do ||
-    Chef::Platform.platforms = @original_platform_map
-  end
+    before :all do
+      @original_platform_map = Chef::Platform.platforms
+    end
 
-  before(:each) do
-    Chef::Platform.platforms = {
-      :darwin => {
-        ">= 10.11" => {
-          :file => "new_darwinian"
+    after :all do ||
+      Chef::Platform.platforms = @original_platform_map
+    end
+
+    before(:each) do
+      Chef::Platform.platforms = {
+        :darwin => {
+          ">= 10.11" => {
+            :file => "new_darwinian"
+          },
+          "9.2.2" => {
+            :file => "darwinian",
+            :else => "thing"
+          },
+          :default => {
+            :file => "old school",
+            :snicker => "snack"
+          }
         },
-        "9.2.2" => {
-          :file => "darwinian",
-          :else => "thing"
+        :mars_volta => {
         },
         :default => {
-          :file => "old school",
-          :snicker => "snack"
+          :file => Chef::Provider::File,
+          :pax => "brittania",
+          :cat => "nice"
         }
-      },
-      :mars_volta => {
-      },
-      :default => {
-        :file => Chef::Provider::File,
-        :pax => "brittania",
-        :cat => "nice"
       }
-    }
-    @events = Chef::EventDispatch::Dispatcher.new
-  end
+      @events = Chef::EventDispatch::Dispatcher.new
+    end
 
-  it "should allow you to look up a platform by name and version, returning the provider map for it" do
-    pmap = Chef::Platform.find("Darwin", "9.2.2")
-    pmap.should be_a_kind_of(Hash)
-    pmap[:file].should eql("darwinian")
-  end
+    it "should allow you to look up a platform by name and version, returning the provider map for it" do
+      pmap = Chef::Platform.find("Darwin", "9.2.2")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:file].should eql("darwinian")
+    end
 
-  it "should allow you to look up a platform by name and version using \"greater than\" style operators" do
-    pmap = Chef::Platform.find("Darwin", "11.1.0")
-    pmap.should be_a_kind_of(Hash)
-    pmap[:file].should eql("new_darwinian")
-  end
+    it "should allow you to look up a platform by name and version using \"greater than\" style operators" do
+      pmap = Chef::Platform.find("Darwin", "11.1.0")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:file].should eql("new_darwinian")
+    end
 
-  it "should use the default providers for an os if the specific version does not exist" do
-    pmap = Chef::Platform.find("Darwin", "1")
-    pmap.should be_a_kind_of(Hash)
-    pmap[:file].should eql("old school")
-  end
+    it "should use the default providers for an os if the specific version does not exist" do
+      pmap = Chef::Platform.find("Darwin", "1")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:file].should eql("old school")
+    end
 
-  it "should use the default providers if the os doesn't give me a default, but does exist" do
-    pmap = Chef::Platform.find("mars_volta", "1")
-    pmap.should be_a_kind_of(Hash)
-    pmap[:file].should eql(Chef::Provider::File)
-  end
+    it "should use the default providers if the os doesn't give me a default, but does exist" do
+      pmap = Chef::Platform.find("mars_volta", "1")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:file].should eql(Chef::Provider::File)
+    end
 
-  it "should use the default provider if the os does not exist" do
-    pmap = Chef::Platform.find("AIX", "1")
-    pmap.should be_a_kind_of(Hash)
-    pmap[:file].should eql(Chef::Provider::File)
-  end
+    it "should use the default provider if the os does not exist" do
+      pmap = Chef::Platform.find("AIX", "1")
+      pmap.should be_a_kind_of(Hash)
+      pmap[:file].should eql(Chef::Provider::File)
+    end
 
-  it "should merge the defaults for an os with the specific version" do
-    pmap = Chef::Platform.find("Darwin", "9.2.2")
-    pmap[:file].should eql("darwinian")
-    pmap[:snicker].should eql("snack")
-  end
+    it "should merge the defaults for an os with the specific version" do
+      pmap = Chef::Platform.find("Darwin", "9.2.2")
+      pmap[:file].should eql("darwinian")
+      pmap[:snicker].should eql("snack")
+    end
 
-  it "should merge the defaults for an os with the universal defaults" do
-    pmap = Chef::Platform.find("Darwin", "9.2.2")
-    pmap[:file].should eql("darwinian")
-    pmap[:pax].should eql("brittania")
-  end
+    it "should merge the defaults for an os with the universal defaults" do
+      pmap = Chef::Platform.find("Darwin", "9.2.2")
+      pmap[:file].should eql("darwinian")
+      pmap[:pax].should eql("brittania")
+    end
 
-  it "should allow you to look up a provider for a platform directly by symbol" do
-    Chef::Platform.find_provider("Darwin", "9.2.2", :file).should eql("darwinian")
-  end
+    it "should allow you to look up a provider for a platform directly by symbol" do
+      Chef::Platform.find_provider("Darwin", "9.2.2", :file).should eql("darwinian")
+    end
 
-  it "should raise an exception if a provider cannot be found for a resource type" do
-    lambda { Chef::Platform.find_provider("Darwin", "9.2.2", :coffee) }.should raise_error(ArgumentError)
-  end
+    it "should raise an exception if a provider cannot be found for a resource type" do
+      lambda { Chef::Platform.find_provider("Darwin", "9.2.2", :coffee) }.should raise_error(ArgumentError)
+    end
 
-  it "should look up a provider for a resource with a Chef::Resource object" do
-    kitty = Chef::Resource::Cat.new("loulou")
-    Chef::Platform.find_provider("Darwin", "9.2.2", kitty).should eql("nice")
-  end
+    it "should look up a provider for a resource with a Chef::Resource object" do
+      kitty = Chef::Resource::Cat.new("loulou")
+      Chef::Platform.find_provider("Darwin", "9.2.2", kitty).should eql("nice")
+    end
 
-  it "should look up a provider with a node and a Chef::Resource object" do
-    kitty = Chef::Resource::Cat.new("loulou")
-    node = Chef::Node.new
-    node.name("Intel")
-    node.automatic_attrs[:platform] = "mac_os_x"
-    node.automatic_attrs[:platform_version] = "9.2.2"
-    Chef::Platform.find_provider_for_node(node, kitty).should eql("nice")
-  end
+    it "should look up a provider with a node and a Chef::Resource object" do
+      kitty = Chef::Resource::Cat.new("loulou")
+      node = Chef::Node.new
+      node.name("Intel")
+      node.automatic_attrs[:platform] = "mac_os_x"
+      node.automatic_attrs[:platform_version] = "9.2.2"
+      Chef::Platform.find_provider_for_node(node, kitty).should eql("nice")
+    end
 
-  it "should not throw an exception when the platform version has an unknown format" do
-    Chef::Platform.find_provider(:darwin, "bad-version", :file).should eql("old school")
-  end
+    it "should not throw an exception when the platform version has an unknown format" do
+      Chef::Platform.find_provider(:darwin, "bad-version", :file).should eql("old school")
+    end
 
-  it "should prefer an explicit provider" do
-    kitty = Chef::Resource::Cat.new("loulou")
-    kitty.stub(:provider).and_return(Chef::Provider::File)
-    node = Chef::Node.new
-    node.name("Intel")
-    node.automatic_attrs[:platform] = "mac_os_x"
-    node.automatic_attrs[:platform_version] = "9.2.2"
-    Chef::Platform.find_provider_for_node(node, kitty).should eql(Chef::Provider::File)
-  end
+    it "should prefer an explicit provider" do
+      kitty = Chef::Resource::Cat.new("loulou")
+      kitty.stub(:provider).and_return(Chef::Provider::File)
+      node = Chef::Node.new
+      node.name("Intel")
+      node.automatic_attrs[:platform] = "mac_os_x"
+      node.automatic_attrs[:platform_version] = "9.2.2"
+      Chef::Platform.find_provider_for_node(node, kitty).should eql(Chef::Provider::File)
+    end
 
-  it "should look up a provider based on the resource name if nothing else matches" do
-    kitty = Chef::Resource::Cat.new("loulou")
-    class Chef::Provider::Cat < Chef::Provider; end
-    Chef::Platform.platforms[:default].delete(:cat)
-    node = Chef::Node.new
-    node.name("Intel")
-    node.automatic_attrs[:platform] = "mac_os_x"
-    node.automatic_attrs[:platform_version] = "8.5"
-    Chef::Platform.find_provider_for_node(node, kitty).should eql(Chef::Provider::Cat)
-  end
+    it "should look up a provider based on the resource name if nothing else matches" do
+      kitty = Chef::Resource::Cat.new("loulou")
+      class Chef::Provider::Cat < Chef::Provider; end
+      Chef::Platform.platforms[:default].delete(:cat)
+      node = Chef::Node.new
+      node.name("Intel")
+      node.automatic_attrs[:platform] = "mac_os_x"
+      node.automatic_attrs[:platform_version] = "8.5"
+      Chef::Platform.find_provider_for_node(node, kitty).should eql(Chef::Provider::Cat)
+    end
 
-  def setup_file_resource
-    node = Chef::Node.new
-    node.automatic_attrs[:platform] = "mac_os_x"
-    node.automatic_attrs[:platform_version] = "9.2.2"
-    run_context = Chef::RunContext.new(node, {}, @events)
-    [ Chef::Resource::File.new("whateva", run_context), run_context ]
-  end
+    def setup_file_resource
+      node = Chef::Node.new
+      node.automatic_attrs[:platform] = "mac_os_x"
+      node.automatic_attrs[:platform_version] = "9.2.2"
+      run_context = Chef::RunContext.new(node, {}, @events)
+      [ Chef::Resource::File.new("whateva", run_context), run_context ]
+    end
 
-  it "returns a provider object given a Chef::Resource object which has a valid run context and an action" do
-    file, run_context = setup_file_resource
-    provider = Chef::Platform.provider_for_resource(file, :foo)
-    provider.should be_an_instance_of(Chef::Provider::File)
-    provider.new_resource.should equal(file)
-    provider.run_context.should equal(run_context)
-  end
+    it "returns a provider object given a Chef::Resource object which has a valid run context and an action" do
+      file, run_context = setup_file_resource
+      provider = Chef::Platform.provider_for_resource(file, :foo)
+      provider.should be_an_instance_of(Chef::Provider::File)
+      provider.new_resource.should equal(file)
+      provider.run_context.should equal(run_context)
+    end
 
-  it "returns a provider object given a Chef::Resource object which has a valid run context without an action" do
-    file, run_context = setup_file_resource
-    provider = Chef::Platform.provider_for_resource(file)
-    provider.should be_an_instance_of(Chef::Provider::File)
-    provider.new_resource.should equal(file)
-    provider.run_context.should equal(run_context)
-  end
+    it "returns a provider object given a Chef::Resource object which has a valid run context without an action" do
+      file, run_context = setup_file_resource
+      provider = Chef::Platform.provider_for_resource(file)
+      provider.should be_an_instance_of(Chef::Provider::File)
+      provider.new_resource.should equal(file)
+      provider.run_context.should equal(run_context)
+    end
 
-  it "raises an error when trying to find the provider for a resource with no run context" do
-    file = Chef::Resource::File.new("whateva")
-    lambda {Chef::Platform.provider_for_resource(file)}.should raise_error(ArgumentError)
-  end
+    it "raises an error when trying to find the provider for a resource with no run context" do
+      file = Chef::Resource::File.new("whateva")
+      lambda {Chef::Platform.provider_for_resource(file)}.should raise_error(ArgumentError)
+    end
 
-  it "does not support finding a provider by resource and node -- a run context is required" do
-    lambda {Chef::Platform.provider_for_node('node', 'resource')}.should raise_error(NotImplementedError)
-  end
+    it "does not support finding a provider by resource and node -- a run context is required" do
+      lambda {Chef::Platform.provider_for_node('node', 'resource')}.should raise_error(NotImplementedError)
+    end
+
+    it "should update the provider map with map" do
+      Chef::Platform.set(
+           :platform => :darwin,
+           :version => "9.2.2",
+           :resource => :file,
+           :provider => "masterful"
+      )
+      Chef::Platform.platforms[:darwin]["9.2.2"][:file].should eql("masterful")
+      Chef::Platform.set(
+           :platform => :darwin,
+           :resource => :file,
+           :provider => "masterful"
+      )
+      Chef::Platform.platforms[:darwin][:default][:file].should eql("masterful")
+      Chef::Platform.set(
+           :resource => :file,
+           :provider => "masterful"
+      )
+      Chef::Platform.platforms[:default][:file].should eql("masterful")
+
+      Chef::Platform.set(
+           :platform => :hero,
+           :version => "9.2.2",
+           :resource => :file,
+           :provider => "masterful"
+      )
+      Chef::Platform.platforms[:hero]["9.2.2"][:file].should eql("masterful")
+
+      Chef::Platform.set(
+           :resource => :file,
+           :provider => "masterful"
+      )
+      Chef::Platform.platforms[:default][:file].should eql("masterful")
+
+      Chef::Platform.platforms = {}
+
+      Chef::Platform.set(
+           :resource => :file,
+           :provider => "masterful"
+      )
+      Chef::Platform.platforms[:default][:file].should eql("masterful")
+
+      Chef::Platform.platforms = { :neurosis => {} }
+      Chef::Platform.set(:platform => :neurosis, :resource => :package, :provider => "masterful")
+      Chef::Platform.platforms[:neurosis][:default][:package].should eql("masterful")
 
-  it "should update the provider map with map" do
-    Chef::Platform.set(
-         :platform => :darwin,
-         :version => "9.2.2",
-         :resource => :file,
-         :provider => "masterful"
-    )
-    Chef::Platform.platforms[:darwin]["9.2.2"][:file].should eql("masterful")
-    Chef::Platform.set(
-         :platform => :darwin,
-         :resource => :file,
-         :provider => "masterful"
-    )
-    Chef::Platform.platforms[:darwin][:default][:file].should eql("masterful")
-    Chef::Platform.set(
-         :resource => :file,
-         :provider => "masterful"
-    )
-    Chef::Platform.platforms[:default][:file].should eql("masterful")
-
-    Chef::Platform.set(
-         :platform => :hero,
-         :version => "9.2.2",
-         :resource => :file,
-         :provider => "masterful"
-    )
-    Chef::Platform.platforms[:hero]["9.2.2"][:file].should eql("masterful")
-
-    Chef::Platform.set(
-         :resource => :file,
-         :provider => "masterful"
-    )
-    Chef::Platform.platforms[:default][:file].should eql("masterful")
-
-    Chef::Platform.platforms = {}
-
-    Chef::Platform.set(
-         :resource => :file,
-         :provider => "masterful"
-    )
-    Chef::Platform.platforms[:default][:file].should eql("masterful")
-
-    Chef::Platform.platforms = { :neurosis => {} }
-    Chef::Platform.set(:platform => :neurosis, :resource => :package, :provider => "masterful")
-    Chef::Platform.platforms[:neurosis][:default][:package].should eql("masterful")
+    end
 
   end
 
+  context "while testing the configured platform data" do
+
+    it "should use the solaris package provider on Solaris <11" do
+      pmap = Chef::Platform.find("Solaris2", "5.9")
+      pmap[:package].should eql(Chef::Provider::Package::Solaris)
+    end
+
+    it "should use the IPS package provider on Solaris 11" do
+      pmap = Chef::Platform.find("Solaris2", "5.11")
+      pmap[:package].should eql(Chef::Provider::Package::Ips)
+    end
+
+  end
 
 end