chef 12.0.3 → 12.1.0.rc.0

data/spec/functional/audit/runner_spec.rb

@@ -0,0 +1,137 @@
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright (c) 2014 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 'rspec/core/sandbox'
+require 'chef/audit/runner'
+require 'rspec/support/spec/in_sub_process'
+require 'rspec/support/spec/stderr_splitter'
+require 'tempfile'
+
+##
+# This functional test ensures that our runner can be setup to not interfere with existing RSpec
+# configuration and world objects.  When normally running Chef, there is only 1 RSpec instance
+# so this isn't needed.  In unit testing the Runner should be mocked appropriately.
+
+describe Chef::Audit::Runner do
+
+  # The functional tests must be run in a sub_process.  Including Serverspec includes the Serverspec DSL - this
+  # conflicts with our `package` DSL (among others) when we try to test `package` inside an RSpec example.
+  # Our DSL leverages `method_missing` while the Serverspec DSL defines a method on the RSpec::Core::ExampleGroup.
+  # The defined method wins our and returns before our `method_missing` DSL can be called.
+  #
+  # Running in a sub_process means the serverspec libraries will only be included in a forked process, not the main one.
+  include RSpec::Support::InSubProcess
+
+  let(:events) { double("events").as_null_object }
+  let(:runner) { Chef::Audit::Runner.new(run_context) }
+  let(:stdout) { StringIO.new }
+
+  around(:each) do |ex|
+    RSpec::Core::Sandbox.sandboxed { ex.run }
+  end
+
+  before do
+    Chef::Config[:log_location] = stdout
+  end
+  
+  describe "#run" do
+
+    let(:audits) { {} }
+    let(:run_context) { instance_double(Chef::RunContext, :events => events, :audits => audits) }
+    let(:control_group_name) { "control_group_name" }
+
+    it "Correctly runs an empty controls block" do
+      in_sub_process do
+        runner.run
+      end
+    end
+
+    shared_context "passing audit" do
+      let(:audits) do
+        should_pass = lambda do
+          it "should pass" do
+            expect(2 - 2).to eq(0)
+          end
+        end
+        { control_group_name => Struct.new(:args, :block).new([control_group_name], should_pass)}
+      end
+    end
+
+    shared_context "failing audit" do
+      let(:audits) do
+        should_fail = lambda do
+          it "should fail" do
+            expect(2 - 1).to eq(0)
+          end
+        end
+        { control_group_name => Struct.new(:args, :block).new([control_group_name], should_fail)}
+      end
+    end
+
+    context "there is a single successful control" do
+      include_context "passing audit"
+      it "correctly runs" do
+        in_sub_process do
+          runner.run
+
+          expect(stdout.string).to match(/1 example, 0 failures/)
+        end
+      end
+    end
+
+    context "there is a single failing control" do
+      include_context "failing audit"
+      it "correctly runs" do
+        in_sub_process do
+          runner.run
+
+          expect(stdout.string).to match(/Failure\/Error: expect\(2 - 1\)\.to eq\(0\)/)
+          expect(stdout.string).to match(/1 example, 1 failure/)
+          expect(stdout.string).to match(/# control_group_name should fail/)
+        end
+      end
+    end
+
+    describe "log location is a file" do
+      let(:tmpfile) { Tempfile.new("audit") }
+      before do
+        Chef::Config[:log_location] = tmpfile.path
+      end
+
+      after do
+        tmpfile.close
+        tmpfile.unlink
+      end
+
+      include_context "failing audit"
+      it "correctly runs" do
+        in_sub_process do
+          runner.run
+
+          contents = tmpfile.read
+          expect(contents).to match(/Failure\/Error: expect\(2 - 1\)\.to eq\(0\)/)
+          expect(contents).to match(/1 example, 1 failure/)
+          expect(contents).to match(/# control_group_name should fail/)
+        end
+      end
+    end
+
+  end
+
+end

data/spec/functional/dsl/reboot_pending_spec.rb

@@ -48,18 +48,18 @@ describe Chef::DSL::RebootPending, :windows_only do
 
     describe "when there is nothing to indicate a reboot is pending" do
       it "should return false" do
-        pending "Found existing registry keys" if registry_unsafe?
-        expect(recipe.reboot_pending?).to be_false
+        skip "Found existing registry keys" if registry_unsafe?
+        expect(recipe.reboot_pending?).to be_falsey
       end
     end
 
     describe 'HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations' do
       it "returns true if the registry value exists" do
-        pending "Found existing registry keys" if registry_unsafe?
+        skip "Found existing registry keys" if registry_unsafe?
         registry.set_value('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager',
             { :name => 'PendingFileRenameOperations', :type => :multi_string, :data => ['\??\C:\foo.txt|\??\C:\bar.txt'] })
 
-        expect(recipe.reboot_pending?).to be_true
+        expect(recipe.reboot_pending?).to be_truthy
       end
 
       after do
@@ -71,10 +71,10 @@ describe Chef::DSL::RebootPending, :windows_only do
 
     describe 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired' do
       it "returns true if the registry key exists" do
-        pending "Found existing registry keys" if registry_unsafe?
+        skip "Found existing registry keys" if registry_unsafe?
         registry.create_key('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired', false)
 
-        expect(recipe.reboot_pending?).to be_true
+        expect(recipe.reboot_pending?).to be_truthy
       end
 
       after do
@@ -87,10 +87,10 @@ describe Chef::DSL::RebootPending, :windows_only do
     describe 'HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired' do
       it "returns true if the registry key exists" do
         pending "Permissions are limited to 'TrustedInstaller' by default"
-        pending "Found existing registry keys" if registry_unsafe?
+        skip "Found existing registry keys" if registry_unsafe?
         registry.create_key('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired', false)
 
-        expect(recipe.reboot_pending?).to be_true
+        expect(recipe.reboot_pending?).to be_truthy
       end
 
       after do
@@ -102,12 +102,12 @@ describe Chef::DSL::RebootPending, :windows_only do
 
     describe 'HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile\Flags' do
       it "returns true if the registry key exists" do
-        pending "Found existing registry keys" if registry_unsafe?
+        skip "Found existing registry keys" if registry_unsafe?
         registry.create_key('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile', true)
         registry.set_value('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile',
                     { :name => 'Flags', :type => :dword, :data => 3 })
 
-        expect(recipe.reboot_pending?).to be_true
+        expect(recipe.reboot_pending?).to be_truthy
       end
 
       after do

data/spec/functional/dsl/registry_helper_spec.rb

@@ -40,24 +40,24 @@ describe Chef::Resource::RegistryKey, :windows_only do
 
   context "tests registry dsl" do
     it "returns true if registry_key_exists" do
-      @resource.registry_key_exists?("HKCU\\Software\\Root").should == true
+      expect(@resource.registry_key_exists?("HKCU\\Software\\Root")).to eq(true)
     end
     it "returns true if registry has specified value" do
       values = @resource.registry_get_values("HKCU\\Software\\Root")
-      values.include?({:name=>"RootType1",:type=>:string,:data=>"fibrous"}).should == true
+      expect(values.include?({:name=>"RootType1",:type=>:string,:data=>"fibrous"})).to eq(true)
     end
     it "returns true if specified registry_has_subkey" do
-      @resource.registry_has_subkeys?("HKCU\\Software\\Root").should == true
+      expect(@resource.registry_has_subkeys?("HKCU\\Software\\Root")).to eq(true)
     end
     it "returns true if specified key has specified subkey" do
       subkeys = @resource.registry_get_subkeys("HKCU\\Software\\Root")
-      subkeys.include?("Branch").should == true
+      expect(subkeys.include?("Branch")).to eq(true)
     end
     it "returns true if registry_value_exists" do
-      @resource.registry_value_exists?("HKCU\\Software\\Root", {:name=>"RootType1", :type=>:string, :data=>"fibrous"}).should == true
+      expect(@resource.registry_value_exists?("HKCU\\Software\\Root", {:name=>"RootType1", :type=>:string, :data=>"fibrous"})).to eq(true)
     end
     it "returns true if data_value_exists" do
-      @resource.registry_data_exists?("HKCU\\Software\\Root", {:name=>"RootType1", :type=>:string, :data=>"fibrous"}).should == true
+      expect(@resource.registry_data_exists?("HKCU\\Software\\Root", {:name=>"RootType1", :type=>:string, :data=>"fibrous"})).to eq(true)
     end
   end
 end

data/spec/functional/event_loggers/windows_eventlog_spec.rb

@@ -37,21 +37,21 @@ describe Chef::EventLoggers::WindowsEventLogger, :windows_only, :not_supported_o
   let(:mock_exception) { double('Exception', {message: SecureRandom.uuid, backtrace:[SecureRandom.uuid, SecureRandom.uuid]})}
 
   it 'is available' do
-    Chef::EventLoggers::WindowsEventLogger.available?.should be_true
+    expect(Chef::EventLoggers::WindowsEventLogger.available?).to be_truthy
   end
 
   it 'writes run_start event with event_id 10000 and contains version' do
     logger.run_start(version)
 
     expect(event_log.read(flags, offset).any? { |e| e.source == 'Chef' && e.event_id == 10000 &&
-                                               e.string_inserts[0].include?(version)}).to be_true
+                                               e.string_inserts[0].include?(version)}).to be_truthy
   end
 
   it 'writes run_started event with event_id 10001 and contains the run_id' do
     logger.run_started(run_status)
 
     expect(event_log.read(flags, offset).any? { |e| e.source == 'Chef' && e.event_id == 10001 &&
-                                               e.string_inserts[0].include?(run_id)}).to be_true
+                                               e.string_inserts[0].include?(run_id)}).to be_truthy
   end
 
   it 'writes run_completed event with event_id 10002 and contains the run_id and elapsed time' do
