chef 11.4.4 → 11.6.0.hotfix.1

data/spec/unit/resource_spec.rb

@@ -459,7 +459,6 @@ describe Chef::Resource do
   end
 
   describe "when invoking its action" do
-
     before do
       @resource = Chef::Resource.new("provided", @run_context)
       @resource.provider = Chef::Provider::SnakeOil
@@ -529,6 +528,114 @@ describe Chef::Resource do
 
   end
 
+  describe "should_skip?" do
+    before do
+      @resource = Chef::Resource::Cat.new("sugar", @run_context)
+    end
+
+    it "should return false by default" do
+      @resource.should_skip?(:purr).should be_false
+    end
+
+    it "should return false when if_only is met" do
+      @resource.only_if { true }
+      @resource.should_skip?(:purr).should be_false
+    end
+
+    it "should return true when if_only is not met" do
+      @resource.only_if { false }
+      @resource.should_skip?(:purr).should be_true
+    end
+
+    it "should return true when not_if is met" do
+      @resource.not_if { true }
+      @resource.should_skip?(:purr).should be_true
+    end
+
+    it "should return false when if_only is not met" do
+      @resource.not_if { false }
+      @resource.should_skip?(:purr).should be_false
+    end
+
+    it "should return true when if_only is met but also not_if is met" do
+      @resource.only_if { true }
+      @resource.not_if { true }
+      @resource.should_skip?(:purr).should be_true
+    end
+
+    it "should return true when one of multiple if_only's is not met" do
+      @resource.only_if { true }
+      @resource.only_if { false }
+      @resource.only_if { true }
+      @resource.should_skip?(:purr).should be_true
+    end
+
+    it "should return true when one of multiple not_if's is met" do
+      @resource.not_if { false }
+      @resource.not_if { true }
+      @resource.not_if { false }
+      @resource.should_skip?(:purr).should be_true
+    end
+
+    it "should return true when action is :nothing" do
+      @resource.should_skip?(:nothing).should be_true
+    end
+
+    it "should return true when action is :nothing ignoring only_if/not_if conditionals" do
+      @resource.only_if { true }
+      @resource.not_if { false }
+      @resource.should_skip?(:nothing).should be_true
+    end
+
+    it "should print \"skipped due to action :nothing\" message for doc formatter when action is :nothing" do
+      fdoc = Chef::Formatters.new(:doc, STDOUT, STDERR)
+      @run_context.stub!(:events).and_return(fdoc)
+      fdoc.should_receive(:puts).with(" (skipped due to action :nothing)")
+      @resource.should_skip?(:nothing)
+    end
+
+  end
+
+  describe "when resource action is :nothing" do
+    before do
+      @resource1 = Chef::Resource::Cat.new("sugar", @run_context)
+      @resource1.action = :nothing
+
+      @node.automatic_attrs[:platform] = "fubuntu"
+      @node.automatic_attrs[:platform_version] = '10.04'
+    end
+
+    it "should not run only_if/not_if conditionals (CHEF-972)" do
+      snitch_var1 = 0
+      @resource1.only_if { snitch_var1 = 1 }
+      @resource1.not_if { snitch_var1 = 2 }
+      @resource1.run_action(:nothing)
+      snitch_var1.should == 0
+    end
+
+    it "should run only_if/not_if conditionals when notified to run another action (CHEF-972)" do
+      snitch_var1 = snitch_var2 = 0
+      @runner = Chef::Runner.new(@run_context)
+      Chef::Platform.set(
+        :resource => :cat,
+        :provider => Chef::Provider::SnakeOil
+      )
+
+      @resource1.only_if { snitch_var1 = 1 }
+      @resource1.not_if { snitch_var2 = 2 }
+      @resource2 = Chef::Resource::Cat.new("coffee", @run_context)
+      @resource2.notifies :purr, @resource1
+      @resource2.action = :purr
+
+      @run_context.resource_collection << @resource1
+      @run_context.resource_collection << @resource2
+      @runner.converge
+
+      snitch_var1.should == 1
+      snitch_var2.should == 2
+    end
+  end
+
   describe "building the platform map" do
 
     it 'adds mappings for a single platform' do
@@ -590,6 +697,68 @@ describe Chef::Resource do
     end
 
   end
