chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

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,12 +32,18 @@ describe Chef::Resource::CookbookFile do
     content
   end
 
+  let(:default_mode) { ((0100666 - File.umask) & 07777).to_s(8) }
+
+  it_behaves_like "a securable resource with reporting"
+
   def create_resource
     # set up cookbook collection for this run to use, based on our
     # spec data.
     cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, 'cookbooks'))
     Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, cookbook_repo) }
-    cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(cookbook_repo))
+    loader = Chef::CookbookLoader.new(cookbook_repo)
+    loader.load_cookbooks
+    cookbook_collection = Chef::CookbookCollection.new(loader)
 
     node = Chef::Node.new
     events = Chef::EventDispatch::Dispatcher.new
@@ -49,27 +55,27 @@ describe Chef::Resource::CookbookFile do
     resource
   end
 
-  let!(:resource) do
+  let(:resource) do
     create_resource
   end
 
   it_behaves_like "a file resource"
 
-  # These examples cover CHEF-3467 where unexpected and incorrect 
-  # permissions can result on Windows because CookbookFile's implementation
+  # These examples cover CHEF-3467 where unexpected and incorrect
+  # permissions can result on Windows because CookbookFile's
+  # implementation
   # stages files in temp.
   context "targets a file outside of the system temp directory" do
     let(:windows_non_temp_dir) { File.join(ENV['systemdrive'], make_tmpname(file_base, "non-temp")) }
-    let(:path) { File.join(windows_non_temp_dir, make_tmpname(file_base, nil)) }
+    let(:path) { File.join(windows_non_temp_dir, make_tmpname(file_base)) }
 
     before do
       FileUtils::mkdir_p(windows_non_temp_dir) if Chef::Platform.windows?
     end
 
     after 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"
+      FileUtils.rm_r(windows_non_temp_dir) if Chef::Platform.windows? && File.exists?(windows_non_temp_dir)
+    end
+
   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,6 +23,8 @@ describe Chef::Resource::Directory do
 
   let(:directory_base) { "directory_spec" }
 
+  let(:default_mode) { ((0100777 - File.umask) & 07777).to_s(8) }
+
   def create_resource
     events = Chef::EventDispatch::Dispatcher.new
     node = Chef::Node.new
@@ -30,10 +32,12 @@ describe Chef::Resource::Directory do
     Chef::Resource::Directory.new(path, run_context)
   end
 
-  let!(:resource) do
+  let(:resource) do
   	create_resource
   end
 
   it_behaves_like "a directory resource"
 
+  it_behaves_like "a securable resource with reporting"
+
 end

data/spec/functional/resource/file_spec.rb

@@ -29,41 +29,91 @@ describe Chef::Resource::File do
     node = Chef::Node.new
     run_context = Chef::RunContext.new(node, {}, events)
     resource = Chef::Resource::File.new(path, run_context)
-    resource.content(expected_content)
     resource
   end
 
-  let!(:resource) do
+  let(:resource) do
+    r = create_resource
+    r.content(expected_content)
+    r
+  end
+
+  let(:resource_without_content) do
     create_resource
   end
 
+  let(:unmanaged_content) do
+    "This is file content that is not managed by chef"
+  end
+
+  let(:current_resource) do
+    provider = resource.provider_for_action(resource.action)
+    provider.load_current_resource
+    provider.current_resource
+  end
+
+  let(:default_mode) { ((0100666 - File.umask) & 07777).to_s(8) }
+
   it_behaves_like "a file resource"
 
-  context "when the target file does not exist" do
-    it "it creates the file when the :touch action is run" do
-      resource.run_action(:touch)
-      File.should exist(path)
+  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
-  end
 
-  context "when the target file has the correct content" do
-    before(:each) do
-      File.open(path, "w") { |f| f.print expected_content }
+    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
+        resource.run_action(:touch)
+      end
+
+      it "it creates the file" do
+        File.should exist(path)
+      end
 
-    it "updates the mtime/atime of the file when the :touch action is run" do
-      expected_mtime = File.stat(path).mtime
-      expected_atime = File.stat(path).atime
-      sleep 1
-      resource.run_action(:touch)
-      File.stat(path).mtime.should > expected_mtime
-      File.stat(path).atime.should > expected_atime
+      it "is marked updated by last action" do
+        resource.should be_updated_by_last_action
+      end
     end
 
-    it "does not change the content when :touch action is run" do
-      expected_checksum = sha256_checksum(path)
-      resource.run_action(:touch)
-      sha256_checksum(path).should == expected_checksum
+    context "and the target file exists and has the correct content" do
+      before(:each) do
+        File.open(path, "w") { |f| f.print expected_content }
+
+        @expected_checksum = sha256_checksum(path)
+
+        now = Time.now.to_i
+        File.utime(now - 9000, now - 9000, path)
+        @expected_mtime = File.stat(path).mtime
+
+        resource.run_action(:touch)
+      end
+
+      it "updates the mtime of the file" do
+        File.stat(path).mtime.should > @expected_mtime
+      end
+
+      it "does not change the content" do
+        sha256_checksum(path).should == @expected_checksum
+      end
+
+      it "is marked as updated by last action" do
+        resource.should be_updated_by_last_action
+      end
     end
   end
+
 end