@@ -61,7 +61,7 @@ describe Chef::EventLoggers::WindowsEventLogger, :windows_only, :not_supported_o
     expect(event_log.read(flags, offset).any? { |e| e.source == 'Chef' && e.event_id == 10002 &&
                                                 e.string_inserts[0].include?(run_id) &&
                                                 e.string_inserts[1].include?(elapsed_time.to_s)
-    }).to be_true
+    }).to be_truthy
   end
 
   it 'writes run_failed event with event_id 10003 and contains the run_id, elapsed time, and exception info' do
@@ -76,7 +76,7 @@ describe Chef::EventLoggers::WindowsEventLogger, :windows_only, :not_supported_o
         e.string_inserts[3].include?(mock_exception.message) &&
         e.string_inserts[4].include?(mock_exception.backtrace[0]) &&
         e.string_inserts[4].include?(mock_exception.backtrace[1])
-    end).to be_true
+    end).to be_truthy
   end
 
 end

data/spec/functional/file_content_management/deploy_strategies_spec.rb

@@ -20,15 +20,6 @@ require 'spec_helper'
 
 shared_examples_for "a content deploy strategy" do
 
-  # Ruby 1.8 has no binread
-  def binread(file)
-    if IO.respond_to?(:binread)
-      IO.binread(file)
-    else
-      IO.read(file)
-    end
-  end
-
   def normalize_mode(mode_int)
     ( mode_int & 07777).to_s(8)
   end
