chef 10.34.6 → 11.0.0.beta.0

data/spec/functional/resource/remote_directory_spec.rb

@@ -22,12 +22,15 @@ describe Chef::Resource::RemoteDirectory do
   include_context Chef::Resource::Directory
 
   let(:directory_base) { "directory_spec" }
+  let(:default_mode) { "755" }
 
   def create_resource
     cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
     Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, cookbook_repo) }
     node = Chef::Node.new
-    cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(cookbook_repo))
+    cl = Chef::CookbookLoader.new(cookbook_repo)
+    cl.load_cookbooks
+    cookbook_collection = Chef::CookbookCollection.new(cl)
     events = Chef::EventDispatch::Dispatcher.new
     run_context = Chef::RunContext.new(node, cookbook_collection, events)
 
@@ -37,57 +40,90 @@ describe Chef::Resource::RemoteDirectory do
     resource
   end
 
+  def create_extraneous_files
+    FileUtils.mkdir_p(File.join(path, 'remotesubdir'))
+    @existing1 = File.join(path, 'marked_for_death.txt')
+    @existing2 = File.join(path, 'remotesubdir', 'marked_for_death_again.txt')
+    FileUtils.touch(@existing1)
+    FileUtils.touch(@existing2)
+  end
+
   let!(:resource) do
     create_resource
   end
 
+  let(:resource_second_pass) do
+    create_resource
+  end
+
+  # See spec/data/cookbooks/openldap/files/default
+  let(:expected_files) do
+    [
+      File.join(path, 'remote_dir_file1.txt'),
+      File.join(path, 'remote_dir_file2.txt'),
+      File.join(path, 'remotesubdir', 'remote_subdir_file1.txt'),
+      File.join(path, 'remotesubdir', 'remote_subdir_file2.txt'),
+      File.join(path, 'remotesubdir', '.a_dotfile'),
+      File.join(path, '.a_dotdir', '.a_dotfile_in_a_dotdir')
+    ]
+  end
+
   it_behaves_like "a directory resource"
 
-  context "when creating the remote directory" do
-    it "transfers the directory with all contents" do
-      resource.run_action(:create)
-      File.should exist(File.join(path, 'remote_dir_file1.txt'))
-      File.should exist(File.join(path, 'remote_dir_file2.txt'))
-      File.should exist(File.join(path, 'remotesubdir', 'remote_subdir_file1.txt'))
-      File.should exist(File.join(path, 'remotesubdir', 'remote_subdir_file2.txt'))
-      File.should exist(File.join(path, 'remotesubdir', '.a_dotfile'))
-      File.should exist(File.join(path, '.a_dotdir', '.a_dotfile_in_a_dotdir'))
-    end
+  it_behaves_like "a securable resource with reporting"
 
-    context "with purging enabled" do
-      before(:each) do
-        resource.purge(true)
+  context "when creating the remote directory with purging disabled" do
+
+    context "and the directory does not yet exist" do
+      before do
+        resource.run_action(:create)
       end
 
-      it "removes existing files if purge is true" do
-        FileUtils.mkdir_p(File.join(path, 'remotesubdir'))
-        existing1 = File.join(path, 'marked_for_death.txt')
-        existing2 = File.join(path, 'remotesubdir', 'marked_for_death_again.txt')
-        FileUtils.touch(existing1)
-        FileUtils.touch(existing2)
+      it "transfers the directory with all contents" do
+        expected_files.each do |file_path|
+          File.should exist(file_path)
+        end
+      end
+
+      it "is marked as updated by last action" do
+        resource.should be_updated_by_last_action
+      end
+    end
 
+    context "and there are extraneous files in the directory" do
+      before do
+        create_extraneous_files
         resource.run_action(:create)
-        File.should_not exist(existing1)
-        File.should_not exist(existing2)
       end
 
