chef 12.22.5 → 13.0.113

data/spec/unit/resource_collection_spec.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Christopher Walters (<cw@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -219,6 +219,7 @@ describe Chef::ResourceCollection do
     end
 
     it "should find resources by strings of zen_master[a,b]" do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
       load_up_resources
       results = rc.resources("zen_master[monkey,dog]")
       expect(results.length).to eql(2)
@@ -291,10 +292,10 @@ describe Chef::ResourceCollection do
       expect(rc.respond_to?(:from_json)).to eq(false)
     end
 
-    it "should convert from json using the CHEF::JSONCompat library" do
+    it "should convert from json using the Chef::JSONCompat library" do
       rc << resource
       json = Chef::JSONCompat.to_json(rc)
-      s_rc = Chef::JSONCompat.from_json(json)
+      s_rc = Chef::ResourceCollection.from_json(json)
       expect(s_rc).to be_a_kind_of(Chef::ResourceCollection)
       expect(s_rc[0].name).to eql(resource.name)
     end

data/spec/unit/resource_reporter_spec.rb

@@ -3,7 +3,7 @@
 # Author:: Prajakta Purohit (<prajakta@chef.io>)
 # Author:: Tyler Cloke (<tyler@chef.io>)
 #
-# Copyright:: Copyright 2012-2016, Chef Software Inc.
+# Copyright:: Copyright 2012-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -399,11 +399,11 @@ describe Chef::ResourceReporter do
       end
 
       it "includes an updated resource's initial state" do
-        expect(@first_update_report["before"]).to eq(current_resource.state)
+        expect(@first_update_report["before"]).to eq(current_resource.state_for_resource_reporter)
       end
 
       it "includes an updated resource's final state" do
-        expect(@first_update_report["after"]).to eq(new_resource.state)
+        expect(@first_update_report["after"]).to eq(new_resource.state_for_resource_reporter)
       end
 
       it "includes the resource's name" do
@@ -540,11 +540,11 @@ describe Chef::ResourceReporter do
       end
 
       it "includes an updated resource's initial state" do
-        expect(@first_update_report["before"]).to eq(@current_resource.state)
+        expect(@first_update_report["before"]).to eq(@current_resource.state_for_resource_reporter)
       end
 
       it "includes an updated resource's final state" do
-        expect(@first_update_report["after"]).to eq(@new_resource.state)
+        expect(@first_update_report["after"]).to eq(@new_resource.state_for_resource_reporter)
       end
 
       it "includes the resource's name" do

data/spec/unit/resource_spec.rb

@@ -3,7 +3,7 @@
 # Author:: Christopher Walters (<cw@chef.io>)
 # Author:: Tim Hinderliter (<tim@chef.io>)
 # Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -160,7 +160,7 @@ describe Chef::Resource do
     end
 
     it "describes its state" do
-      resource_state = file_resource.state
+      resource_state = file_resource.state_for_resource_reporter
       expect(resource_state.keys).to match_array([:checksum, :owner, :group, :mode])
       expect(resource_state[:checksum]).to eq("abc123")
       expect(resource_state[:owner]).to eq("root")
@@ -192,7 +192,6 @@ describe Chef::Resource do
   describe "load_from" do
     let(:prior_resource) do
       prior_resource = Chef::Resource.new("funk")
-      prior_resource.supports(:funky => true)
       prior_resource.source_line
       prior_resource.allowed_actions << :funkytown
       prior_resource.action(:funkytown)
@@ -205,7 +204,6 @@ describe Chef::Resource do
 
     it "should load the attributes of a prior resource" do
       resource.load_from(prior_resource)
-      expect(resource.supports).to eq({ :funky => true })
     end
 
     it "should not inherit the action from the prior resource" do
@@ -233,14 +231,6 @@ describe Chef::Resource do
     end
   end
 
-  describe "noop" do
-    it "should accept true or false for noop" do
-      expect { resource.noop true }.not_to raise_error
-      expect { resource.noop false }.not_to raise_error
-      expect { resource.noop "eat it" }.to raise_error(ArgumentError)
-    end
-  end
-
   describe "notifies" do
     it "should make notified resources appear in the actions hash" do
       run_context.resource_collection << Chef::Resource::ZenMaster.new("coffee")
@@ -294,6 +284,23 @@ describe Chef::Resource do
       resource.notifies :reload, run_context.resource_collection.find(:zen_master => "coffee, tea")
       expect(resource.delayed_notifications.detect { |e| e.resource.name == "coffee, tea" && e.action == :reload }).not_to be_nil
     end
+
+    it "notifies a resource without a name via a string name with brackets" do
+      run_context.resource_collection << Chef::Resource::ZenMaster.new("")
+      resource.notifies :reload, "zen_master[]"
+    end
+
+    it "notifies a resource without a name via a string name without brackets" do
+      run_context.resource_collection << Chef::Resource::ZenMaster.new("")
+      resource.notifies :reload, "zen_master"
+      expect(resource.delayed_notifications.first.resource).to eql("zen_master")
+    end
+
+    it "notifies a resource without a name via a hash name with an empty string" do
+      run_context.resource_collection << Chef::Resource::ZenMaster.new("")
+      resource.notifies :reload, zen_master: ""
+      expect(resource.delayed_notifications.first.resource).to eql(zen_master: "")
+    end
   end
 
   describe "subscribes" do
@@ -452,18 +459,6 @@ describe Chef::Resource do
     end
   end
 
-  describe "is" do
-    it "should return the arguments passed with 'is'" do
-      zm = Chef::Resource::ZenMaster.new("coffee")
-      expect(zm.is("one", "two", "three")).to eq(%w{one two three})
-    end
-
-    it "should allow arguments preceded by is to methods" do
-      resource.noop(resource.is(true))
-      expect(resource.noop).to eql(true)
-    end
-  end
-
   describe "to_json" do
     it "should serialize to json" do
       json = resource.to_json
@@ -481,10 +476,10 @@ describe Chef::Resource do
       let(:resource_class) { Class.new(Chef::Resource) { property :a, default: 1 } }
       it "should include the default in the hash" do
         expect(resource.to_hash.keys.sort).to eq([:a, :allowed_actions, :params, :provider, :updated,
-          :updated_by_last_action, :before, :supports,
-          :noop, :ignore_failure, :name, :source_line,
-          :action, :retries, :retry_delay, :elapsed_time,
-          :default_guard_interpreter, :guard_interpreter, :sensitive].sort)
+          :updated_by_last_action, :before,
+          :name, :source_line,
+          :action, :elapsed_time,
+          :default_guard_interpreter, :guard_interpreter].sort)
         expect(resource.to_hash[:name]).to eq "funk"
         expect(resource.to_hash[:a]).to eq 1
       end