@@ -56,11 +47,11 @@ shared_examples_for "a content deploy strategy" do
 
     it "touches the file to create it (UNIX)", :unix_only do
       content_deployer.create(target_file_path)
-      File.should exist(target_file_path)
+      expect(File).to exist(target_file_path)
       file_info = File.stat(target_file_path)
-      file_info.should be_owned
-      file_info.should be_file
-      normalize_mode(file_info.mode).should == default_mode
+      expect(file_info).to be_owned
+      expect(file_info).to be_file
+      expect(normalize_mode(file_info.mode)).to eq(default_mode)
     end
 
     ##
@@ -89,10 +80,10 @@ shared_examples_for "a content deploy strategy" do
 
     it "touches the file to create it (Windows)", :windows_only do
       content_deployer.create(target_file_path)
-      File.should exist(target_file_path)
+      expect(File).to exist(target_file_path)
       file_info = File.stat(target_file_path)
-      file_info.should be_owned
-      file_info.should be_file
+      expect(file_info).to be_owned
+      expect(file_info).to be_file
 
       parent_aces = parent_inheritable_aces
       security_obj = Chef::ReservedNames::Win32::Security::SecurableObject.new(target_file_path)
@@ -106,7 +97,7 @@ shared_examples_for "a content deploy strategy" do
       end
 
       self_aces.each_with_index do |ace, index|
