chef 11.4.4 → 11.6.0.hotfix.1

data/spec/functional/knife/exec_spec.rb

@@ -46,12 +46,12 @@ describe Chef::Knife::Exec do
 
   pending "executes a script in the context of the chef-shell main context", :ruby_18_only
 
-  it "executes a script in the context of the chef-shell main context", :ruby_19_only do
+  it "executes a script in the context of the chef-shell main context", :ruby_gte_19_only do
     @node = Chef::Node.new
     @node.name("ohai-world")
     response = {"rows" => [@node],"start" => 0,"total" => 1}
     @api.get(%r{^/search/node}, 200, response.to_json)
-    code = "$output.puts nodes.all.inspect"
+    code = "$output.puts nodes.all"
     @knife.config[:exec] = code
     @knife.run
     $output.string.should match(%r{node\[ohai-world\]})

data/spec/functional/provider/remote_file/cache_control_data_spec.rb

@@ -0,0 +1,101 @@
+#
+# Author:: Adam Edwards (<adamed@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 'uri'
+
+describe Chef::Provider::RemoteFile::CacheControlData do
+
+  before do
+    @original_config = Chef::Config.hash_dup    
+  end
+
+  after do
+    Chef::Config.configuration = @original_config if @original_config    
+  end
+  
+  before(:each) do
+    Chef::Config[:file_cache_path] = Dir.mktmpdir
+  end
+
+  after(:each) do
+    FileUtils.rm_rf(Chef::Config[:file_cache_path])
+  end
+
+  let(:uri) { URI.parse("http://www.bing.com/robots.txt") }
+  
+  describe "when the cache control data save method is invoked" do
+
+    subject(:cache_control_data) do
+      Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
+    end
+
+    # the checksum of the file last we fetched it.
+    let(:file_checksum) { "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" }
+
+    let(:etag) { "\"a-strong-identifier\"" }
+    let(:mtime) { "Thu, 01 Aug 2013 08:16:32 GMT" }
+
+    before do
+      cache_control_data.etag = etag
+      cache_control_data.mtime = mtime
+      cache_control_data.checksum = file_checksum
+    end
+
+    it "writes data to the cache" do
+      cache_control_data.save
+    end
+
+    it "writes the data to the cache and the same data can be read back" do
+      cache_control_data.save
+      saved_cache_control_data = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
+      saved_cache_control_data.etag.should == cache_control_data.etag
+      saved_cache_control_data.mtime.should == cache_control_data.mtime
+      saved_cache_control_data.checksum.should == cache_control_data.checksum  
+    end
+
+    # Cover the very long remote file path case -- see CHEF-4422 where
+    # local cache file names generated from the long uri exceeded
+    # local file system path limits resulting in exceptions from
+    # file system API's on both Windows and Unix systems.
+    context "when the length of the uri exceeds the path length limits for the local file system" do
+      let(:uri_exceeds_file_system_limit) do
+        URI.parse("http://www.bing.com/" + ('0' * 1024))
+      end
+
+      let(:uri) { uri_exceeds_file_system_limit }
+
+      it "writes data to the cache" do
+        lambda do
+          cache_control_data.save
+        end.should_not raise_error
+      end
+
+      it "writes the data to the cache and the same data can be read back" do
+        cache_control_data.save
+        saved_cache_control_data = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
+        saved_cache_control_data.etag.should == cache_control_data.etag
+        saved_cache_control_data.mtime.should == cache_control_data.mtime
+        saved_cache_control_data.checksum.should == cache_control_data.checksum  
+      end
+
+    end
+  end
+
+end
+

data/spec/functional/resource/batch_spec.rb

@@ -0,0 +1,64 @@
+#
+# Author:: Adam Edwards (<adamed@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'
+
+shared_context Chef::Resource::WindowsScript do
+  before(:all) do
+
+    ohai_reader = Ohai::System.new
+    ohai_reader.require_plugin("os")    
+    ohai_reader.require_plugin("windows::platform")
+
+    new_node = Chef::Node.new
+    new_node.consume_external_attrs(ohai_reader.data,{})
+    
+    events = Chef::EventDispatch::Dispatcher.new
+    
+    @run_context = Chef::RunContext.new(new_node, {}, events)
+  end
+
+  let(:script_output_path) do
+    File.join(Dir.tmpdir, make_tmpname("windows_script_test"))
+  end
+
+  before(:each) do
+k    File.delete(script_output_path) if File.exists?(script_output_path)    
+  end
+
+  after(:each) do
+    File.delete(script_output_path) if File.exists?(script_output_path)
+  end
+end
+
+describe Chef::Resource::WindowsScript::Batch, :windows_only do
+  let(:script_content) { "whoami" }
+
+  let!(:resource) do
+    Chef::Resource::WindowsScript::Batch.new("Batch resource functional test", @run_context)
+  end
+
+  context "when the run action is invoked on Windows" do
+    include_context Chef::Resource::WindowsScript    
+    it "executes the script code" do
+      resource.code(script_content + " > #{script_output_path}")
+      resource.returns(0)
+      resource.run_action(:run)
+    end
+  end  
+end