@@ -493,10 +488,10 @@ describe Chef::Resource do
     it "should convert to a hash" do
       hash = resource.to_hash
       expected_keys = [ :allowed_actions, :params, :provider, :updated,
-        :updated_by_last_action, :before, :supports,
-        :noop, :ignore_failure, :name, :source_line,
-        :action, :retries, :retry_delay, :elapsed_time,
-        :default_guard_interpreter, :guard_interpreter, :sensitive ]
+        :updated_by_last_action, :before,
+        :name, :source_line,
+        :action, :elapsed_time,
+        :default_guard_interpreter, :guard_interpreter ]
       expect(hash.keys - expected_keys).to eq([])
       expect(expected_keys - hash.keys).to eq([])
       expect(hash[:name]).to eql("funk")
@@ -506,24 +501,12 @@ describe Chef::Resource do
   describe "self.json_create" do
     it "should deserialize itself from json" do
       json = Chef::JSONCompat.to_json(resource)
-      serialized_node = Chef::JSONCompat.from_json(json)
+      serialized_node = Chef::Resource.from_json(json)
       expect(serialized_node).to be_a_kind_of(Chef::Resource)
       expect(serialized_node.name).to eql(resource.name)
     end
   end
 
-  describe "supports" do
-    it "should allow you to set what features this resource supports" do
-      support_hash = { :one => :two }
-      resource.supports(support_hash)
-      expect(resource.supports).to eql(support_hash)
-    end
-
-    it "should return the current value of supports" do
-      expect(resource.supports).to eq({})
-    end
-  end
-
   describe "ignore_failure" do
     it "should default to throwing an error if a provider fails for a resource" do
       expect(resource.ignore_failure).to eq(false)