-        ace.mask.should == parent_aces[index].mask
+        expect(ace.mask).to eq(parent_aces[index].mask)
       end
     end
   end
@@ -147,7 +138,7 @@ shared_examples_for "a content deploy strategy" do
       content_deployer.deploy(staging_file_path, target_file_path)
       updated_info = File.stat(target_file_path)
 
-      unix_invariant_properies(original_info).should == unix_invariant_properies(updated_info)
+      expect(unix_invariant_properies(original_info)).to eq(unix_invariant_properies(updated_info))
     end
 
     it "maintains invariant properties on Windows", :windows_only do
@@ -155,12 +146,12 @@ shared_examples_for "a content deploy strategy" do
       content_deployer.deploy(staging_file_path, target_file_path)
       updated_info = Chef::ReservedNames::Win32::Security::SecurableObject.new(target_file_path)
 
-      win_invariant_properties(original_info).should == win_invariant_properties(updated_info)
+      expect(win_invariant_properties(original_info)).to eq(win_invariant_properties(updated_info))
     end
 
     it "updates the target with content from staged" do
       content_deployer.deploy(staging_file_path, target_file_path)
-      binread(target_file_path).should == staging_file_content
+      expect(IO.binread(target_file_path)).to eq(staging_file_content)
     end
 
     context "when the owner of the target file is not the owner of the staging file", :requires_root do
@@ -174,7 +165,7 @@ shared_examples_for "a content deploy strategy" do
         content_deployer.deploy(staging_file_path, target_file_path)
         updated_info = File.stat(target_file_path)
 
-        unix_invariant_properies(original_info).should == unix_invariant_properies(updated_info)
+        expect(unix_invariant_properies(original_info)).to eq(unix_invariant_properies(updated_info))
       end
 
     end

data/spec/functional/http/simple_spec.rb

@@ -85,7 +85,7 @@ describe Chef::HTTP::Simple do
     before do
       Chef::Log.level = :debug
       @debug_log = ''
-      Chef::Log.stub(:debug) { |str| @debug_log << str }
+      allow(Chef::Log).to receive(:debug) { |str| @debug_log << str }
     end
 
     let(:source) { 'http://localhost:9000' }

data/spec/functional/knife/cookbook_delete_spec.rb

@@ -51,9 +51,9 @@ describe Chef::Knife::CookbookDelete do
     end
 
     it "logs an error and exits" do
-      @knife.ui.stub(:stderr).and_return(@log_output)
-      lambda {@knife.run}.should raise_error(SystemExit)
-      @log_output.string.should match(/Cannot find a cookbook named no-such-cookbook to delete/)
+      allow(@knife.ui).to receive(:stderr).and_return(@log_output)
+      expect {@knife.run}.to raise_error(SystemExit)
+      expect(@log_output.string).to match(/Cannot find a cookbook named no-such-cookbook to delete/)
     end
 
   end
@@ -67,33 +67,33 @@ describe Chef::Knife::CookbookDelete do
 
     it "asks for confirmation, then deletes the cookbook" do
       stdin, stdout = StringIO.new("y\n"), StringIO.new
-      @knife.ui.stub(:stdin).and_return(stdin)
-      @knife.ui.stub(:stdout).and_return(stdout)
+      allow(@knife.ui).to receive(:stdin).and_return(stdin)
+      allow(@knife.ui).to receive(:stdout).and_return(stdout)
 
       cb100_deleted = false
       @api.delete("/cookbooks/obsolete-cookbook/1.0.0", 200) { cb100_deleted = true; "[\"true\"]" }
 
       @knife.run
 
