chef 14.2.0-universal-mingw32 → 14.3.37-universal-mingw32

data/spec/unit/audit/audit_reporter_spec.rb

@@ -24,13 +24,13 @@ describe Chef::Audit::AuditReporter do
 
   let(:rest) { double("rest") }
   let(:reporter) { described_class.new(rest) }
-  let(:node) { double("node", :name => "sofreshsoclean") }
+  let(:node) { double("node", name: "sofreshsoclean") }
   let(:run_id) { 0 }
   let(:start_time) { Time.new(2014, 12, 3, 9, 31, 05, "-08:00") }
   let(:end_time) { Time.new(2014, 12, 3, 9, 36, 14, "-08:00") }
   let(:run_status) do
-    instance_double(Chef::RunStatus, :node => node, :run_id => run_id,
-                                     :start_time => start_time, :end_time => end_time) end
+    instance_double(Chef::RunStatus, node: node, run_id: run_id,
+                                     start_time: start_time, end_time: end_time) end
 
   describe "#audit_phase_start" do
 
@@ -79,17 +79,17 @@ describe Chef::Audit::AuditReporter do
           "X-Ops-Audit-Report-Protocol-Version" => Chef::Audit::AuditReporter::PROTOCOL_VERSION,
         }
 
-        expect(rest).to receive(:post).
-          with("controls", run_data, headers)
+        expect(rest).to receive(:post)
+          .with("controls", run_data, headers)
         reporter.run_completed(node)
       end
 
       context "when audit phase failed" do
 
         let(:audit_error) do
-          double("AuditError", :class => "Chef::Exceptions::AuditError",
-                               :message => "Audit phase failed with error message: derpderpderp",
-                               :backtrace => ["/path/recipe.rb:57", "/path/library.rb:106"]) end
+          double("AuditError", class: "Chef::Exceptions::AuditError",
+                               message: "Audit phase failed with error message: derpderpderp",
+                               backtrace: ["/path/recipe.rb:57", "/path/library.rb:106"]) end
 
         before do
           reporter.instance_variable_set(:@audit_phase_error, audit_error)
@@ -99,10 +99,10 @@ describe Chef::Audit::AuditReporter do
           reporter.run_completed(node)
           expect(run_data).to have_key(:error)
           expect(run_data).to have_key(:error)
-          expect(run_data[:error]).to eq <<-EOM.strip!
-Chef::Exceptions::AuditError: Audit phase failed with error message: derpderpderp
-/path/recipe.rb:57
-/path/library.rb:106
+          expect(run_data[:error]).to eq <<~EOM.strip!
+            Chef::Exceptions::AuditError: Audit phase failed with error message: derpderpderp
+            /path/recipe.rb:57
+            /path/library.rb:106
 EOM
         end
 
@@ -123,7 +123,7 @@ EOM
 
         context "the error is an http error" do
 
-          let(:response) { double("response", :code => code) }
+          let(:response) { double("response", code: code) }
 
           before do
             expect(Chef::Log).to receive(:trace).with(/Sending audit report/)
@@ -145,12 +145,12 @@ EOM
           shared_examples "non-404 error code" do
 
             it "saves the error report" do
-              expect(Chef::FileCache).to receive(:store).
-                with("failed-audit-data.json", an_instance_of(String), 0640).
-                and_return(true)
-              expect(Chef::FileCache).to receive(:load).
-                with("failed-audit-data.json", false).
-                and_return(true)
+              expect(Chef::FileCache).to receive(:store)
+                .with("failed-audit-data.json", an_instance_of(String), 0640)
+                .and_return(true)
+              expect(Chef::FileCache).to receive(:load)
+                .with("failed-audit-data.json", false)
+                .and_return(true)
               expect(Chef::Log).to receive(:error).with(/Failed to post audit report to server/)
               reporter.run_completed(node)
             end
@@ -184,9 +184,9 @@ EOM
         context "when reporting url fatals are enabled" do
 
           before do
-            allow(Chef::Config).to receive(:[]).
-              with(:enable_reporting_url_fatals).
-              and_return(true)
+            allow(Chef::Config).to receive(:[])
+              .with(:enable_reporting_url_fatals)
+              .and_return(true)
           end
 
           it "raises the error" do
@@ -236,14 +236,14 @@ EOM
     let(:run_data) { audit_data.to_hash }
 
     let(:audit_error) do