@@ -583,31 +566,18 @@ describe Chef::Resource do
       expect { retriable_resource.run_action(:purr) }.to raise_error(RuntimeError)
       expect(retriable_resource.retries).to eq(3)
     end
-  end
-
-  describe "setting the base provider class for the resource" do
 
-    it "defaults to Chef::Provider for the base class" do
-      expect(Chef::Resource.provider_base).to eq(Chef::Provider)
-    end
-
-    it "allows the base provider to be overridden" do
-      Chef::Config.treat_deprecation_warnings_as_errors(false)
-      class OverrideProviderBaseTest < Chef::Resource
-        provider_base Chef::Provider::Package
-      end
+    it "should not rescue from non-StandardError exceptions" do
+      retriable_resource.retries(3)
+      retriable_resource.retry_delay(0) # No need to wait.
 
-      expect(OverrideProviderBaseTest.provider_base).to eq(Chef::Provider::Package)
-    end
+      provider = Chef::Provider::SnakeOil.new(retriable_resource, run_context)
+      allow(Chef::Provider::SnakeOil).to receive(:new).and_return(provider)
+      allow(provider).to receive(:action_purr).and_raise(LoadError)
 
-    it "warns when setting provider_base" do
-      expect do
-        class OverrideProviderBaseTest2 < Chef::Resource
-          provider_base Chef::Provider::Package
-        end
-      end.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
+      expect(retriable_resource).not_to receive(:sleep)
+      expect { retriable_resource.run_action(:purr) }.to raise_error(LoadError)
     end
-
   end
 
   it "runs an action by finding its provider, loading the current resource and then running the action" do
@@ -857,11 +827,7 @@ describe Chef::Resource do
       snitch_var1 = snitch_var2 = 0
       runner = Chef::Runner.new(run_context)
 
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      Chef::Platform.set(
-        :resource => :cat,
-        :provider => Chef::Provider::SnakeOil
-      )
+      Chef::Provider::SnakeOil.provides :cat
 
       resource1.only_if { snitch_var1 = 1 }
       resource1.not_if { snitch_var2 = 2 }

data/spec/unit/run_context/cookbook_compiler_spec.rb

@@ -163,9 +163,7 @@ describe Chef::RunContext::CookbookCompiler do
     describe "event dispatch" do
       let(:recipe) { "dependency1::default" }
       let(:recipe_path) do
-        File.expand_path("../../../data/run_context/cookbooks/dependency1/recipes/default.rb", __FILE__).tap do |path|
-          path.gsub!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
-        end
+        File.expand_path("../../../data/run_context/cookbooks/dependency1/recipes/default.rb", __FILE__)
       end
       before do
         node.run_list(recipe)

data/spec/unit/run_list/versioned_recipe_list_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Stephen Delano (<stephen@chef.io>)
-# Copyright:: Copyright 2010-2016, Chef Software Inc.
+# Copyright:: Copyright 2010-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -186,9 +186,12 @@ describe Chef::RunList::VersionedRecipeList do
     end
   end
 
-  context "with duplicated names", chef: ">= 13" do
-    it "should fail in Chef 13" do
-      expect(list).to_not respond_to(:with_duplicate_names)
+  context "with duplicate names" do
+    let(:fq_names) { list.with_duplicate_names }
+    let(:recipes) { %w{ foo bar::default } }
+
+    it "expands default recipes" do
+      expect(fq_names).to eq(%w{foo foo::default bar bar::default})
     end
   end
 end

data/spec/unit/runner_spec.rb

@@ -1,6 +1,6 @@
 
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -98,25 +98,6 @@ describe Chef::Runner do
     run_context.resource_collection << first_resource
   end
 
