chef 12.5.0.alpha.1 → 12.5.1

data/spec/support/shared/unit/mock_shellout.rb

@@ -0,0 +1,46 @@
+#
+# Author:: John Keiser <jkeiser@chef.io>
+# Copyright:: Copyright (c) 2015 John Keiser.
+# 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.
+#
+
+#
+# Mocks shellout results. Examples:
+#   mock_shellout_command("systemctl --all", exitstatus: 1)
+#
+class MockShellout
+  module RSpec
+    def mock_shellout_command(command, **result)
+      allow(::Mixlib::ShellOut).to receive(:new).with(command, anything).and_return MockShellout.new(result)
+    end
+  end
+
+  def initialize(**properties)
+    @properties = {
+      stdout: "",
+      stderr: "",
+      exitstatus: 0
+    }.merge(properties)
+  end
+  def method_missing(name, *args)
+    @properties[name.to_sym]
+  end
+  def error?
+    exitstatus != 0
+  end
+  def error!
+    raise Mixlib::ShellOut::ShellCommandFailed, "Expected process to exit with 0, but received #{exitstatus}" if error?
+  end
+end

data/spec/support/shared/unit/provider/file.rb

@@ -465,11 +465,13 @@ shared_examples_for Chef::Provider::File do
         t
       }
 
-      let(:verification) { double("Verification") }
+      let(:verification) { instance_double(Chef::Resource::File::Verification) }
+      let(:verification_fail) { instance_double(Chef::Resource::File::Verification) }
 
       context "with user-supplied verifications" do
         it "calls #verify on each verification with tempfile path" do
-          allow(Chef::Resource::File::Verification).to receive(:new).and_return(verification)
+          allow(Chef::Resource::File::Verification).to(
+            receive(:new).with(anything(), "true", anything()).and_return(verification))
           provider.new_resource.verify "true"
           provider.new_resource.verify "true"
           expect(verification).to receive(:verify).with(tempfile.path).twice.and_return(true)
@@ -477,10 +479,14 @@ shared_examples_for Chef::Provider::File do
         end
 
         it "raises an exception if any verification fails" do
+          allow(Chef::Resource::File::Verification).to(
+            receive(:new).with(anything(), "true", anything()).and_return(verification))
+          allow(Chef::Resource::File::Verification).to(
+            receive(:new).with(anything(), "false", anything()).and_return(verification_fail))
           provider.new_resource.verify "true"
           provider.new_resource.verify "false"
-          allow(verification).to receive(:verify).with("true").and_return(true)
-          allow(verification).to receive(:verify).with("false").and_return(false)
+          expect(verification).to receive(:verify).with(tempfile.path).and_return(true)
+          expect(verification_fail).to receive(:verify).with(tempfile.path).and_return(false)
           expect{provider.send(:do_validate_content)}.to raise_error(Chef::Exceptions::ValidationFailed)
         end
       end

data/spec/unit/application/client_spec.rb

@@ -47,6 +47,19 @@ describe Chef::Application::Client, "reconfigure" do
       expect(app).to receive(:set_specific_recipes).and_return(true)
       app.reconfigure
     end
+
+    context "when given a named_run_list" do
+
+      before do
+        ARGV.replace( %w[ --named-run-list arglebargle-example ] )
+        app.reconfigure
+      end
+
+      it "sets named_run_list in Chef::Config" do
+        expect(Chef::Config[:named_run_list]).to eq("arglebargle-example")
+      end
+
+    end
   end
 
   describe "when configured to not fork the client process" do
@@ -237,7 +250,7 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
     end
 
     it "should throw an exception" do
-      expect { @app.reconfigure }.to raise_error
+      expect { app.reconfigure }.to raise_error(Chef::Exceptions::PIDFileLockfileMatch)
     end
   end
 end
@@ -275,9 +288,9 @@ describe Chef::Application::Client, "configure_chef" do
     ARGV.replace(@original_argv)
   end
 
-  it "should set the colored output to false by default on windows and true otherwise" do
+  it "should set the colored output to true by default on windows and true on all other platforms as well" do
     if windows?
-      expect(Chef::Config[:color]).to be_falsey
+      expect(Chef::Config[:color]).to be_truthy
     else
       expect(Chef::Config[:color]).to be_truthy
     end

data/spec/unit/application/knife_spec.rb

@@ -70,13 +70,13 @@ describe Chef::Application::Knife do
     end
   end
 
-  it "should set the colored output to false by default on windows and true otherwise" do
+  it "should set the colored output to true by default on windows and true on all other platforms as well" do
     with_argv(*%w{noop knife command}) do
       expect(@knife).to receive(:exit).with(0)
       @knife.run
     end
     if windows?