-      it "removes files in subdirectories before files above" do
-        FileUtils.mkdir_p(File.join(path, 'a', 'multiply', 'nested', 'directory'))
-        existing1 = File.join(path, 'a', 'foo.txt')
-        existing2 = File.join(path, 'a', 'multiply', 'bar.txt')
-        existing3 = File.join(path, 'a', 'multiply', 'nested', 'baz.txt')
-        existing4 = File.join(path, 'a', 'multiply', 'nested', 'directory', 'qux.txt')
-        FileUtils.touch(existing1)
-        FileUtils.touch(existing2)
-        FileUtils.touch(existing3)
-        FileUtils.touch(existing4)
+      it "does not modify the expected state of the directory" do
+        expected_files.each do |file_path|
+          File.should exist(file_path)
+        end
+      end
 
+      it "does not remove unmanaged files" do
+        File.should exist(@existing1)
+        File.should exist(@existing2)
+      end
+    end
+
+    context "and the directory is in the desired state" do
+      before do
         resource.run_action(:create)
-        File.should_not exist(existing1)
-        File.should_not exist(existing2)
-        File.should_not exist(existing3)
-        File.should_not exist(existing4)
+        resource_second_pass.run_action(:create)
       end
+
+      it "does not modify the expected state of the directory" do
+        expected_files.each do |file_path|
+          File.should exist(file_path)
+        end
+      end
+
+      it "is not marked as updated by last action" do
+        resource_second_pass.should_not be_updated_by_last_action
+      end
+
     end
 
     describe "with overwrite disabled" do
@@ -111,4 +147,74 @@ describe Chef::Resource::RemoteDirectory do
       end
     end
   end
+
+  context "when creating the directory with purging enabled" do
+    before(:each) do
+      resource.purge(true)
+    end
+
+    context "and there are no extraneous files in the directory" do
+      before do
+        resource.run_action(:create)
+      end
+
+      it "creates the directory contents as normal" do
+        expected_files.each do |file_path|
+          File.should exist(file_path)
+        end
+      end
+
+    end
+
+    context "and there are extraneous files in the directory" do
+      before do
+        create_extraneous_files
+        resource.run_action(:create)
+      end
+
+      it "removes unmanaged files" do
+        File.should_not exist(@existing1)
+        File.should_not exist(@existing2)
+      end
+
+      it "does not modify managed files" do
+        expected_files.each do |file_path|
+          File.should exist(file_path)
+        end
+      end
+
+      it "is marked as updated by last action" do
+        resource.should be_updated_by_last_action
+      end
+    end
+
+    context "and there are deeply nested extraneous files in the directory" do
+      before do
+        FileUtils.mkdir_p(File.join(path, 'a', 'multiply', 'nested', 'directory'))
+        @existing1 = File.join(path, 'a', 'foo.txt')
+        @existing2 = File.join(path, 'a', 'multiply', 'bar.txt')
+        @existing3 = File.join(path, 'a', 'multiply', 'nested', 'baz.txt')
+        @existing4 = File.join(path, 'a', 'multiply', 'nested', 'directory', 'qux.txt')
+        FileUtils.touch(@existing1)
+        FileUtils.touch(@existing2)
+        FileUtils.touch(@existing3)
+        FileUtils.touch(@existing4)
+
+        resource.run_action(:create)
+      end
+
+      it "removes files in subdirectories before files above" do
+        File.should_not exist(@existing1)
+        File.should_not exist(@existing2)
+        File.should_not exist(@existing3)
+        File.should_not exist(@existing4)
+      end
+
+      it "is marked as updated by last action" do
+        resource.should be_updated_by_last_action
+      end
+
+    end
+  end
+
 end

data/spec/functional/resource/remote_file_spec.rb

@@ -45,6 +45,22 @@ describe Chef::Resource::RemoteFile do
     create_resource
   end
 