-  context "when we fall through to old Chef::Platform resolution" do
-    let(:provider_resolver) { Chef::ProviderResolver.new(node, first_resource, nil) }
-    before do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = false
-      # set up old Chef::Platform resolution instead of provider_resolver
-      Chef::Platform.set(
-        :resource => :cat,
-        :provider => Chef::Provider::SnakeOil
-      )
-      allow(Chef::ProviderResolver).to receive(:new).and_return(provider_resolver)
-      allow(provider_resolver).to receive(:maybe_dynamic_provider_resolution).with(first_resource, anything()).and_return(nil)
-    end
-
-    it "should use the platform provider if it has one" do
-      expect(Chef::Platform).to receive(:find_provider_for_node).with(node, first_resource).and_call_original
-      runner.converge
-    end
-  end
-
   context "when we are doing dynamic provider resolution" do
 
     it "should pass each resource in the collection to a provider" do
@@ -141,25 +122,26 @@ describe Chef::Runner do
 
     it "should raise exceptions as thrown by a provider" do
       provider = Chef::Provider::SnakeOil.new(run_context.resource_collection[0], run_context)
-      allow(Chef::Provider::SnakeOil).to receive(:new).once.and_return(provider)
-      allow(provider).to receive(:action_sell).once.and_raise(ArgumentError)
+      expect(Chef::Provider::SnakeOil).to receive(:new).once.and_return(provider)
+      expect(provider).to receive(:action_sell).once.and_raise(ArgumentError)
       expect { runner.converge }.to raise_error(ArgumentError)
     end
 
     it "should not raise exceptions thrown by providers if the resource has ignore_failure set to true" do
       allow(run_context.resource_collection[0]).to receive(:ignore_failure).and_return(true)
       provider = Chef::Provider::SnakeOil.new(run_context.resource_collection[0], run_context)
-      allow(Chef::Provider::SnakeOil).to receive(:new).once.and_return(provider)
-      allow(provider).to receive(:action_sell).once.and_raise(ArgumentError)
+      expect(Chef::Provider::SnakeOil).to receive(:new).once.and_return(provider)
+      expect(provider).to receive(:action_sell).once.and_raise(ArgumentError)
       expect { runner.converge }.not_to raise_error
     end
 
     it "should retry with the specified delay if retries are specified" do
-      first_resource.retries 3
+      num_retries = 3
+      allow(run_context.resource_collection[0]).to receive(:retries).and_return(num_retries)
       provider = Chef::Provider::SnakeOil.new(run_context.resource_collection[0], run_context)
-      allow(Chef::Provider::SnakeOil).to receive(:new).once.and_return(provider)
-      allow(provider).to receive(:action_sell).and_raise(ArgumentError)
-      expect(first_resource).to receive(:sleep).with(2).exactly(3).times
+      expect(Chef::Provider::SnakeOil).to receive(:new).exactly(num_retries + 1).times.and_return(provider)
+      expect(provider).to receive(:action_sell).exactly(num_retries + 1).times.and_raise(ArgumentError)
+      expect(run_context.resource_collection[0]).to receive(:sleep).with(2).exactly(num_retries).times
       expect { runner.converge }.to raise_error(ArgumentError)
     end
 

data/spec/unit/search/query_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2009-2016, Chef Software Inc.
+# Copyright:: Copyright 2009-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,7 +24,7 @@ describe Chef::Search::Query do
   let(:query) { Chef::Search::Query.new }
 
   shared_context "filtered search" do
-    let(:query_string) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0" }
+    let(:query_string) { "search/node?q=platform:rhel&start=0" }
     let(:server_url) { "https://api.opscode.com/organizations/opscode/nodes" }
     let(:args) { { filter_key => filter_hash } }
     let(:filter_hash) do
@@ -81,10 +81,10 @@ describe Chef::Search::Query do
   end
 
   describe "search" do