-      stdout.string.should match(/#{Regexp.escape('Do you really want to delete obsolete-cookbook version 1.0.0? (Y/N)')}/)
-      cb100_deleted.should be_true
+      expect(stdout.string).to match(/#{Regexp.escape('Do you really want to delete obsolete-cookbook version 1.0.0? (Y/N)')}/)
+      expect(cb100_deleted).to be_truthy
     end
 
     it "asks for confirmation before purging" do
       @knife.config[:purge] = true
 
       stdin, stdout = StringIO.new("y\ny\n"), StringIO.new
-      @knife.ui.stub(:stdin).and_return(stdin)
-      @knife.ui.stub(:stdout).and_return(stdout)
+      allow(@knife.ui).to receive(:stdin).and_return(stdin)
+      allow(@knife.ui).to receive(:stdout).and_return(stdout)
 
       cb100_deleted = false
       @api.delete("/cookbooks/obsolete-cookbook/1.0.0?purge=true", 200) { cb100_deleted = true; "[\"true\"]" }
 
       @knife.run
 
-      stdout.string.should match(/#{Regexp.escape('Are you sure you want to purge files')}/)
-      stdout.string.should match(/#{Regexp.escape('Do you really want to delete obsolete-cookbook version 1.0.0? (Y/N)')}/)
-      cb100_deleted.should be_true
+      expect(stdout.string).to match(/#{Regexp.escape('Are you sure you want to purge files')}/)
+      expect(stdout.string).to match(/#{Regexp.escape('Do you really want to delete obsolete-cookbook version 1.0.0? (Y/N)')}/)
+      expect(cb100_deleted).to be_truthy
 
     end
 
@@ -117,22 +117,22 @@ describe Chef::Knife::CookbookDelete do
       @api.delete("/cookbooks/obsolete-cookbook/1.2.0", 200) { cb120_deleted = true; "[\"true\"]" }
       @knife.run
 
-      cb100_deleted.should be_true
-      cb110_deleted.should be_true
-      cb120_deleted.should be_true
+      expect(cb100_deleted).to be_truthy
+      expect(cb110_deleted).to be_truthy
+      expect(cb120_deleted).to be_truthy
     end
 
     it "asks which version to delete and deletes that when not given the -a flag" do
       cb100_deleted = cb110_deleted = cb120_deleted = nil
       @api.delete("/cookbooks/obsolete-cookbook/1.0.0", 200) { cb100_deleted = true; "[\"true\"]" }
       stdin, stdout = StringIO.new, StringIO.new
-      @knife.ui.stub(:stdin).and_return(stdin)
-      @knife.ui.stub(:stdout).and_return(stdout)
+      allow(@knife.ui).to receive(:stdin).and_return(stdin)
+      allow(@knife.ui).to receive(:stdout).and_return(stdout)
       stdin << "1\n"
       stdin.rewind
       @knife.run
-      cb100_deleted.should be_true
-      stdout.string.should match(/Which version\(s\) do you want to delete\?/)
+      expect(cb100_deleted).to be_truthy
+      expect(stdout.string).to match(/Which version\(s\) do you want to delete\?/)
     end
 
     it "deletes all versions of the cookbook when not given the -a flag and the user chooses to delete all" do
@@ -142,14 +142,14 @@ describe Chef::Knife::CookbookDelete do
       @api.delete("/cookbooks/obsolete-cookbook/1.2.0", 200) { cb120_deleted = true; "[\"true\"]" }
 
       stdin, stdout = StringIO.new("4\n"), StringIO.new
-      @knife.ui.stub(:stdin).and_return(stdin)
-      @knife.ui.stub(:stdout).and_return(stdout)
+      allow(@knife.ui).to receive(:stdin).and_return(stdin)
+      allow(@knife.ui).to receive(:stdout).and_return(stdout)
 
       @knife.run
 
-      cb100_deleted.should be_true
-      cb110_deleted.should be_true
-      cb120_deleted.should be_true
+      expect(cb100_deleted).to be_truthy
+      expect(cb110_deleted).to be_truthy
+      expect(cb120_deleted).to be_truthy
     end
 
   end