+  let(:default_mode) do
+    # TODO: Lots of ugly here :(
+    # RemoteFile uses FileUtils.cp. FileUtils does a copy by opening the
+    # destination file and writing to it. Before 1.9.3, it does not preserve
+    # the mode of the copied file. In 1.9.3 and after, it does. So we have to
+    # figure out what the default mode ought to be via heuristic.
+
+    t = Tempfile.new("get-the-mode")
+    path = t.path
+    path_2 = t.path + "fileutils-mode-test"
+    FileUtils.cp(path, path_2)
+    t.close
+    m = File.stat(path_2).mode
+    (07777 & m).to_s(8)
+  end
+
   before(:all) do
     @server = TinyServer::Manager.new
     @server.start
@@ -62,4 +78,6 @@ describe Chef::Resource::RemoteFile do
   end
 
   it_behaves_like "a file resource"
+
+  it_behaves_like "a securable resource with reporting"
 end

data/spec/functional/resource/template_spec.rb

@@ -27,14 +27,16 @@ describe Chef::Resource::Template do
 
   let(:node) do
     node = Chef::Node.new
-    node[:slappiness] = "a warm gun"
+    node.normal[:slappiness] = "a warm gun"
     node
   end
 
   def create_resource
     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))
+    cl = Chef::CookbookLoader.new(cookbook_repo)
+    cl.load_cookbooks
+    cookbook_collection = Chef::CookbookCollection.new(cl)
     events = Chef::EventDispatch::Dispatcher.new
     run_context = Chef::RunContext.new(node, cookbook_collection, events)
     resource = Chef::Resource::Template.new(path, run_context)
@@ -47,8 +49,27 @@ describe Chef::Resource::Template do
     create_resource
   end
 
+  let(:default_mode) do
+    # TODO: Lots of ugly here :(
+    # RemoteFile uses FileUtils.cp. FileUtils does a copy by opening the
+    # destination file and writing to it. Before 1.9.3, it does not preserve
+    # the mode of the copied file. In 1.9.3 and after, it does. So we have to
+    # figure out what the default mode ought to be via heuristic.
+
+    t = Tempfile.new("get-the-mode")
+    path = t.path
+    path_2 = t.path + "fileutils-mode-test"
+    FileUtils.cp(path, path_2)
+    t.close
+    m = File.stat(path_2).mode
+    (07777 & m).to_s(8)
+  end
+
+
   it_behaves_like "a file resource"
 
+  it_behaves_like "a securable resource with reporting"
+
   context "when the target file does not exist" do
     it "creates the template with the rendered content using the variable attribute when the :create action is run" do
       resource.source('openldap_variable_stuff.conf.erb')

data/spec/functional/run_lock_spec.rb

@@ -0,0 +1,106 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2012 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 File.expand_path('../../spec_helper', __FILE__)
+require 'chef/client'
+
+describe Chef::RunLock do
+
+  # This behavior is believed to work on windows, but the tests use UNIX APIs.
+  describe "when locking the chef-client run", :unix_only => true do
+    let(:random_temp_root) do
+      Kernel.srand(Time.now.to_i + Process.pid)
+      "/tmp/#{Kernel.rand(Time.now.to_i + Process.pid)}"
+    end
+
+    let(:file_cache_path){ "/var/chef/cache" }
+    let(:lockfile){ "#{random_temp_root}/this/long/path/does/not/exist/chef-client-running.pid" }
+
+    after(:each){ FileUtils.rm_r(random_temp_root) }
+
+    it "creates the full path to the lockfile" do
+      run_lock = Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile)
+      lambda { run_lock.acquire }.should_not raise_error(Errno::ENOENT)
+      File.should exist(lockfile)
+    end
+
+    it "allows only one chef client run per lockfile" do
+      read, write = IO.pipe
+      run_lock = Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile)
+      p1 = fork do
+        run_lock.acquire
+        write.puts 1
+        #puts "[#{Time.new.to_i % 100}] p1 (#{Process.pid}) running with lock"
+        sleep 2
+        write.puts 2
+        #puts "[#{Time.new.to_i % 100}] p1 (#{Process.pid}) releasing lock"
+        run_lock.release
+      end
+
+      sleep 0.5
+
+      p2 = fork do
+        run_lock.acquire
+        write.puts 3
+        #puts "[#{Time.new.to_i % 100}] p2 (#{Process.pid}) running with lock"
+        run_lock.release
+      end
+
+      Process.waitpid2(p1)
+      Process.waitpid2(p2)
+
+      write.close
+      order = read.read
+      read.close
+
+      order.should == "1\n2\n3\n"
+    end
+
+    it "clears the lock if the process dies unexpectedly" do
+      read, write = IO.pipe
+      run_lock = Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile)
+      p1 = fork do
+        run_lock.acquire
+        write.puts 1
+        #puts "[#{Time.new.to_i % 100}] p1 (#{Process.pid}) running with lock"
+        sleep 1
+        write.puts 2
+        #puts "[#{Time.new.to_i % 100}] p1 (#{Process.pid}) releasing lock"
+        run_lock.release
+      end
+
+      p2 = fork do
+        run_lock.acquire
+        write.puts 3
+        #puts "[#{Time.new.to_i % 100}] p2 (#{Process.pid}) running with lock"
+        run_lock.release
+      end
+      Process.kill(:KILL, p1)
+
+      Process.waitpid2(p1)
+      Process.waitpid2(p2)
+
+      write.close
+      order = read.read
+      read.close
+
+      order.should =~ /3\Z/
+    end
+  end
+
+end
+