+
+  describe "when creating notifications" do
+
+    describe "with a string resource spec" do
+
+      it "creates a delayed notification when timing is not specified" do
+        @resource.notifies(:run, "execute[foo]")
+        @run_context.delayed_notification_collection.should have(1).notifications
+      end
+
+      it "creates a delayed notification when :delayed is not specified" do
+        @resource.notifies(:run, "execute[foo]", :delayed)
+        @run_context.delayed_notification_collection.should have(1).notifications
+      end
+
+      it "creates an immediate notification when :immediate is specified" do
+        @resource.notifies(:run, "execute[foo]", :immediate)
+        @run_context.immediate_notification_collection.should have(1).notifications
+      end
+
+      it "creates an immediate notification when :immediately is specified" do
+        @resource.notifies(:run, "execute[foo]", :immediately)
+        @run_context.immediate_notification_collection.should have(1).notifications
+      end
+
+      describe "with a syntax error in the resource spec" do
+
+        it "raises an exception immmediately" do
+          lambda do
+            @resource.notifies(:run, "typo[missing-closing-bracket")
+          end.should raise_error(Chef::Exceptions::InvalidResourceSpecification)
+        end
+      end
+    end
+
+    describe "with a resource reference" do
+      before do
+        @notified_resource = Chef::Resource.new("punk", @run_context)
+      end
+
+      it "creates a delayed notification when timing is not specified" do
+        @resource.notifies(:run, @notified_resource)
+        @run_context.delayed_notification_collection.should have(1).notifications
+      end
+
+      it "creates a delayed notification when :delayed is not specified" do
+        @resource.notifies(:run, @notified_resource, :delayed)
+        @run_context.delayed_notification_collection.should have(1).notifications
+      end
+
+      it "creates an immediate notification when :immediate is specified" do
+        @resource.notifies(:run, @notified_resource, :immediate)
+        @run_context.immediate_notification_collection.should have(1).notifications
+      end
+
+      it "creates an immediate notification when :immediately is specified" do
+        @resource.notifies(:run, @notified_resource, :immediately)
+        @run_context.immediate_notification_collection.should have(1).notifications
+      end
+    end
+
+  end
 end
 
 describe Chef::Resource::Notification do

data/spec/unit/rest/auth_credentials_spec.rb

@@ -298,7 +298,7 @@ describe Chef::REST::RESTRequest do
         Chef::Config[:http_proxy]  = "http://proxy.example.com:3128"
         Chef::Config[:https_proxy] = "http://sproxy.example.com:3129"
         Chef::Config[:http_proxy_user] = nil
-        Chef::Config[:https_proxy_pass] = nil
+        Chef::Config[:http_proxy_pass] = nil
         Chef::Config[:https_proxy_user] = nil
         Chef::Config[:https_proxy_pass] = nil
         Chef::Config[:no_proxy] = nil
@@ -308,7 +308,7 @@ describe Chef::REST::RESTRequest do
         Chef::Config[:http_proxy]  = nil
         Chef::Config[:https_proxy] = nil
         Chef::Config[:http_proxy_user] = nil
-        Chef::Config[:https_proxy_pass] = nil
+        Chef::Config[:http_proxy_pass] = nil
         Chef::Config[:https_proxy_user] = nil
         Chef::Config[:https_proxy_pass] = nil
         Chef::Config[:no_proxy] = nil

data/spec/unit/rest_spec.rb

@@ -347,8 +347,12 @@ describe Chef::REST do
           @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
 
           lambda { @rest.api_request(:GET, @url) }.should raise_error(Chef::Exceptions::RedirectLimitExceeded)
+
+          [:PUT, :POST, :DELETE].each do |method|
+            lambda { @rest.api_request(method, @url) }.should raise_error(Chef::Exceptions::InvalidRedirect)
+          end
         end
-       end
+      end
 
       it "should return `false` when response is 304 NotModified" do
         http_response = Net::HTTPNotModified.new("1.1", "304", "it's the same as when you asked 5 minutes ago")
@@ -493,7 +497,7 @@ describe Chef::REST do
 
       it "closes and unlinks the tempfile when the response is a redirect" do
         Tempfile.rspec_reset
-        tempfile = mock("die", :path => "/tmp/ragefist", :close => true, :binmode => nil)
+        tempfile = mock("die", :path => "/tmp/ragefist", :close => true, :binmode => true)
         tempfile.should_receive(:close!).at_least(2).times
         Tempfile.stub!(:new).with("chef-rest").and_return(tempfile)
 