-    let(:query_string) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0" }
-    let(:query_string_continue) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=4" }
-    let(:query_string_with_rows) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=4" }
-    let(:query_string_continue_with_rows) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=4&rows=4" }
+    let(:query_string) { "search/node?q=platform:rhel&start=0" }
+    let(:query_string_continue) { "search/node?q=platform:rhel&start=4" }
+    let(:query_string_with_rows) { "search/node?q=platform:rhel&start=0&rows=4" }
+    let(:query_string_continue_with_rows) { "search/node?q=platform:rhel&start=4&rows=4" }
 
     let(:response) do
       {
@@ -178,27 +178,22 @@ describe Chef::Search::Query do
     end
 
     it "queries for every object of a type by default" do
-      expect(rest).to receive(:get).with("search/node?q=*:*&sort=X_CHEF_id_CHEF_X%20asc&start=0").and_return(response)
+      expect(rest).to receive(:get).with("search/node?q=*:*&start=0").and_return(response)
       query.search(:node)
     end
 
     it "allows a custom query" do
-      expect(rest).to receive(:get).with("search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0").and_return(response)
+      expect(rest).to receive(:get).with("search/node?q=platform:rhel&start=0").and_return(response)
       query.search(:node, "platform:rhel")
     end
 
-    it "lets you set a sort order" do
-      expect(rest).to receive(:get).with("search/node?q=platform:rhel&sort=id%20desc&start=0").and_return(response)
-      query.search(:node, "platform:rhel", sort: "id desc")
-    end
-
     it "lets you set a starting object" do
-      expect(rest).to receive(:get).with("search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=2").and_return(response)
+      expect(rest).to receive(:get).with("search/node?q=platform:rhel&start=2").and_return(response)
       query.search(:node, "platform:rhel", start: 2)
     end
 
     it "lets you set how many rows to return" do
-      expect(rest).to receive(:get).with("search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=40").and_return(response)
+      expect(rest).to receive(:get).with("search/node?q=platform:rhel&start=0&rows=40").and_return(response)
       query.search(:node, "platform:rhel", rows: 40)
     end
 
@@ -223,7 +218,7 @@ describe Chef::Search::Query do
     it "pages through the responses" do
       @call_me = double("blocky")
       response["rows"].each { |r| expect(@call_me).to receive(:do).with(Chef::Node.from_hash(r)) }
-      query.search(:node, "*:*", sort: nil, start: 0, rows: 4) { |r| @call_me.do(r) }
+      query.search(:node, "*:*", start: 0, rows: 4) { |r| @call_me.do(r) }
     end
 
     it "sends multiple API requests when the server indicates there is more data" do
@@ -242,6 +237,27 @@ describe Chef::Search::Query do
       end
     end
 
+    it "fuzzifies node searches when fuzz is set" do
+      expect(rest).to receive(:get).with(
+        "search/node?q=tags:*free.messi*%20OR%20roles:*free.messi*%20OR%20fqdn:*free.messi*%20OR%20addresses:*free.messi*%20OR%20policy_name:*free.messi*%20OR%20policy_group:*free.messi*&start=0"
+      ).and_return(response)
+      query.search(:node, "free.messi", fuzz: true)
+    end
+
+    it "does not fuzzify node searches when fuzz is not set" do
+      expect(rest).to receive(:get).with(
+        "search/node?q=free.messi&start=0"
+      ).and_return(response)
+      query.search(:node, "free.messi")
+    end
+
+    it "does not fuzzify client searches" do
+      expect(rest).to receive(:get).with(
+        "search/client?q=messi&start=0"
+      ).and_return(response)
+      query.search(:client, "messi", fuzz: true)
+    end
+
     context "when :filter_result is provided as a result" do
       include_context "filtered search" do
         let(:filter_key) { :filter_result }
@@ -269,22 +285,4 @@ describe Chef::Search::Query do
     end
   end
 
-  describe "#partial_search" do
-    include_context "filtered search" do
-      let(:filter_key) { :keys }
-
-      it "emits a deprecation warning" do
-        # partial_search calls search, so we'll stub search to return empty
-        allow(query).to receive(:search).and_return( [ [], 0, 0 ] )
-        expect(Chef::Log).to receive(:warn).with(/DEPRECATED: The 'partial_search' API is deprecated/)
-        query.partial_search(:node, "platform:rhel", args)
-      end
-
-      it "returns an array of filtered hashes" do
-        expect(rest).to receive(:post).with(query_string, args[filter_key]).and_return(response)
-        results = query.partial_search(:node, "platform:rhel", args)
-        expect(results[0]).to match_array(response_rows)
-      end
-    end
-  end
 end