-      double("AuditError", :class => "Chef::Exceptions::AuditError",
-                           :message => "Audit phase failed with error message: derpderpderp",
-                           :backtrace => ["/path/recipe.rb:57", "/path/library.rb:106"]) end
+      double("AuditError", class: "Chef::Exceptions::AuditError",
+                           message: "Audit phase failed with error message: derpderpderp",
+                           backtrace: ["/path/recipe.rb:57", "/path/library.rb:106"]) end
 
     let(:run_error) do
-      double("RunError", :class => "Chef::Exceptions::RunError",
-                         :message => "This error shouldn't be reported.",
-                         :backtrace => ["fix it", "fix it", "fix it"]) end
+      double("RunError", class: "Chef::Exceptions::RunError",
+                         message: "This error shouldn't be reported.",
+                         backtrace: ["fix it", "fix it", "fix it"]) end
 
     before do
       allow(reporter).to receive(:auditing_enabled?).and_return(true)
@@ -269,10 +269,10 @@ EOM
         expect(rest).to receive(:post)
         reporter.run_failed(run_error)
         expect(run_data).to have_key(:error)
-        expect(run_data[:error]).to eq <<-EOM.strip!
-Chef::Exceptions::AuditError: Audit phase failed with error message: derpderpderp
-/path/recipe.rb:57
-/path/library.rb:106
+        expect(run_data[:error]).to eq <<~EOM.strip!
+          Chef::Exceptions::AuditError: Audit phase failed with error message: derpderpderp
+          /path/recipe.rb:57
+          /path/library.rb:106
 EOM
       end
     end
@@ -282,10 +282,10 @@ EOM
 
     let(:control_group_foo) do
       instance_double(Chef::Audit::ControlGroupData,
-      :metadata => double("foo metadata")) end
+      metadata: double("foo metadata")) end
     let(:control_group_bar) do
       instance_double(Chef::Audit::ControlGroupData,
-      :metadata => double("bar metadata")) end
+      metadata: double("bar metadata")) end
 
     let(:ordered_control_groups) do
       {
@@ -296,11 +296,11 @@ EOM
 
     let(:audit_data) do
       instance_double(Chef::Audit::AuditData,
-      :add_control_group => true) end
+      add_control_group: true) end
 
     let(:run_context) do
       instance_double(Chef::RunContext,
-      :audits => ordered_control_groups) end
+      audits: ordered_control_groups) end
 
     before do
       allow(reporter).to receive(:ordered_control_groups).and_return(ordered_control_groups)
@@ -350,31 +350,27 @@ EOM
     let(:name) { "bat" }
     let(:control_group) do
       instance_double(Chef::Audit::ControlGroupData,
-      :metadata => double("metadata")) end
+      metadata: double("metadata")) end
 
     before do
-      allow(Chef::Audit::ControlGroupData).to receive(:new).
-        with(name, control_group.metadata).
-        and_return(control_group)
+      allow(Chef::Audit::ControlGroupData).to receive(:new)
+        .with(name, control_group.metadata)
+        .and_return(control_group)
     end
 
     it "stores the control group" do
-      expect(ordered_control_groups).to receive(:has_key?).with(name).and_return(false)
+      expect(ordered_control_groups).to receive(:key?).with(name).and_return(false)
       allow(run_context.audits).to receive(:[]).with(name).and_return(control_group)
-      expect(ordered_control_groups).to receive(:store).
-        with(name, control_group).
-        and_call_original
+      expect(ordered_control_groups).to receive(:store)
+        .with(name, control_group)
+        .and_call_original
       reporter.control_group_started(name)
-      # stubbed :has_key? above, which is used by the have_key matcher,
-      # so instead we check the response to Hash's #key? because luckily
-      # #key? does not call #has_key?
-      expect(ordered_control_groups.key?(name)).to be true
       expect(ordered_control_groups[name]).to eq control_group
     end
 
     context "when a control group with the same name has been seen" do
       it "raises an exception" do
-        expect(ordered_control_groups).to receive(:has_key?).with(name).and_return(true)
+        expect(ordered_control_groups).to receive(:key?).with(name).and_return(true)
         expect { reporter.control_group_started(name) }.to raise_error(Chef::Exceptions::AuditControlGroupDuplicate)
       end
     end
@@ -397,11 +393,11 @@ EOM
 
     let(:name) { "bar" }
     let(:example_data) { double("example data") }
-    let(:error) { double("Exception", :message => "oopsie") }
+    let(:error) { double("Exception", message: "oopsie") }
 
     it "notifies the control group the example failed" do
-      expect(control_group_bar).to receive(:example_failure).
-        with(example_data, error.message)
+      expect(control_group_bar).to receive(:example_failure)
+        .with(example_data, error.message)
       reporter.control_example_failure(name, example_data, error)
     end
   end
