chef 12.15.19-universal-mingw32 → 12.16.42-universal-mingw32

data/spec/integration/knife/node_environment_set_spec.rb

@@ -31,7 +31,10 @@ describe "knife node environment set", :workstation do
 
     it "sets an environment on a node" do
       knife("node environment set cons lisp").should_succeed /chef_environment:.*lisp/
-      knife("node show cons -a chef_environment").should_succeed /Environment:.*lisp/
+      knife("node show cons -a chef_environment").should_succeed <<EOM
+cons:
+  chef_environment: lisp
+EOM
     end
 
     it "with no environment" do

data/spec/integration/recipes/accumulator_spec.rb

@@ -0,0 +1,232 @@
+require "support/shared/integration/integration_helper"
+require "chef/mixin/shell_out"
+
+describe "Accumulators" do
+  include IntegrationSupport
+  include Chef::Mixin::ShellOut
+
+  let(:chef_dir) { File.expand_path("../../../../bin", __FILE__) }
+
+  # Invoke `chef-client` as `ruby PATH/TO/chef-client`. This ensures the
+  # following constraints are satisfied:
+  # * Windows: windows can only run batch scripts as bare executables. Rubygems
+  # creates batch wrappers for installed gems, but we don't have batch wrappers
+  # in the source tree.
+  # * Other `chef-client` in PATH: A common case is running the tests on a
+  # machine that has omnibus chef installed. In that case we need to ensure
+  # we're running `chef-client` from the source tree and not the external one.
+  # cf. CHEF-4914
+  let(:chef_client) { "ruby '#{chef_dir}/chef-client' --minimal-ohai" }
+
+  let(:aliases_temppath) do
+    t = Tempfile.new("chef_accumulator_test")
+    path = t.path
+    t.close
+    t.unlink
+    path
+  end
+
+  when_the_repository "edit_resource-based delayed accumulators work" do
+    before do
+      directory "cookbooks/x" do
+        file "resources/email_alias.rb", <<-EOM
+          provides :email_alias
+          resource_name :email_alias
+
+          property :address, String, name_property: true, identity: true
+          property :recipients, Array
+
+          default_action :create
+
+          action :create do
+            with_run_context :root do
+              edit_resource(:template, "#{aliases_temppath}") do |new_resource|
+                source "aliases.erb"
+                variables[:aliases] ||= {}
+                variables[:aliases][new_resource.address] ||= []
+                variables[:aliases][new_resource.address] += new_resource.recipients
+                action :nothing
+                delayed_action :create
+              end
+            end
+          end
+        EOM
+
+        file "resources/nested.rb", <<-EOM
+          provides :nested
+          resource_name :nested
+
+          property :address, String, name_property: true, identity: true
+          property :recipients, Array
+
+          default_action :create
+
+          action :create do
+            email_alias address do
+              recipients new_resource.recipients
+            end
+          end
+        EOM
+
+        file "resources/doubly_nested.rb", <<-EOM
+          provides :doubly_nested
+          resource_name :doubly_nested
+
+          property :address, String, name_property: true, identity: true
+          property :recipients, Array
+
+          default_action :create
+
+          action :create do
+            nested address do
+              recipients new_resource.recipients
+            end
+          end
+        EOM
+
+        file "recipes/default.rb", <<-EOM
+          email_alias "outer1" do
+            recipients [ "out1a", "out1b" ]
+          end
+
+          nested "nested1" do
+            recipients [ "nested1a", "nested1b" ]
+          end
+
+          email_alias "outer2" do
+            recipients [ "out2a", "out2b" ]
+          end
+
+          doubly_nested "nested2" do
+            recipients [ "nested2a", "nested2b" ]
+          end
+
+          email_alias "outer3" do
+            recipients [ "out3a", "out3b" ]
+          end
+        EOM
+
+        file "templates/aliases.erb", <<-EOM.gsub(/^\s+/, "")
+          <%= pp @aliases %>
+        EOM
+      end # directory 'cookbooks/x'
+    end
+
+    it "should complete with success" do
+      file "config/client.rb", <<-EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+        log_level :warn
+      EOM
+
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" --no-color -F doc -o 'x::default'", :cwd => chef_dir)
+      result.error!
+      # runs only a single template resource (in the outer run context, as a delayed resource)
+      expect(result.stdout.scan(/template\S+ action create/).size).to eql(1)
+      # hash order is insertion order in ruby >= 1.9, so this next line does test that all calls were in the correct order
+      expect(IO.read(aliases_temppath).chomp).to eql('{"outer1"=>["out1a", "out1b"], "nested1"=>["nested1a", "nested1b"], "outer2"=>["out2a", "out2b"], "nested2"=>["nested2a", "nested2b"], "outer3"=>["out3a", "out3b"]}')
+    end
+  end
+
+  when_the_repository "find_resource-based delayed accumulators work" do
+    before do
+      directory "cookbooks/x" do
+        file "resources/email_alias.rb", <<-EOM
+          provides :email_alias
+          resource_name :email_alias
+
+          property :address, String, name_property: true, identity: true
+          property :recipients, Array
+
+          default_action :create
+
+          action :create do
+            r = with_run_context :root do
+              find_resource(:template, "#{aliases_temppath}") do
+                source "aliases.erb"
+                variables[:aliases] = {}
+                action :nothing
+                delayed_action :create
+              end
+            end
+            r.variables[:aliases][address] ||= []
+            r.variables[:aliases][address] += new_resource.recipients
+          end
+        EOM
+
+        file "resources/nested.rb", <<-EOM
+          provides :nested
+          resource_name :nested
+
+          property :address, String, name_property: true, identity: true
+          property :recipients, Array
+
+          default_action :create
+
+          action :create do
+            email_alias address do
+              recipients new_resource.recipients
+            end
+          end
+        EOM
+
+        file "resources/doubly_nested.rb", <<-EOM
+          provides :doubly_nested
+          resource_name :doubly_nested
+
+          property :address, String, name_property: true, identity: true
+          property :recipients, Array
+
+          default_action :create
+
+          action :create do
+            nested address do
+              recipients new_resource.recipients
+            end
+          end
+        EOM
+
+        file "recipes/default.rb", <<-EOM
+          email_alias "outer1" do
+            recipients [ "out1a", "out1b" ]
+          end
+
+          nested "nested1" do
+            recipients [ "nested1a", "nested1b" ]
+          end
+
+          email_alias "outer2" do
+            recipients [ "out2a", "out2b" ]
+          end
+
+          doubly_nested "nested2" do
+            recipients [ "nested2a", "nested2b" ]
+          end
+
+          email_alias "outer3" do
+            recipients [ "out3a", "out3b" ]
+          end
+        EOM
+
+        file "templates/aliases.erb", <<-EOM.gsub(/^\s+/, "")
+          <%= pp @aliases %>
+        EOM
+      end # directory 'cookbooks/x'
+    end
+
+    it "should complete with success" do
+      file "config/client.rb", <<-EOM
+        local_mode true
+        cookbook_path "#{path_to('cookbooks')}"
+        log_level :warn
+      EOM
+
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" --no-color -F doc -o 'x::default'", :cwd => chef_dir)
+      result.error!
+      # runs only a single template resource (in the outer run context, as a delayed resource)
+      expect(result.stdout.scan(/template\S+ action create/).size).to eql(1)
+      # hash order is insertion order in ruby >= 1.9, so this next line does test that all calls were in the correct order
+      expect(IO.read(aliases_temppath).chomp).to eql('{"outer1"=>["out1a", "out1b"], "nested1"=>["nested1a", "nested1b"], "outer2"=>["out2a", "out2b"], "nested2"=>["nested2a", "nested2b"], "outer3"=>["out3a", "out3b"]}')
+    end
+  end
+end

