chef 12.18.31-universal-mingw32 → 12.19.33-universal-mingw32

data/spec/unit/knife/ssh_spec.rb

@@ -21,54 +21,53 @@ require "net/ssh"
 require "net/ssh/multi"
 
 describe Chef::Knife::Ssh do
-  before(:each) do
-    Chef::Config[:client_key] = CHEF_SPEC_DATA + "/ssl/private_key.pem"
-  end
+  let(:query_result) { double("chef search results") }
 
   before do
+    Chef::Config[:client_key] = CHEF_SPEC_DATA + "/ssl/private_key.pem"
     @knife = Chef::Knife::Ssh.new
     @knife.merge_configs
-    @node_foo = Chef::Node.new
-    @node_foo.automatic_attrs[:fqdn] = "foo.example.org"
-    @node_foo.automatic_attrs[:ipaddress] = "10.0.0.1"
+    @node_foo = {}
+    @node_foo["fqdn"] = "foo.example.org"
+    @node_foo["ipaddress"] = "10.0.0.1"
+    @node_foo["cloud"] = {}
+
+    @node_bar = {}
+    @node_bar["fqdn"] = "bar.example.org"
+    @node_bar["ipaddress"] = "10.0.0.2"
+    @node_bar["cloud"] = {}
 
-    @node_bar = Chef::Node.new
-    @node_bar.automatic_attrs[:fqdn] = "bar.example.org"
-    @node_bar.automatic_attrs[:ipaddress] = "10.0.0.2"
   end
 
   describe "#configure_session" do
     context "manual is set to false (default)" do
       before do
         @knife.config[:manual] = false
-        @query = Chef::Search::Query.new
-      end
-
-      def configure_query(node_array)
-        allow(@query).to receive(:search).and_return([node_array])
-        allow(Chef::Search::Query).to receive(:new).and_return(@query)
+        allow(query_result).to receive(:search).with(any_args).and_yield(@node_foo).and_yield(@node_bar)
+        allow(Chef::Search::Query).to receive(:new).and_return(query_result)
       end
 
       def self.should_return_specified_attributes
         it "returns an array of the attributes specified on the command line OR config file, if only one is set" do
+          @node_bar["config"] = "10.0.0.2"
+          @node_foo["config"] = "10.0.0.1"
           @knife.config[:attribute] = "ipaddress"
           Chef::Config[:knife][:ssh_attribute] = "ipaddress" # this value will be in the config file
-          configure_query([@node_foo, @node_bar])
           expect(@knife).to receive(:session_from_list).with([["10.0.0.1", nil], ["10.0.0.2", nil]])
           @knife.configure_session
         end
 
         it "returns an array of the attributes specified on the command line even when a config value is set" do
+          @node_bar["config"] = "10.0.0.2"
+          @node_foo["config"] = "10.0.0.1"
           Chef::Config[:knife][:ssh_attribute] = "config_file" # this value will be in the config file
           @knife.config[:attribute] = "ipaddress" # this is the value of the command line via #configure_attribute
-          configure_query([@node_foo, @node_bar])
           expect(@knife).to receive(:session_from_list).with([["10.0.0.1", nil], ["10.0.0.2", nil]])
           @knife.configure_session
         end
       end
 
       it "searchs for and returns an array of fqdns" do