@@ -410,9 +406,9 @@ EOM
     shared_examples "enabled?" do |true_or_false|
 
       it "returns #{true_or_false}" do
-        expect(Chef::Config).to receive(:[]).
-          with(:audit_mode).
-          and_return(audit_setting)
+        expect(Chef::Config).to receive(:[])
+          .with(:audit_mode)
+          .and_return(audit_setting)
         expect(reporter.auditing_enabled?).to be true_or_false
       end
     end

data/spec/unit/audit/control_group_data_spec.rb

@@ -72,8 +72,8 @@ describe Chef::Audit::AuditData do
 
     describe ":control_groups" do
 
-      let(:control_hash_1) { { :name => "control group 1" } }
-      let(:control_hash_2) { { :name => "control group 2" } }
+      let(:control_hash_1) { { name: "control group 1" } }
+      let(:control_hash_2) { { name: "control group 2" } }
 
       let(:control_groups) { audit_data_hash[:control_groups] }
 
@@ -174,11 +174,11 @@ describe Chef::Audit::ControlGroupData do
 
     let(:control_data) do
       {
-        :name => name,
-        :resource_type => resource_type,
-        :resource_name => resource_name,
-        :context => context,
-        :line_number => line_number,
+        name: name,
+        resource_type: resource_type,
+        resource_name: resource_name,
+        context: context,
+        line_number: line_number,
       }
     end
 
@@ -193,11 +193,11 @@ describe Chef::Audit::ControlGroupData do
                                    context: context, line_number: line_number) end
 
     before do
-      allow(Chef::Audit::ControlData).to receive(:new).
-        with(name: name, resource_type: resource_type,
+      allow(Chef::Audit::ControlData).to receive(:new)
+        .with(name: name, resource_type: resource_type,
              resource_name: resource_name, context: context,
-             line_number: line_number).
-        and_return(control)
+             line_number: line_number)
+        .and_return(control)
     end
   end
 
@@ -434,22 +434,22 @@ describe Chef::Audit::ControlGroupData do
 
       context "with multiple controls added" do
 
-        let(:control_hash_1) { { :line_number => 27 } }
-        let(:control_hash_2) { { :line_number => 13 } }
-        let(:control_hash_3) { { :line_number => 35 } }
+        let(:control_hash_1) { { line_number: 27 } }
+        let(:control_hash_2) { { line_number: 13 } }
+        let(:control_hash_3) { { line_number: 35 } }
 
         let(:control_1) do
           double("control 1",
-          :line_number => control_hash_1[:line_number],
-          :to_hash => control_hash_1) end
+          line_number: control_hash_1[:line_number],
+          to_hash: control_hash_1) end
         let(:control_2) do
           double("control 2",
-          :line_number => control_hash_2[:line_number],
-          :to_hash => control_hash_2) end
+          line_number: control_hash_2[:line_number],
+          to_hash: control_hash_2) end
         let(:control_3) do
           double("control 3",
-          :line_number => control_hash_3[:line_number],
-          :to_hash => control_hash_3) end
+          line_number: control_hash_3[:line_number],
+          to_hash: control_hash_3) end
 
         let(:control_list) { [control_1, control_2, control_3] }
         let(:ordered_control_hashes) { [control_hash_2, control_hash_1, control_hash_3] }

data/spec/unit/audit/runner_spec.rb

@@ -28,7 +28,7 @@ describe Chef::Audit::Runner do
   include RSpec::Support::InSubProcess
 
   let(:events) { double("events") }
-  let(:run_context) { instance_double(Chef::RunContext, :events => events) }
+  let(:run_context) { instance_double(Chef::RunContext, events: events) }
   let(:runner) { Chef::Audit::Runner.new(run_context) }
 
   around(:each) do |ex|
@@ -89,7 +89,7 @@ describe Chef::Audit::Runner do
 
     describe "#register_control_groups" do
       let(:audits) { [] }
-      let(:run_context) { instance_double(Chef::RunContext, :audits => audits) }
+      let(:run_context) { instance_double(Chef::RunContext, audits: audits) }
 
       it "adds the control group aliases" do
         runner.send(:register_control_groups)

data/spec/unit/chef_class_spec.rb

@@ -107,4 +107,124 @@ describe "Chef class" do
       end.to raise_error(Chef::Exceptions::InvalidEventType)
     end
   end