data/spec/integration/recipes/resource_action_spec.rb

@@ -498,7 +498,7 @@ module ResourceActionSpec
       it "Raises an error when attempting to use a template in the action" do
         expect_converge do
           has_property_named_template "hi"
-        end.to raise_error(/Property template of has_property_named_template\[hi\] cannot be passed a block! If you meant to create a resource named template instead, you'll need to first rename the property./)
+        end.to raise_error(/Property `template` of `has_property_named_template\[hi\]` was incorrectly passed a block.  Possible property-resource collision.  To call a resource named `template` either rename the property or else use `declare_resource\(:template, ...\)`/)
       end
     end
 

data/spec/spec_helper.rb

@@ -174,13 +174,13 @@ RSpec.configure do |config|
 
   running_platform_arch = `uname -m`.strip unless windows?
 
-  config.filter_run_excluding :arch => lambda {|target_arch|
+  config.filter_run_excluding :arch => lambda { |target_arch|
     running_platform_arch != target_arch
   }
 
   # Functional Resource tests that are provider-specific:
   # context "on platforms that use useradd", :provider => {:user => Chef::Provider::User::Useradd}} do #...
-  config.filter_run_excluding :provider => lambda {|criteria|
+  config.filter_run_excluding :provider => lambda { |criteria|
     type, target_provider = criteria.first
 
     node = TEST_NODE.dup

data/spec/support/shared/context/client.rb

@@ -68,9 +68,10 @@ shared_context "a client run" do
   let(:api_client_exists?) { false }
   let(:enable_fork)        { false }
 
-  let(:http_cookbook_sync) { double("Chef::ServerAPI (cookbook sync)") }
-  let(:http_node_load)     { double("Chef::ServerAPI (node)") }
-  let(:http_node_save)     { double("Chef::ServerAPI (node save)") }
+  let(:http_data_collector)   { double("Chef::ServerAPI (data collector)") }
+  let(:http_cookbook_sync)    { double("Chef::ServerAPI (cookbook sync)") }
+  let(:http_node_load)        { double("Chef::ServerAPI (node)") }
+  let(:http_node_save)        { double("Chef::ServerAPI (node save)") }
   let(:reporting_rest_client) { double("Chef::ServerAPI (reporting client)") }
 
   let(:runner)       { instance_double("Chef::Runner") }
@@ -92,6 +93,13 @@ shared_context "a client run" do
     end
   end
 
+  def stub_for_data_collector_init
+    expect(Chef::ServerAPI).to receive(:new).
+      with(Chef::Config[:data_collector][:server_url]).
+      exactly(:once).
+      and_return(http_data_collector)
+  end
+
   def stub_for_node_load
     #   Client.register will then turn around create another
     #   Chef::ServerAPI object, this time with the client key it got from the
@@ -154,6 +162,7 @@ shared_context "a client run" do
 
     stub_rest_clean
     stub_for_register
+    stub_for_data_collector_init
     stub_for_node_load
     stub_for_sync_cookbooks
     stub_for_converge

data/spec/support/shared/integration/app_server_support.rb

@@ -1,7 +1,7 @@
 #
 # Author:: John Keiser (<jkeiser@chef.io>)
 # Author:: Ho-Sheng Hsiao (<hosh@chef.io>)
-# Copyright:: Copyright 2012-2016, 2013-2015 Chef Software, Inc.
+# Copyright:: Copyright 2012-2016 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/spec/support/shared/integration/knife_support.rb

@@ -64,8 +64,11 @@ module KnifeSupport
         subcommand_class.load_deps
         instance = subcommand_class.new(args)
 
+        # Load configs
+        instance.merge_configs
+
         # Capture stdout/stderr
-        instance.ui = Chef::Knife::UI.new(stdout, stderr, stdin, disable_editing: true)
+        instance.ui = Chef::Knife::UI.new(stdout, stderr, stdin, instance.config.merge(disable_editing: true))
 
         # Don't print stuff
         Chef::Config[:verbosity] = ( DEBUG ? 2 : 0 )

data/spec/unit/data_collector/messages_spec.rb

@@ -113,6 +113,7 @@ describe Chef::DataCollector::Messages do
           status
           total_resource_count
           updated_resource_count
+          deprecations
         }
       end
       let(:optional_fields) { %w{error} }
@@ -164,6 +165,7 @@ describe Chef::DataCollector::Messages do
           status
           total_resource_count
           updated_resource_count
+          deprecations
         }
       end
       let(:optional_fields) { [] }

data/spec/unit/data_collector_spec.rb

@@ -23,6 +23,7 @@ require "chef/data_collector"
 require "chef/resource_builder"
 
 describe Chef::DataCollector do
+
   describe ".register_reporter?" do
     context "when no data collector URL is configured" do
       it "returns false" do
@@ -44,23 +45,93 @@ describe Chef::DataCollector do
       end
 
       context "when not operating in why_run mode" do
+
         before do
           Chef::Config[:why_run] = false
+          Chef::Config[:data_collector][:token] = token
         end
 
-        context "when report is enabled for current mode" do
-          it "returns true" do
-            allow(Chef::DataCollector).to receive(:reporter_enabled_for_current_mode?).and_return(true)
-            expect(Chef::DataCollector.register_reporter?).to be_truthy
+        context "when a token is configured" do
+
+          let(:token) { "supersecrettoken" }
+
+          context "when report is enabled for current mode" do
+            it "returns true" do
+              allow(Chef::DataCollector).to receive(:reporter_enabled_for_current_mode?).and_return(true)
+              expect(Chef::DataCollector.register_reporter?).to be_truthy
+            end
           end
+
+          context "when report is disabled for current mode" do
+            it "returns false" do
+              allow(Chef::DataCollector).to receive(:reporter_enabled_for_current_mode?).and_return(false)
+              expect(Chef::DataCollector.register_reporter?).to be_falsey
+            end
+          end
+
         end
 
-        context "when report is disabled for current mode" do
-          it "returns false" do
-            allow(Chef::DataCollector).to receive(:reporter_enabled_for_current_mode?).and_return(false)
-            expect(Chef::DataCollector.register_reporter?).to be_falsey
+        # `Chef::Config[:data_collector][:server_url]` defaults to a URL
+        # relative to the `chef_server_url`, so we use configuration of the
+        # token to infer whether a solo/local mode user intends for data
+        # collection to be enabled.
+        context "when a token is not configured" do
+
+          let(:token) { nil }
+
+          context "when report is enabled for current mode" do
+
+            before do
+              allow(Chef::DataCollector).to receive(:reporter_enabled_for_current_mode?).and_return(true)
+            end
+
+            context "when the current mode is solo" do
+
+              before do
+                Chef::Config[:solo] = true
+              end
+
+              it "returns true" do
+                expect(Chef::DataCollector.register_reporter?).to be(true)
+              end
+
+            end
+
+            context "when the current mode is local mode" do
+
+              before do
+                Chef::Config[:local_mode] = true
+              end
+
+              it "returns false" do
+                expect(Chef::DataCollector.register_reporter?).to be(true)
+              end
+            end
+
+            context "when the current mode is client mode" do
+
+              before do
+                Chef::Config[:local_mode] = false
+                Chef::Config[:solo] = false
+              end
+
+              it "returns true" do
+                expect(Chef::DataCollector.register_reporter?).to be_truthy
+              end
+
+            end
+
+          end
+
+          context "when report is disabled for current mode" do
+            it "returns false" do
+              allow(Chef::DataCollector).to receive(:reporter_enabled_for_current_mode?).and_return(false)
+              expect(Chef::DataCollector.register_reporter?).to be_falsey
+            end
           end
+
         end
+
       end
     end
   end
@@ -150,14 +221,52 @@ describe Chef::DataCollector do
       end
     end
   end
+
 end
 
 describe Chef::DataCollector::Reporter do
   let(:reporter) { described_class.new }
   let(:run_status) { Chef::RunStatus.new(Chef::Node.new, Chef::EventDispatch::Dispatcher.new) }
 
+  let(:token) { "supersecrettoken" }
+
   before do
     Chef::Config[:data_collector][:server_url] = "http://my-data-collector-server.mycompany.com"
+    Chef::Config[:data_collector][:token] = token
+  end
+
+  describe "selecting token or signed header authentication" do
+
+    context "when the token is set in the config" do
+
+      before do
+        Chef::Config[:client_key] = "/no/key/should/exist/at/this/path.pem"
+      end
+
+      it "configures an HTTP client that doesn't do signed header auth" do
+        # Initializing with the wrong kind of HTTP class should cause Chef::Exceptions::PrivateKeyMissing
+        expect { reporter.http }.to_not raise_error
+      end
+
+    end
+
+    context "when no token is set in the config" do
+
+      let(:token) { nil }
+
+      let(:client_key) { File.join(CHEF_SPEC_DATA, "ssl", "private_key.pem") }
+
+      before do
+        Chef::Config[:client_key] = client_key
+      end
+
+      it "configures an HTTP client that does signed header auth" do
+        expect { reporter.http }.to_not raise_error
+        expect(reporter.http.options).to have_key(:signing_key_filename)
+        expect(reporter.http.options[:signing_key_filename]).to eq(client_key)
+      end
+    end
+
   end
 
   describe "#run_started" do
@@ -177,24 +286,52 @@ describe Chef::DataCollector::Reporter do
         .to receive(:run_start_message)
         .with(run_status)
         .and_return(key: "value")
-      expect(reporter).to receive(:send_to_data_collector).with('{"key":"value"}')
+      expect(reporter).to receive(:send_to_data_collector).with({ key: "value" })
       reporter.run_started(run_status)
     end
   end
 
-  describe "#run_completed" do
-    it "sends the run completion" do
-      node = Chef::Node.new
+  describe "when sending a message at chef run completion" do
 
-      expect(reporter).to receive(:send_run_completion).with(status: "success")
-      reporter.run_completed(node)
+    let(:node) { Chef::Node.new }
+
+    let(:run_status) do
+      instance_double("Chef::RunStatus",
+                      run_id: "run_id",
+                      node: node,
+                      start_time: Time.new,
+                      end_time: Time.new,
+                      exception: exception)
     end
-  end
 
-  describe "#run_failed" do
-    it "updates the exception and sends the run completion" do
-      expect(reporter).to receive(:send_run_completion).with(status: "failure")
-      reporter.run_failed("test_exception")
+    before do
+      reporter.send(:update_run_status, run_status)
+    end
+
+    describe "#run_completed" do
+
+      let(:exception) { nil }
+
+      it "sends the run completion" do
+        expect(reporter).to receive(:send_to_data_collector) do |message|
+          expect(message).to be_a(Hash)
+          expect(message["status"]).to eq("success")
+        end
+        reporter.run_completed(node)
+      end
+    end
+
+    describe "#run_failed" do
+
+      let(:exception) { StandardError.new("oops") }
+
+      it "updates the exception and sends the run completion" do
+        expect(reporter).to receive(:send_to_data_collector) do |message|
+          expect(message).to be_a(Hash)
+          expect(message["status"]).to eq("failure")
+        end
+        reporter.run_failed("test_exception")
+      end
     end
   end
 
@@ -511,9 +648,9 @@ describe Chef::DataCollector::Reporter do
         end
 
         context "when raise-on-failure is disabled" do
-          it "logs a warning and does not raise an exception" do
+          it "logs an info message and does not raise an exception" do
             Chef::Config[:data_collector][:raise_on_failure] = false
-            expect(Chef::Log).to receive(:warn)
+            expect(Chef::Log).to receive(:info)
             expect { reporter.send(:disable_reporter_on_error) { raise exception_class.new("bummer") } }.not_to raise_error
           end
         end