-        configure_query([@node_foo, @node_bar])
         expect(@knife).to receive(:session_from_list).with([
           ["foo.example.org", nil],
           ["bar.example.org", nil],
@@ -80,11 +79,10 @@ describe Chef::Knife::Ssh do
 
       context "when cloud hostnames are available" do
         before do
-          @node_foo.automatic_attrs[:cloud][:public_hostname] = "ec2-10-0-0-1.compute-1.amazonaws.com"
-          @node_bar.automatic_attrs[:cloud][:public_hostname] = "ec2-10-0-0-2.compute-1.amazonaws.com"
+          @node_foo["cloud"]["public_hostname"] = "ec2-10-0-0-1.compute-1.amazonaws.com"
+          @node_bar["cloud"]["public_hostname"] = "ec2-10-0-0-2.compute-1.amazonaws.com"
         end
         it "returns an array of cloud public hostnames" do
-          configure_query([@node_foo, @node_bar])
           expect(@knife).to receive(:session_from_list).with([
             ["ec2-10-0-0-1.compute-1.amazonaws.com", nil],
             ["ec2-10-0-0-2.compute-1.amazonaws.com", nil],
@@ -97,12 +95,11 @@ describe Chef::Knife::Ssh do
 
       context "when cloud hostnames are available but empty" do
         before do
-          @node_foo.automatic_attrs[:cloud][:public_hostname] = ""
-          @node_bar.automatic_attrs[:cloud][:public_hostname] = ""
+          @node_foo["cloud"]["public_hostname"] = ""
+          @node_bar["cloud"]["public_hostname"] = ""
         end
 
         it "returns an array of fqdns" do
-          configure_query([@node_foo, @node_bar])
           expect(@knife).to receive(:session_from_list).with([
             ["foo.example.org", nil],
             ["bar.example.org", nil],
@@ -114,7 +111,7 @@ describe Chef::Knife::Ssh do
       end
 
       it "should raise an error if no host are found" do
-        configure_query([ ])
+        allow(query_result).to receive(:search).with(any_args)
         expect(@knife.ui).to receive(:fatal)
         expect(@knife).to receive(:exit).with(10)
         @knife.configure_session
@@ -122,10 +119,8 @@ describe Chef::Knife::Ssh do
 
       context "when there are some hosts found but they do not have an attribute to connect with" do
         before do
-          allow(@query).to receive(:search).and_return([[@node_foo, @node_bar]])
-          @node_foo.automatic_attrs[:fqdn] = nil
-          @node_bar.automatic_attrs[:fqdn] = nil
-          allow(Chef::Search::Query).to receive(:new).and_return(@query)
+          @node_foo["fqdn"] = nil
+          @node_bar["fqdn"] = nil
         end
 
         it "should raise a specific error (CHEF-3402)" do
@@ -158,31 +153,34 @@ describe Chef::Knife::Ssh do
     before do
       Chef::Config[:knife][:ssh_attribute] = nil
       @knife.config[:attribute] = nil
-      @node_foo.automatic_attrs[:cloud][:public_hostname] = "ec2-10-0-0-1.compute-1.amazonaws.com"
-      @node_bar.automatic_attrs[:cloud][:public_hostname] = ""
+      @node_foo["cloud"]["public_hostname"] = "ec2-10-0-0-1.compute-1.amazonaws.com"
+      @node_bar["cloud"]["public_hostname"] = ""
     end
 
     it "should return fqdn by default" do
-      expect(@knife.get_ssh_attribute(Chef::Node.new)).to eq("fqdn")
+      expect(@knife.get_ssh_attribute({ "fqdn" => "fqdn" })).to eq("fqdn")
     end
 
     it "should return cloud.public_hostname attribute if available" do
-      expect(@knife.get_ssh_attribute(@node_foo)).to eq("cloud.public_hostname")
+      expect(@knife.get_ssh_attribute(@node_foo)).to eq("ec2-10-0-0-1.compute-1.amazonaws.com")
     end
 
     it "should favor to attribute_from_cli over config file and cloud" do
       @knife.config[:attribute] = "command_line"
       Chef::Config[:knife][:ssh_attribute] = "config_file"
+      @node_foo["config"] = "command_line"
+      @node_foo["knife_config"] = "config_file"
       expect( @knife.get_ssh_attribute(@node_foo)).to eq("command_line")
     end
 
     it "should favor config file over cloud and default" do
       Chef::Config[:knife][:ssh_attribute] = "config_file"
+      @node_foo["knife_config"] = "config_file"
       expect( @knife.get_ssh_attribute(@node_foo)).to eq("config_file")
     end
 
     it "should return fqdn if cloud.hostname is empty" do
-      expect( @knife.get_ssh_attribute(@node_bar)).to eq("fqdn")
+      expect( @knife.get_ssh_attribute(@node_bar)).to eq("bar.example.org")
     end
   end
 
@@ -190,7 +188,7 @@ describe Chef::Knife::Ssh do
     before :each do
       @knife.instance_variable_set(:@longest, 0)
       ssh_config = { :timeout => 50, :user => "locutus", :port => 23 }
-      allow(Net::SSH).to receive(:configuration_for).with("the.b.org").and_return(ssh_config)
+      allow(Net::SSH).to receive(:configuration_for).with("the.b.org", true).and_return(ssh_config)
     end
 
     it "uses the port from an ssh config file" do
@@ -294,7 +292,7 @@ describe Chef::Knife::Ssh do
   describe "#run" do
     before do
       @query = Chef::Search::Query.new
-      expect(@query).to receive(:search).and_return([[@node_foo]])
+      expect(@query).to receive(:search).and_yield(@node_foo)
       allow(Chef::Search::Query).to receive(:new).and_return(@query)
       allow(@knife).to receive(:ssh_command).and_return(exit_code)
       @knife.name_args = ["*:*", "false"]

data/spec/unit/mixin/versioned_api_spec.rb

@@ -0,0 +1,107 @@
+#
+# Copyright:: Copyright 2015-2017, 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/mixin/versioned_api"
+
+describe Chef::Mixin::VersionedAPI do
+  let(:dummy_class) { Class.new { extend Chef::Mixin::VersionedAPI } }
+
+  it "allows a class to declare the minimum supported API version" do
+    dummy_class.minimum_api_version 3
+    expect(dummy_class.minimum_api_version).to eq(3)
+  end
+end
+
+describe Chef::Mixin::VersionedAPIFactory do
+  class V1Class; extend Chef::Mixin::VersionedAPI; minimum_api_version 1; end
+  class V2Class; extend Chef::Mixin::VersionedAPI; minimum_api_version 2; end
+  class V3Class; extend Chef::Mixin::VersionedAPI; minimum_api_version 3; end
+
+  let(:factory_class) { Class.new { extend Chef::Mixin::VersionedAPIFactory } }
+
+  before do
+    Chef::ServerAPIVersions.instance.reset!
+  end
+
+  describe "#add_versioned_api_class" do
+    it "adds a target class" do
+      factory_class.add_versioned_api_class V1Class
+      expect(factory_class.versioned_interfaces).to eq([V1Class])
+    end
+
+    it "can be called many times" do
+      factory_class.add_versioned_api_class V1Class
+      factory_class.add_versioned_api_class V2Class
+      expect(factory_class.versioned_interfaces).to eq([V1Class, V2Class])
+    end
+  end
+
+  describe "#versioned_api_class" do
+    describe "with no known versions" do
+      it "with one class it returns that class" do
+        factory_class.add_versioned_api_class V2Class
+        expect(factory_class.versioned_api_class.minimum_api_version).to eq(2)
+      end
+
+      it "with many classes it returns the highest minimum version" do
+        factory_class.add_versioned_api_class V1Class
+        factory_class.add_versioned_api_class V2Class
+        factory_class.add_versioned_api_class V3Class
+        expect(factory_class.versioned_api_class.minimum_api_version).to eq(3)
+      end
+    end
+
+    describe "with a known version" do
+      it "with one class it returns that class" do
+        Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 0, "max_version" => 2 })
+        factory_class.add_versioned_api_class V2Class
+        expect(factory_class.versioned_api_class.minimum_api_version).to eq(2)
+      end
+
+      it "with a maximum version it returns the highest possible versioned class" do
+        Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 0, "max_version" => 2 })
+        factory_class.add_versioned_api_class V1Class
+        factory_class.add_versioned_api_class V2Class
+        factory_class.add_versioned_api_class V3Class
+        expect(factory_class.versioned_api_class.minimum_api_version).to eq(2)
+      end
+    end
+
+    it "with no classes it returns nil" do
+      expect(factory_class.versioned_api_class).to be_nil
+    end
+  end
+
+  describe "#new" do
+    it "creates an instance of the versioned class" do
+      factory_class.add_versioned_api_class V2Class
+      expect { factory_class.new }.to_not raise_error
+      expect(factory_class.new.class).to eq(V2Class)
+    end
+  end
+
+  describe "#def_versioned_delegator" do
+    it "delegates the method to the correct class" do
+      factory_class.add_versioned_api_class V2Class
+      factory_class.def_versioned_delegator("test_method")
+      expect(V2Class).to receive(:test_method).with("test message").and_return(true)
+
+      factory_class.test_method("test message")
+    end
+  end
+end

data/spec/unit/mixin/which.rb

@@ -0,0 +1,160 @@
+#
+# Copyright:: Copyright 2011-2017, 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"
+
+class TestClass
+  include Chef::Mixin::Which
+end
+
+describe Chef::Mixin::Which do
+
+  let(:test) { TestClass.new }
+
+  describe "#which" do
+    def self.test_which(description, *args, finds: nil, others: [], directory: false, &block)
+      it description do
+        # stub the ENV['PATH']
+        expect(test).to receive(:env_path).and_return(["/dir1", "/dir2" ].join(File::PATH_SEPARATOR))
+
+        # most files should not be found
+        allow(File).to receive(:executable?).and_return(false)
+        allow(File).to receive(:directory?).and_return(false)
+
+        # stub the expectation
+        expect(File).to receive(:executable?).with(finds).and_return(true) if finds
+
+        # if the file we find is a directory
+        expect(File).to receive(:directory?).with(finds).and_return(true) if finds && directory
+
+        # allow for stubbing other paths to exist that we should not find
+        others.each do |other|
+          allow(File).to receive(:executable?).with(other).and_return(true)
+        end
+
+        # setup the actual expectation on the return value
+        if finds && !directory
+          expect(test.which(*args, &block)).to eql(finds)
+        else
+          expect(test.which(*args, &block)).to eql(false)
+        end
+      end
+    end
+
+    context "simple usage" do
+      test_which("returns false when it does not find anything", "foo1")
+
+      ["/dir1", "/dir2", "/bin", "/usr/bin", "/sbin", "/usr/sbin" ].each do |dir|
+        test_which("finds `foo1` in #{dir} when it is stubbed", "foo1", finds: "#{dir}/foo1")
+      end
+
+      test_which("does not find an executable directory", "foo1", finds: "/dir1/foo1", directory: true)
+    end
+
+    context "with an array of args" do
+      test_which("finds the first arg", "foo1", "foo2", finds: "/dir2/foo1")
+
+      test_which("finds the second arg", "foo1", "foo2", finds: "/dir2/foo2")
+
+      test_which("finds the first arg when there's both", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ])
+
+      test_which("and the directory order can be reversed", "foo1", "foo2", finds: "/dir1/foo1", others: [ "/dir2/foo2" ])
+
+      test_which("or be the same", "foo1", "foo2", finds: "/dir1/foo1", others: [ "/dir1/foo2" ])
+    end
+
+    context "with a block" do
+      test_which("doesnt find it if its false", "foo1", others: [ "/dir1/foo1" ]) do |f|
+        false
+      end
+
+      test_which("finds it if its true", "foo1", finds: "/dir1/foo1") do |f|
+        true
+      end
+
+      test_which("passes in the filename as the arg", "foo1", finds: "/dir1/foo1") do |f|
+        raise "bad arg to block" unless f == "/dir1/foo1"
+        true
+      end
+
+      test_which("arrays with blocks", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ]) do |f|
+        raise "bad arg to block" unless f == "/dir2/foo1" || f == "/dir1/foo2"
+        true
+      end
+    end
+  end
+
+  describe "#where" do
+    def self.test_where(description, *args, finds: [], others: [], &block)
+      it description do
+        # stub the ENV['PATH']
+        expect(test).to receive(:env_path).and_return(["/dir1", "/dir2" ].join(File::PATH_SEPARATOR))
+
+        # most files should not be found
+        allow(File).to receive(:executable?).and_return(false)
+        allow(File).to receive(:directory?).and_return(false)
+
+        # allow for stubbing other paths to exist that we should not return
+        others.each do |other|
+          allow(File).to receive(:executable?).with(other).and_return(true)
+        end
+
+        # stub the expectation
+        finds.each do |path|
+          expect(File).to receive(:executable?).with(path).and_return(true)
+        end
+
+        # setup the actual expectation on the return value
+        expect(test.where(*args, &block)).to eql(finds)
+      end
+    end
+
+    context "simple usage" do
+      test_where("returns empty array when it doesn't find anything", "foo1")
+
+      ["/dir1", "/dir2", "/bin", "/usr/bin", "/sbin", "/usr/sbin" ].each do |dir|
+        test_where("finds `foo1` in #{dir} when it is stubbed", "foo1", finds: [ "#{dir}/foo1" ])
+      end
+
+      test_where("finds `foo1` in all directories", "foo1", finds: [ "/dir1/foo1", "/dir2/foo1" ])
+    end
+
+    context "with an array of args" do
+      test_where("finds the first arg", "foo1", "foo2", finds: [ "/dir2/foo1" ])
+
+      test_where("finds the second arg", "foo1", "foo2", finds: [ "/dir2/foo2" ])
+
+      test_where("finds foo1 before foo2", "foo1", "foo2", finds: [ "/dir2/foo1", "/dir1/foo2" ])
+
+      test_where("finds foo1 before foo2 if the dirs are reversed", "foo1", "foo2", finds: [ "/dir1/foo1", "/dir2/foo2" ])
+
+      test_where("finds them both in the same directory", "foo1", "foo2", finds: [ "/dir1/foo1", "/dir1/foo2" ])
+
+      test_where("finds foo2 first if they're reversed", "foo2", "foo1", finds: [ "/dir1/foo2", "/dir1/foo1" ])
+    end
+
+    context "with a block do" do
+      test_where("finds foo1 and foo2 if they exist and the block is true", "foo1", "foo2", finds: [ "/dir1/foo2", "/dir2/foo2" ]) do
+        true
+      end
+
+      test_where("does not finds foo1 and foo2 if they exist and the block is false", "foo1", "foo2", others: [ "/dir1/foo2", "/dir2/foo2" ]) do
+        false
+      end
+    end
+  end
+end