-      expect(Chef::Config[:color]).to be_falsey
+      expect(Chef::Config[:color]).to be_truthy
     else
       expect(Chef::Config[:color]).to be_truthy
     end

data/spec/unit/chef_class_spec.rb

@@ -46,10 +46,6 @@ describe "Chef class" do
     Chef.set_provider_priority_map(provider_priority_map)
   end
 
-  after do
-    Chef.reset!
-  end
-
   context "priority maps" do
     context "#get_provider_priority_array" do
       it "should use the current node to get the right priority_map" do

data/spec/unit/client_spec.rb

@@ -364,6 +364,8 @@ describe Chef::Client do
       expect(node[:expanded_run_list]).to be_nil
 
       allow(client.policy_builder).to receive(:node).and_return(node)
+      client.policy_builder.select_implementation(node)
+      allow(client.policy_builder.implementation).to receive(:node).and_return(node)
 
       # chefspec and possibly others use the return value of this method
       expect(client.build_node).to eq(node)
@@ -373,7 +375,8 @@ describe Chef::Client do
       expect(node[:roles].length).to eq(1)
       expect(node[:roles]).to include("role_containing_cookbook1")
       expect(node[:recipes]).not_to be_nil
-      expect(node[:recipes].length).to eq(1)
+      expect(node[:recipes].length).to eq(2)
+      expect(node[:recipes]).to include("cookbook1")
       expect(node[:recipes]).to include("cookbook1::default")
       expect(node[:expanded_run_list]).not_to be_nil
       expect(node[:expanded_run_list].length).to eq(1)
@@ -391,6 +394,8 @@ describe Chef::Client do
       expect(mock_chef_rest).to receive(:get_rest).with("environments/A").and_return(test_env)
       expect(Chef::REST).to receive(:new).and_return(mock_chef_rest)
       allow(client.policy_builder).to receive(:node).and_return(node)
+      client.policy_builder.select_implementation(node)
+      allow(client.policy_builder.implementation).to receive(:node).and_return(node)
       expect(client.build_node).to eq(node)
 
       expect(node.chef_environment).to eq("A")

data/spec/unit/config_spec.rb

@@ -0,0 +1,31 @@
+
+require 'spec_helper'
+
+require 'chef/config'
+
+RSpec.describe Chef::Config do
+
+  shared_examples_for "deprecated by ohai but not deprecated" do
+    it "does not emit a deprecation warning when set" do
+      expect(Chef::Log).to_not receive(:warn).
+        with(/Ohai::Config\[:#{option}\] is deprecated/)
+      Chef::Config[option] = value
+      expect(Chef::Config[option]).to eq(value)
+    end
+  end
+
+  describe ":log_level" do
+    include_examples "deprecated by ohai but not deprecated" do
+      let(:option) { :log_level }
+      let(:value) { :debug }
+    end
+  end
+
+  describe ":log_location" do
+    include_examples "deprecated by ohai but not deprecated" do
+      let(:option) { :log_location }
+      let(:value) { "path/to/log" }
+    end
+  end
+
+end

data/spec/unit/cookbook/metadata_spec.rb

@@ -30,7 +30,7 @@ describe Chef::Cookbook::Metadata do
                   :maintainer_email, :license, :platforms, :dependencies,
                   :recommendations, :suggestions, :conflicting, :providing,
                   :replacing, :attributes, :groupings, :recipes, :version,
-                  :source_url, :issues_url ]
+                  :source_url, :issues_url, :privacy ]
     end
 
     it "does not depend on object identity for equality" do
@@ -148,6 +148,10 @@ describe Chef::Cookbook::Metadata do
     it "has an empty issues_url string" do
       expect(metadata.issues_url).to eq('')
     end
+
+    it "is not private" do
+      expect(metadata.privacy).to eq(false)
+    end
   end
 
   describe "validation" do
@@ -198,7 +202,8 @@ describe Chef::Cookbook::Metadata do
       :long_description => "Much Longer\nSeriously",
       :version => "0.6.0",
       :source_url => "http://example.com",
-      :issues_url => "http://example.com/issues"
+      :issues_url => "http://example.com/issues",
+      :privacy => true
     }
     params.sort { |a,b| a.to_s <=> b.to_s }.each do |field, field_value|
       describe field do
@@ -360,7 +365,8 @@ describe Chef::Cookbook::Metadata do
         "recipes" => [ "mysql::server", "mysql::master" ],
         "default" => [ ],
         "source_url" => "http://example.com",
-        "issues_url" => "http://example.com/issues"
+        "issues_url" => "http://example.com/issues",
+        "privacy" => true
       }
       expect(metadata.attribute("/db/mysql/databases", attrs)).to eq(attrs)
     end