+
+  describe "Deprecation system" do
+    context "with treat_deprecation_warnings_as_errors false" do
+      before { Chef::Config[:treat_deprecation_warnings_as_errors] = false }
+
+      it "displays a simple deprecation warning" do
+        expect(Chef::Log).to receive(:warn).with(%r{spec/unit/chef_class_spec\.rb.*?I'm a little teapot.*?Please see}m)
+        Chef.deprecated(:generic, "I'm a little teapot.")
+      end
+
+      it "allows silencing all warnings" do
+        Chef::Config[:silence_deprecation_warnings] = true
+        expect(Chef::Log).to_not receive(:warn)
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:internal_api, "Short and stout.")
+        Chef.deprecated(:generic, "This is my handle.")
+      end
+
+      it "allows silencing specific types" do
+        Chef::Config[:silence_deprecation_warnings] = [:internal_api]
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:internal_api, "Short and stout.")
+        Chef.deprecated(:generic, "This is my handle.")
+      end
+
+      it "allows silencing specific IDs" do
+        Chef::Config[:silence_deprecation_warnings] = [0]
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:internal_api, "Short and stout.")
+        Chef.deprecated(:generic, "This is my handle.")
+      end
+
+      it "allows silencing specific IDs using the CHEF- syntax" do
+        Chef::Config[:silence_deprecation_warnings] = ["CHEF-0"]
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:internal_api, "Short and stout.")
+        Chef.deprecated(:generic, "This is my handle.")
+      end
+
+      it "allows silencing specific IDs using the chef- syntax" do
+        Chef::Config[:silence_deprecation_warnings] = ["chef-0"]
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:internal_api, "Short and stout.")
+        Chef.deprecated(:generic, "This is my handle.")
+      end
+
+      it "allows silencing specific lines" do
+        Chef::Config[:silence_deprecation_warnings] = ["chef_class_spec.rb:#{__LINE__ + 4}"]
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:generic, "Short and stout.")
+        Chef.deprecated(:internal_api, "This is my handle.")
+      end
+
+      it "allows silencing all via inline comments" do
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:generic, "Short and stout.") # chef:silence_deprecation
+        Chef.deprecated(:internal_api, "This is my handle.")
+      end
+
+      it "allows silencing specific types via inline comments" do
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:generic, "Short and stout.") # chef:silence_deprecation:generic
+        Chef.deprecated(:internal_api, "This is my handle.")
+      end
+
+      it "does not silence via inline comments when the types don't match" do
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/Short and stout/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:internal_api, "Short and stout.") # chef:silence_deprecation:generic
+        Chef.deprecated(:internal_api, "This is my handle.")
+      end
+
+      it "allows silencing all via inline comments with other stuff in the comment" do
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:generic, "Short and stout.") # rubocop:something chef:silence_deprecation other stuff
+        Chef.deprecated(:internal_api, "This is my handle.")
+      end
+
+      it "handles multiple silence configurations at the same time" do
+        Chef::Config[:silence_deprecation_warnings] = ["exit_code", "chef_class_spec.rb:#{__LINE__ + 6}"]
+        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
+        expect(Chef::Log).to receive(:warn).with(/This is my spout/).once
+        expect(Chef::Log).to receive(:warn).with(/Hear me shout/).once
+        Chef.deprecated(:generic, "I'm a little teapot.")
+        Chef.deprecated(:generic, "Short and stout.") # chef:silence_deprecation
+        Chef.deprecated(:internal_api, "This is my handle.")
+        Chef.deprecated(:internal_api, "This is my spout.")
+        Chef.deprecated(:exit_code, "When I get all steamed up.")
+        Chef.deprecated(:generic, "Hear me shout.")
+      end
+    end
+
+    context "with treat_deprecation_warnings_as_errors true" do
+      # This is already turned on globally for Chef's unit tests, but just for clarity do it here too.
+      before { Chef::Config[:treat_deprecation_warnings_as_errors] = true }
+
+      it "displays a simple deprecation error" do
+        expect(Chef::Log).to receive(:error).with(%r{spec/unit/chef_class_spec\.rb.*?I'm a little teapot.*?Please see}m)
+        expect { Chef.deprecated(:generic, "I'm a little teapot.") }.to raise_error(/I'm a little teapot./)
+      end
+    end
+  end
 end

data/spec/unit/chef_fs/data_handler/data_bag_item_data_handler.rb

@@ -68,7 +68,7 @@ describe Chef::ChefFS::DataHandler::DataBagItemDataHandler do
 
     context "using a reserved word as part of the data bag name" do
       %w{xnode rolex xenvironmentx xclientx}.each do |bag_name|
-        let(:entry) { TestDataBagItem.new("#{bag_name}", "bag") }
+        let(:entry) { TestDataBagItem.new(bag_name.to_s, "bag") }
         let(:object) do
           { "raw_data" => { "id" => "bag" } }
         end