data/spec/unit/platform_spec.rb

@@ -21,6 +21,14 @@ require "spec_helper"
 describe Chef::Platform do
 
   context "while testing with fake data" do
+    def expect_platform_warning(method_name, times: 1, recurse: true)
+      expect(Chef).to receive(:deprecated).with(:chef_platform_methods, "Chef::Platform.#{method_name} is deprecated").exactly(times).times
+      return unless recurse
+
+      expect_platform_warning(:find_provider_for_node, times: times) if method_name == :provider_for_resource
+      expect_platform_warning(:find_provider, times: times) if method_name == :find_provider_for_node
+      expect_platform_warning(:find, times: times) if method_name == :find_provider
+    end
 
     before :all do
       @original_platform_map = Chef::Platform.platforms
@@ -31,7 +39,6 @@ describe Chef::Platform do
     end
 
     before(:each) do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       Chef::Platform.platforms = {
         :darwin => {
           ">= 10.11" => {
@@ -58,57 +65,67 @@ describe Chef::Platform do
     end
 
     it "should allow you to look up a platform by name and version, returning the provider map for it" do
+      expect_platform_warning(:find)
       pmap = Chef::Platform.find("Darwin", "9.2.2")
       expect(pmap).to be_a_kind_of(Hash)
       expect(pmap[:file]).to eql("darwinian")
     end
 
     it "should allow you to look up a platform by name and version using \"greater than\" style operators" do
+      expect_platform_warning(:find)
       pmap = Chef::Platform.find("Darwin", "11.1.0")
       expect(pmap).to be_a_kind_of(Hash)
       expect(pmap[:file]).to eql("new_darwinian")
     end
 
     it "should use the default providers for an os if the specific version does not exist" do
+      expect_platform_warning(:find)
       pmap = Chef::Platform.find("Darwin", "1")
       expect(pmap).to be_a_kind_of(Hash)
       expect(pmap[:file]).to eql("old school")
     end
 
     it "should use the default providers if the os doesn't give me a default, but does exist" do
+      expect_platform_warning(:find)
       pmap = Chef::Platform.find("mars_volta", "1")
       expect(pmap).to be_a_kind_of(Hash)
       expect(pmap[:file]).to eql(Chef::Provider::File)
     end
 
     it "should use the default provider if the os does not exist" do
+      expect_platform_warning(:find)
       pmap = Chef::Platform.find("AIX", "1")
       expect(pmap).to be_a_kind_of(Hash)
       expect(pmap[:file]).to eql(Chef::Provider::File)
     end
 
     it "should merge the defaults for an os with the specific version" do
+      expect_platform_warning(:find)
       pmap = Chef::Platform.find("Darwin", "9.2.2")
       expect(pmap[:file]).to eql("darwinian")
       expect(pmap[:snicker]).to eql("snack")
     end
 
     it "should merge the defaults for an os with the universal defaults" do
+      expect_platform_warning(:find)
       pmap = Chef::Platform.find("Darwin", "9.2.2")
       expect(pmap[:file]).to eql("darwinian")
       expect(pmap[:pax]).to eql("brittania")
     end
 
     it "should allow you to look up a provider for a platform directly by symbol" do
+      expect_platform_warning(:find_provider)
       expect(Chef::Platform.find_provider("Darwin", "9.2.2", :file)).to eql("darwinian")
     end
 
     it "should raise an exception if a provider cannot be found for a resource type" do
+      expect_platform_warning(:find_provider)
       expect { Chef::Platform.find_provider("Darwin", "9.2.2", :coffee) }.to raise_error(Chef::Exceptions::ProviderNotFound)
     end
 
     it "should look up a provider for a resource with a Chef::Resource object" do
       kitty = Chef::Resource::Cat.new("loulou")
+      expect_platform_warning(:find_provider)
       expect(Chef::Platform.find_provider("Darwin", "9.2.2", kitty)).to eql("nice")
     end
 
@@ -118,10 +135,12 @@ describe Chef::Platform do
       node.name("Intel")
       node.automatic_attrs[:platform] = "mac_os_x"
       node.automatic_attrs[:platform_version] = "9.2.2"
+      expect_platform_warning(:find_provider_for_node)
       expect(Chef::Platform.find_provider_for_node(node, kitty)).to eql("nice")
     end
 
     it "should not throw an exception when the platform version has an unknown format" do
+      expect_platform_warning(:find_provider)
       expect(Chef::Platform.find_provider(:darwin, "bad-version", :file)).to eql("old school")
     end
 
@@ -132,6 +151,8 @@ describe Chef::Platform do
       node.name("Intel")
       node.automatic_attrs[:platform] = "mac_os_x"
       node.automatic_attrs[:platform_version] = "9.2.2"
+      expect_platform_warning(:find_provider_for_node, recurse: false)
+      expect_platform_warning(:find_provider, recurse: false)
       expect(Chef::Platform.find_provider_for_node(node, kitty)).to eql(Chef::Provider::File)
     end
 
@@ -143,6 +164,7 @@ describe Chef::Platform do
       node.name("Intel")
       node.automatic_attrs[:platform] = "mac_os_x"
       node.automatic_attrs[:platform_version] = "8.5"
+      expect_platform_warning(:find_provider_for_node)
       expect(Chef::Platform.find_provider_for_node(node, kitty)).to eql(Chef::Provider::Cat)
     end
 
@@ -156,6 +178,7 @@ describe Chef::Platform do
 
     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
+      expect_platform_warning(:provider_for_resource)
       provider = Chef::Platform.provider_for_resource(file, :foo)
       expect(provider).to be_an_instance_of(Chef::Provider::File)
       expect(provider.new_resource).to equal(file)
@@ -164,6 +187,7 @@ describe Chef::Platform do
 
     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
+      expect_platform_warning(:provider_for_resource)
       provider = Chef::Platform.provider_for_resource(file)
       expect(provider).to be_an_instance_of(Chef::Provider::File)
       expect(provider.new_resource).to equal(file)
@@ -172,6 +196,7 @@ describe Chef::Platform do
 
     it "raises an error when trying to find the provider for a resource with no run context" do
       file = Chef::Resource::File.new("whateva")
+      expect_platform_warning(:provider_for_resource, recurse: false)
       expect { Chef::Platform.provider_for_resource(file) }.to raise_error(ArgumentError)
     end
 
@@ -180,6 +205,7 @@ describe Chef::Platform do
     end
 
     it "should update the provider map with map" do
+      expect_platform_warning(:set, times: 7)
       Chef::Platform.set(
            :platform => :darwin,
            :version => "9.2.2",
@@ -228,6 +254,7 @@ describe Chef::Platform do
     end
 
     it "does not overwrite the platform map when using :default platform" do
+      expect_platform_warning(:set)
       Chef::Platform.set(
         :resource => :file,
         :platform => :default,