data/spec/unit/run_context/cookbook_compiler_spec.rb

@@ -178,4 +178,13 @@ describe Chef::RunContext::CookbookCompiler do
     # Tests for this behavior are in RunContext's tests
   end
 
+  describe "listing cookbook order" do 
+    it "should return an array of cookbook names as symbols without duplicates" do
+      node.run_list("test-with-circular-deps::default", "circular-dep1::default", "circular-dep2::default")
+
+      compiler.cookbook_order.should == [:"circular-dep2",
+                                         :"circular-dep1",
+                                         :"test-with-circular-deps"]
+    end
+  end
 end

data/spec/unit/runner_spec.rb

@@ -360,7 +360,7 @@ E
   end
 
   it "should check a resource's only_if and not_if if notified by another resource" do
-    @first_resource.action = :nothing
+    @first_resource.action = :buy
 
     only_if_called_times = 0
     @first_resource.only_if {only_if_called_times += 1; true}

data/spec/unit/scan_access_control_spec.rb

@@ -21,7 +21,8 @@ require 'chef/scan_access_control'
 describe Chef::ScanAccessControl do
 
   before do
-    @new_resource = Chef::Resource::File.new("/tmp/foo/bar/baz/qux")
+    @new_resource = Chef::Resource::File.new("/tmp/foo/bar/baz/link")
+    @real_file = "/tmp/foo/bar/real/file"
     @current_resource = Chef::Resource::File.new(@new_resource.path)
     @scanner = Chef::ScanAccessControl.new(@new_resource, @current_resource)
   end
@@ -49,7 +50,8 @@ describe Chef::ScanAccessControl do
 
     before do
       @stat = mock("File::Stat for #{@new_resource.path}", :uid => 0, :gid => 0, :mode => 00100644)
-      File.should_receive(:stat).with(@new_resource.path).and_return(@stat)
+      File.should_receive(:realpath).with(@new_resource.path).and_return(@real_file)
+      File.should_receive(:stat).with(@real_file).and_return(@stat)
       File.should_receive(:exist?).with(@new_resource.path).and_return(true)
     end
 

data/spec/unit/shell/shell_session_spec.rb

@@ -47,6 +47,19 @@ describe Shell::ShellSession do
 
 end
 
+describe Shell::ClientSession do
+  it "builds the node's run_context with the proper environment" do
+    @session = Shell::ClientSession.instance
+    @node = Chef::Node.build("foo")
+    @session.node = @node
+    @session.instance_variable_set(:@client, stub(:sync_cookbooks => {}))
+    @expansion = Chef::RunList::RunListExpansion.new(@node.chef_environment, [])
+
+    @node.run_list.should_receive(:expand).with(@node.chef_environment).and_return(@expansion)
+    @session.rebuild_context
+  end
+end
+
 describe Shell::StandAloneSession do
   before do
     @session = Shell::StandAloneSession.instance
@@ -109,7 +122,7 @@ describe Shell::SoloSession do
     @session.resource_collection.should include(kitteh)
   end
 
-  it "returns definitions from it's compilation object" do
+  it "returns definitions from its compilation object" do
     @session.definitions.should == @run_context.definitions
   end
 
@@ -119,7 +132,7 @@ describe Shell::SoloSession do
     #pending "1) keep attribs in an ivar 2) pass them to the node 3) feed them to the node on reset"
   end
 
-  it "generates it's resource collection from the compiled cookbooks and the ad hoc recipe" do
+  it "generates its resource collection from the compiled cookbooks and the ad hoc recipe" do
     @session.stub!(:node_built?).and_return(true)
     kitteh_cat = Chef::Resource::Cat.new("kitteh")
     @run_context.resource_collection << kitteh_cat

data/spec/unit/util/backup_spec.rb