data/spec/functional/resource/cookbook_file_spec.rb

@@ -32,7 +32,7 @@ describe Chef::Resource::CookbookFile do
     content
   end
 
-  let(:default_mode) { "600" }
+  let(:default_mode) { ((0100666 - File.umask) & 07777).to_s(8) }
 
   it_behaves_like "a securable resource with reporting"
 
@@ -55,7 +55,7 @@ describe Chef::Resource::CookbookFile do
     resource
   end
 
-  let!(:resource) do
+  let(:resource) do
     create_resource
   end
 
@@ -77,6 +77,5 @@ describe Chef::Resource::CookbookFile do
       FileUtils.rm_r(windows_non_temp_dir) if Chef::Platform.windows? && File.exists?(windows_non_temp_dir)
     end
 
-    it_behaves_like "a file that inherits permissions from a parent directory"
   end
 end

data/spec/functional/resource/deploy_revision_spec.rb

@@ -30,6 +30,7 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
   let(:observe_order_file) { Tempfile.new("deploy-resource-observe-operations") }
 
   before do
+    Chef::Log.level = :info
     @old_file_cache_path = Chef::Config[:file_cache_path]
     Chef::Config[:file_cache_path] = file_cache_path
   end
@@ -276,6 +277,11 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       it "is marked updated" do
         deploy_to_previous_rev.should be_updated_by_last_action
       end
+
+      it "leaves the old copy of the app around for rollback" do
+        File.should exist(File.join(deploy_directory, "releases", previous_rev))
+      end
+
     end
 
     describe "back to a previously deployed revision (implicit rollback)" do
@@ -510,6 +516,180 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       lambda { deploy_with_in_repo_symlinks.run_action(:deploy) }.should_not raise_error
     end
   end