@@ -401,6 +407,18 @@ describe Chef::Cookbook::Metadata do
       }.to raise_error(ArgumentError)
     end
 
+    it "should not accept anything but true or false for the privacy flag" do
+      expect {
+        metadata.attribute("db/mysql/databases", :privacy => true)
+      }.not_to raise_error
+      expect {
+        metadata.attribute("db/mysql/databases", :privacy => false)
+      }.not_to raise_error
+      expect {
+        metadata.attribute("db/mysql/databases", :privacy => 'true')
+      }.to raise_error(ArgumentError)
+    end
+
     it "should not accept anything but an array of strings for choice" do
       expect {
         metadata.attribute("db/mysql/databases", :choice => ['dedicated', 'shared'])
@@ -699,6 +717,7 @@ describe Chef::Cookbook::Metadata do
         version
         source_url
         issues_url
+        privacy
       }.each do |t|
         it "should include '#{t}'" do
           expect(deserialized_metadata[t]).to eq(metadata.send(t.to_sym))
@@ -734,6 +753,7 @@ describe Chef::Cookbook::Metadata do
         version
         source_url
         issues_url
+        privacy
       }.each do |t|
         it "should match '#{t}'" do
           expect(deserialized_metadata.send(t.to_sym)).to eq(metadata.send(t.to_sym))

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -53,7 +53,10 @@ describe Chef::Cookbook::SyntaxCheck do
     @ruby_files = @attr_files + @libr_files + @defn_files + @recipes + [File.join(cookbook_path, "metadata.rb")]
     basenames = %w{ helpers_via_partial_test.erb
                     helper_test.erb
+                    helpers.erb
                     openldap_stuff.conf.erb
+                    nested_openldap_partials.erb
+                    nested_partial.erb
                     openldap_variable_stuff.conf.erb
                     test.erb
                     some_windows_line_endings.erb

data/spec/unit/deprecation_spec.rb

@@ -65,19 +65,16 @@ describe Chef::Deprecation do
     end
 
     context 'deprecation warning messages' do
-      before(:each) do
-        @warning_output = [ ]
-        allow(Chef::Log).to receive(:warn) { |msg| @warning_output << msg }
-      end
+      RSpec::Matchers.define_negated_matcher :a_non_empty_array, :be_empty
 
       it 'should be enabled for deprecated methods' do
+        expect(Chef::Log).to receive(:warn).with(a_non_empty_array)
         TestClass.new.deprecated_method(10)
-        expect(@warning_output).not_to be_empty
       end
 
       it 'should contain stack trace' do
+        expect(Chef::Log).to receive(:warn).with(a_string_including(".rb"))
         TestClass.new.deprecated_method(10)
-        expect(@warning_output.join("").include?(".rb")).to be_truthy
       end
     end
 

data/spec/unit/dsl/reboot_pending_spec.rb

@@ -46,15 +46,21 @@ describe Chef::DSL::RebootPending do
         end
   
         it 'should return true if key "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired" exists' do
-          allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired').and_return(true)
+          allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootPending').and_return(true)
           expect(recipe.reboot_pending?).to be_truthy
         end
   
-        it 'should return true if value "HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile" contains specific data' do
-          allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(true)
-          allow(recipe).to receive(:registry_get_values).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(
-                [{:name => "Flags", :type => :dword, :data => 3}])
-          expect(recipe.reboot_pending?).to be_truthy
+        context "version is server 2003" do
+          before do
+            allow(Chef::Platform).to receive(:windows_server_2003?).and_return(true)
+          end
+
+          it 'should return true if value "HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile" contains specific data on 2k3' do
+            allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(true)
+            allow(recipe).to receive(:registry_get_values).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(
+                  [{:name => "Flags", :type => :dword, :data => 3}])
+            expect(recipe.reboot_pending?).to be_truthy
+          end
         end
       end
   

data/spec/unit/event_dispatch/dispatcher_spec.rb

@@ -47,15 +47,77 @@ describe Chef::EventDispatch::Dispatcher do
       expect(event_sink).to receive(:run_start).with("12.4.0")
       dispatcher.run_start("12.4.0")
 
-      expect(event_sink).to receive(:synchronized_cookbook).with("apache2")
-      dispatcher.synchronized_cookbook("apache2")
+      cookbook_version = double("cookbook_version")
+      expect(event_sink).to receive(:synchronized_cookbook).with("apache2", cookbook_version)
+      dispatcher.synchronized_cookbook("apache2", cookbook_version)
 
       exception = StandardError.new("foo")
       expect(event_sink).to receive(:recipe_file_load_failed).with("/path/to/file.rb", exception)
       dispatcher.recipe_file_load_failed("/path/to/file.rb", exception)
     end
 
+    context "when an event sink has fewer arguments for an event" do
+      # Can't use a double because they don't report arity correctly.
+      let(:event_sink) do
+        Class.new(Chef::EventDispatch::Base) do
+          attr_reader :synchronized_cookbook_args
+          def synchronized_cookbook(cookbook_name)
+            @synchronized_cookbook_args = [cookbook_name]
+          end
+        end.new
+      end
+
+      it "trims the arugment list" do
+        cookbook_version = double("cookbook_version")
+        dispatcher.synchronized_cookbook("apache2", cookbook_version)
+        expect(event_sink.synchronized_cookbook_args).to eq ["apache2"]
+      end
+    end
   end
 
-end
 
+  context "when two event sinks have different arguments for an event" do
+    let(:event_sink_1) do
+      Class.new(Chef::EventDispatch::Base) do
+        attr_reader :synchronized_cookbook_args
+        def synchronized_cookbook(cookbook_name)
+          @synchronized_cookbook_args = [cookbook_name]
+        end
+      end.new
+    end
+    let(:event_sink_2) do
+      Class.new(Chef::EventDispatch::Base) do
+        attr_reader :synchronized_cookbook_args
+        def synchronized_cookbook(cookbook_name, cookbook)
+          @synchronized_cookbook_args = [cookbook_name, cookbook]
+        end
+      end.new
+    end
+
+    context "and the one with fewer arguments comes first" do
+      before do
+        dispatcher.register(event_sink_1)
+        dispatcher.register(event_sink_2)
+      end
+      it "trims the arugment list" do
+        cookbook_version = double("cookbook_version")
+        dispatcher.synchronized_cookbook("apache2", cookbook_version)
+        expect(event_sink_1.synchronized_cookbook_args).to eq ["apache2"]
+        expect(event_sink_2.synchronized_cookbook_args).to eq ["apache2", cookbook_version]
+      end
+    end
+
+    context "and the one with fewer arguments comes last" do
+      before do
+        dispatcher.register(event_sink_2)
+        dispatcher.register(event_sink_1)
+      end
+      it "trims the arugment list" do
+        cookbook_version = double("cookbook_version")
+        dispatcher.synchronized_cookbook("apache2", cookbook_version)
+        expect(event_sink_1.synchronized_cookbook_args).to eq ["apache2"]
+        expect(event_sink_2.synchronized_cookbook_args).to eq ["apache2", cookbook_version]
+      end
+    end
+  end
+end

data/spec/unit/event_dispatch/dsl_spec.rb

@@ -32,10 +32,6 @@ describe Chef::EventDispatch::DSL do
     Chef.set_run_context(run_context)
   end
 
-  after do
-    Chef.reset!
-  end
-
   subject{ described_class.new('test') }
 
   it 'set handler name' do

data/spec/unit/formatters/doc_spec.rb

@@ -43,4 +43,36 @@ describe Chef::Formatters::Base do
     expect(out.string).to include("Using policy 'jenkins' at revision '613f803bdd035d574df7fa6da525b38df45a74ca82b38b79655efed8a189e073'")
   end
 
+  it "prints cookbook name and version" do
+    cookbook_version = double(name: "apache2", version: "1.2.3")
+    formatter.synchronized_cookbook("apache2", cookbook_version)
+    expect(out.string).to include("- apache2 (1.2.3")
+  end
+
+  it "prints only seconds when elapsed time is less than 60 seconds" do
+    @now = Time.now
+    allow(Time).to receive(:now).and_return(@now, @now + 10.0)
+    formatter.run_completed(nil)
+    expect(formatter.elapsed_time).to eql(10.0)
+    expect(formatter.pretty_elapsed_time).to include("10 seconds")
+    expect(formatter.pretty_elapsed_time).not_to include("minutes")
+    expect(formatter.pretty_elapsed_time).not_to include("hours")
+  end
+
+  it "prints minutes and seconds when elapsed time is more than 60 seconds" do
+    @now = Time.now
+    allow(Time).to receive(:now).and_return(@now, @now + 610.0)
+    formatter.run_completed(nil)
+    expect(formatter.elapsed_time).to eql(610.0)
+    expect(formatter.pretty_elapsed_time).to include("10 minutes 10 seconds")
+    expect(formatter.pretty_elapsed_time).not_to include("hours")
+  end
+
+  it "prints hours, minutes and seconds when elapsed time is more than 3600 seconds" do
+    @now = Time.now
+    allow(Time).to receive(:now).and_return(@now, @now + 36610.0)
+    formatter.run_completed(nil)
+    expect(formatter.elapsed_time).to eql(36610.0)
+    expect(formatter.pretty_elapsed_time).to include("10 hours 10 minutes 10 seconds")
+  end
 end