@@ -0,0 +1,149 @@
+#
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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 'tmpdir'
+
+describe Chef::Util::Backup do
+  before(:all) do
+    @original_config = Chef::Config.configuration
+  end
+
+  after(:all) do
+    Chef::Config.configuration.replace(@original_config)
+  end
+
+  let (:tempfile) do
+    Tempfile.new("chef-util-backup-spec-test")
+  end
+
+  before(:each) do
+    @new_resource = mock("new_resource")
+    @new_resource.should_receive(:path).at_least(:once).and_return(tempfile.path)
+    @backup = Chef::Util::Backup.new(@new_resource)
+  end
+
+  it "should store the resource passed to new as new_resource" do
+    @backup.new_resource.should eql(@new_resource)
+  end
+
+  describe "for cases when we don't want to back anything up" do
+
+    before(:each) do
+      @backup.should_not_receive(:do_backup)
+    end
+
+    it "should not attempt to backup a file if :backup is false" do
+      @new_resource.should_receive(:backup).at_least(:once).and_return(false)
+      @backup.backup!
+    end
+
+    it "should not attempt to backup a file if :backup == 0" do
+      @new_resource.should_receive(:backup).at_least(:once).and_return(0)
+      @backup.backup!
+    end
+
+    it "should not attempt to backup a file if it does not exist" do
+      @new_resource.should_receive(:backup).at_least(:once).and_return(1)
+      File.should_receive(:exist?).with(tempfile.path).at_least(:once).and_return(false)
+      @backup.backup!
+    end
+
+  end
+
+  describe "for cases when we want to back things up" do
+    before(:each) do
+      @backup.should_receive(:do_backup)
+    end
+
+    describe "when the number of backups is specified as 1" do
+      before(:each) do
+        @new_resource.should_receive(:backup).at_least(:once).and_return(1)
+      end
+
+      it "should not delete anything if this is the only backup" do
+        @backup.should_receive(:sorted_backup_files).and_return(['a'])
+        @backup.should_not_receive(:delete_backup)
+        @backup.backup!
+      end
+
+      it "should keep only 1 backup copy" do
+        @backup.should_receive(:sorted_backup_files).and_return(['a', 'b', 'c'])
+        @backup.should_receive(:delete_backup).with('b')
+        @backup.should_receive(:delete_backup).with('c')
+        @backup.backup!
+      end
+    end
+
+    describe "when the number of backups is specified as 2" do
+      before(:each) do
+        @new_resource.should_receive(:backup).at_least(:once).and_return(2)
+      end
+
+      it "should not delete anything if we only have one other backup" do
+        @backup.should_receive(:sorted_backup_files).and_return(['a', 'b'])
+        @backup.should_not_receive(:delete_backup)
+        @backup.backup!
+      end
+
+      it "should keep only 2 backup copies" do
+        @backup.should_receive(:sorted_backup_files).and_return(['a', 'b', 'c', 'd'])
+        @backup.should_receive(:delete_backup).with('c')
+        @backup.should_receive(:delete_backup).with('d')
+        @backup.backup!
+      end
+    end
+  end
+
+  describe "backup_filename" do
+    it "should return a timestamped path" do
+      @backup.should_receive(:path).and_return('/a/b/c.txt')
+      @backup.send(:backup_filename).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+    end
+    it "should strip the drive letter off for windows" do
+      @backup.should_receive(:path).and_return('c:\a\b\c.txt')
+      @backup.send(:backup_filename).should =~ %r|^\\a\\b\\c.txt.chef-\d{14}$|
+    end
+    it "should strip the drive letter off for windows (with forwardslashes)" do
+      @backup.should_receive(:path).and_return('c:/a/b/c.txt')
+      @backup.send(:backup_filename).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+    end
+  end
+
+  describe "backup_path" do
+    it "uses the file's directory when Chef::Config[:file_backup_path] is nil" do
+      @backup.should_receive(:path).and_return('/a/b/c.txt')
+      Chef::Config[:file_backup_path] = nil
+      @backup.send(:backup_path).should =~ %r|^/a/b/c.txt.chef-\d{14}$|
+    end
+
+    it "uses the configured Chef::Config[:file_backup_path]" do
+      @backup.should_receive(:path).and_return('/a/b/c.txt')
+      Chef::Config[:file_backup_path] = '/backupdir'
+      @backup.send(:backup_path).should =~ %r|^/backupdir[\\/]+a/b/c.txt.chef-\d{14}$|
+    end
+
+    it "uses the configured Chef::Config[:file_backup_path] and strips the drive on windows" do
+      @backup.should_receive(:path).and_return('c:\\a\\b\\c.txt')
+      Chef::Config[:file_backup_path] = 'c:\backupdir'
+      @backup.send(:backup_path).should =~ %r|^c:\\backupdir[\\/]+a\\b\\c.txt.chef-\d{14}$|
+    end
+  end
+
+end