+
+  context "when a previously deployed application has been nuked" do
+
+    shared_examples_for "a redeployed application" do
+
+      it "should redeploy the application" do
+        File.should be_directory(rel_path("releases"))
+        File.should be_directory(rel_path("shared"))
+        File.should be_directory(rel_path("releases/#{latest_rev}"))
+
+        File.should be_directory(rel_path("current/tmp"))
+        File.should be_directory(rel_path("current/config"))
+        File.should be_directory(rel_path("current/public"))
+
+        File.should be_symlink(rel_path("current"))
+        File.readlink(rel_path("current")).should == rel_path("releases/#{latest_rev}")
+      end
+    end
+
+    # background: If a deployment is hosed and the user decides to rm -rf the
+    # deployment dir, deploy resource should detect that and nullify its cache.
+
+    context "by removing the entire deploy directory" do
+
+      before do
+        deploy_to_latest_rev.dup.run_action(:deploy)
+        FileUtils.rm_rf(deploy_directory)
+        deploy_to_latest_rev.dup.run_action(:deploy)
+      end
+
+      include_examples "a redeployed application"
+
+    end
+
+    context "by removing the current/ directory" do
+
+      before do
+        deploy_to_latest_rev.dup.run_action(:deploy)
+        FileUtils.rm(rel_path("current"))
+        deploy_to_latest_rev.dup.run_action(:deploy)
+      end
+
+      include_examples "a redeployed application"
+
+    end
+  end
+
+  context "when a deployment fails" do
+
+    shared_examples_for "a recovered deployment" do
+
+      it "should redeploy the application" do
+        File.should be_directory(rel_path("releases"))
+        File.should be_directory(rel_path("shared"))
+        File.should be_directory(rel_path("releases/#{latest_rev}"))
+
+        File.should be_directory(rel_path("current/tmp"))
+        File.should be_directory(rel_path("current/config"))
+        File.should be_directory(rel_path("current/public"))
+
+        File.should be_symlink(rel_path("current"))
+        File.readlink(rel_path("current")).should == rel_path("releases/#{latest_rev}")
+
+        # if callbacks ran, we know the app was deployed and not merely rolled
+        # back to a (busted) prior deployment.
+        callback_order.should == [:before_migrate,
+                                  :before_symlink,
+                                  :before_restart,
+                                  :after_restart ]
+      end
+    end
+
+    let!(:callback_order) { [] }
+
+    let(:deploy_to_latest_with_callback_tracking) do
+      resource = deploy_to_latest_rev.dup
+      tracker = callback_order
+      resource.before_migrate { tracker << :before_migrate }
+      resource.before_symlink { tracker << :before_symlink }
+      resource.before_restart { tracker << :before_restart }
+      resource.after_restart  { tracker << :after_restart }
+      resource
+    end
+
+    [:before_migrate, :before_symlink, :before_restart, :after_restart].each do |callback|
+
+      context "in the `#{callback}' callback" do
+        before do
+          lambda { deploy_that_fails.run_action(:deploy) }.should raise_error(Exception, %r{I am a failed deploy})
+          deploy_to_latest_with_callback_tracking.run_action(:deploy)
+        end
+
+
+        let(:deploy_that_fails) do
+          resource = deploy_to_latest_rev.dup
+          errant_callback = lambda {|x| raise Exception, "I am a failed deploy" }
+          resource.send(callback, &errant_callback)
+          resource
+        end
+
+        include_examples "a recovered deployment"
+
+      end
+
+    end
+
+    context "in the service restart step" do
+
+      let(:deploy_that_fails) do
+        resource = deploy_to_latest_rev.dup
+        resource.restart_command("RUBYOPT=\"\" ruby -e 'exit 1'")
+        resource
+      end
+
+      before do
+        lambda { deploy_that_fails.run_action(:deploy) }.should raise_error(Chef::Exceptions::Exec)
+        deploy_to_latest_with_callback_tracking.run_action(:deploy)
+      end
+
+      include_examples "a recovered deployment"
+    end
+
+    context "when cloning the app code" do
+
+      class BadTimeScmProvider
+        def initialize(new_resource, run_context)
+        end
+
+        def load_current_resource
+        end
+
+        def revision_slug
+          "5"
+        end
+
+        def run_action(action)
+          raise RuntimeError, "network error"
+        end
+      end
+
+      let(:deploy_that_fails) do
+        resource = deploy_to_latest_rev.dup
+        resource.scm_provider(BadTimeScmProvider)
+        resource
+      end
+
+      before do
+        lambda { deploy_that_fails.run_action(:deploy) }.should raise_error(RuntimeError, /network error/)
+        deploy_to_latest_with_callback_tracking.run_action(:deploy)
+      end
+
+      include_examples "a recovered deployment"
+    end
+
+    context "and then is deployed to a different revision" do
+
+      let(:deploy_that_fails) do
+        resource = deploy_to_previous_rev.dup
+        resource.after_restart {|x| raise Exception, "I am a failed deploy" }
+        resource
+      end
+
+      before do
+        lambda { deploy_that_fails.run_action(:deploy) }.should raise_error(Exception, %r{I am a failed deploy})
+        deploy_to_latest_rev.run_action(:deploy)
+      end
+
+      it "removes the unsuccessful deploy after a later successful deploy" do
+        ::File.should_not exist(File.join(deploy_directory, "releases", previous_rev))
+      end
+
+    end
+
+  end
 end
 
 

data/spec/functional/resource/directory_spec.rb

@@ -23,7 +23,7 @@ describe Chef::Resource::Directory do
 
   let(:directory_base) { "directory_spec" }
 
-  let(:default_mode) { "755" }
+  let(:default_mode) { ((0100777 - File.umask) & 07777).to_s(8) }
 
   def create_resource
     events = Chef::EventDispatch::Dispatcher.new
@@ -32,7 +32,7 @@ describe Chef::Resource::Directory do
     Chef::Resource::Directory.new(path, run_context)
   end
 
-  let!(:resource) do
+  let(:resource) do
   	create_resource
   end
 

data/spec/functional/resource/file_spec.rb

@@ -32,7 +32,7 @@ describe Chef::Resource::File do
     resource
   end
 
-  let!(:resource) do
+  let(:resource) do
     r = create_resource
     r.content(expected_content)
     r
@@ -58,6 +58,22 @@ describe Chef::Resource::File do
 
   it_behaves_like "a securable resource with reporting"
 
+  describe "when running action :create without content" do
+    before do
+      resource_without_content.run_action(:create)
+    end
+
+    context "and the target file does not exist" do
+      it "creates the file" do
+        File.should exist(path)
+      end
+
+      it "is marked updated by last action" do
+        resource_without_content.should be_updated_by_last_action
+      end
+    end
+  end
+
   describe "when running action :touch" do
     context "and the target file does not exist" do
       before do