data/spec/functional/shell_spec.rb

@@ -0,0 +1,100 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2012 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 'chef/version'
+
+describe Chef::Shell do
+
+  # chef-shell's unit tests are by necessity very mock-heavy, and frequently do
+  # not catch cases where chef-shell fails to boot because of changes in
+  # chef/client.rb
+  describe "smoke tests", :unix_only => true do
+
+    def read_until(io, expected_value)
+      start = Time.new
+      buffer = ""
+      until buffer.include?(expected_value)
+        begin
+          buffer << io.read_nonblock(1)
+        rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EIO, EOFError
+        end
+        if Time.new - start > 15
+          STDERR.puts "did not read expected value `#{expected_value}' within 15s"
+          STDERR.puts "Buffer so far: `#{buffer}'"
+          break
+        end
+      end
+      buffer
+    end
+
+    def wait_or_die(pid)
+      start = Time.new
+
+      until exitstatus = Process.waitpid2(pid, Process::WNOHANG)
+        if Time.new - start > 5
+          STDERR.puts("chef-shell tty did not exit cleanly, killing it")
+          Process.kill(:KILL, pid)
+        end
+        sleep 0.1
+      end
+      exitstatus[1]
+    end
+
+    def run_chef_shell_with(options)
+      # Windows ruby installs don't (always?) have PTY,
+      # so hide the require here
+      require 'pty'
+      config = File.expand_path("chef-config.rb", CHEF_SPEC_DATA)
+      path_to_chef_shell = File.expand_path("../../../bin/chef-shell", __FILE__)
+      reader, writer, pid = PTY.spawn("#{path_to_chef_shell} -c #{config} #{options}")
+      read_until(reader, "chef >")
+      yield reader, writer if block_given?
+      writer.puts('"done"')
+      output = read_until(reader, '=> "done"')
+      writer.print("exit\n")
+      read_until(reader, "exit")
+      read_until(reader, "exit")
+      read_until(reader, "\n")
+      writer.close
+
+      exitstatus = wait_or_die(pid)
+
+      [output, exitstatus]
+    rescue PTY::ChildExited => e
+      [output, e.status]
+    end
+
+    it "boots correctly with -lauto" do
+      output, exitstatus = run_chef_shell_with("-lauto")
+      exitstatus.should be_success
+    end
+
+    it "sets the log_level from the command line" do
+      output, exitstatus = run_chef_shell_with("-lfatal") do |out, keyboard|
+        show_log_level_code = %q[puts "===#{Chef::Log.level}==="]
+        keyboard.puts(show_log_level_code)
+        read_until(out, show_log_level_code)
+      end
+      output.should include("===fatal===")
+      exitstatus.should be_success
+    end
+
+  end
+
+end