microwave 1.0.4 → 11.400.2

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

@@ -24,7 +24,13 @@ describe Chef::Resource::RemoteFile do
 
   let(:file_base) { "remote_file_spec" }
   let(:source) { 'http://localhost:9000/nyan_cat.png' }
-  let(:expected_content) { IO.read(File.join(CHEF_SPEC_DATA, 'remote_file', 'nyan_cat.png')) }
+  let(:expected_content) do
+    content = File.open(File.join(CHEF_SPEC_DATA, 'remote_file', 'nyan_cat.png'), "rb") do |f|
+      f.read
+    end
+    content.force_encoding(Encoding::BINARY) if content.respond_to?(:force_encoding)
+    content
+  end
 
   def create_resource
     node = Chef::Node.new
@@ -39,14 +45,31 @@ 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
-    Thin::Logging.silent = false
     @server = TinyServer::Manager.new
     @server.start
     @api = TinyServer::API.instance
     @api.clear
     @api.get("/nyan_cat.png", 200) {
-      IO.read(File.join(CHEF_SPEC_DATA, 'remote_file', 'nyan_cat.png'))
+      File.open(File.join(CHEF_SPEC_DATA, 'remote_file', 'nyan_cat.png'), "rb") do |f|
+        f.read
+      end
     }
   end
 
@@ -55,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,238 @@
+#
+# 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
+
+    ##
+    # Lockfile location and helpers
+
+    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" }
+
+    # make sure to start with a clean slate.
+    before(:each){ FileUtils.rm_r(random_temp_root) if File.exist?(random_temp_root) }
+    after(:each){ FileUtils.rm_r(random_temp_root) }
+
+    def wait_on_lock
+      tries = 0
+      until File.exist?(lockfile)
+        raise "Lockfile never created, abandoning test" if tries > 10
+        tries += 1
+        sleep 0.1
+      end
+    end
+
+    ##
+    # Side channel via a pipe allows child processes to send errors to the parent
+
+    # Don't lazy create the pipe or else we might not share it with subprocesses
+    let!(:error_pipe) do
+      r,w = IO.pipe
+      w.sync = true
+      [r,w]
+    end
+
+    let(:error_read) { error_pipe[0] }
+    let(:error_write) { error_pipe[1] }
+
+    after do
+      error_read.close unless error_read.closed?
+      error_write.close unless error_write.closed?
+    end
+
+    # Send a RuntimeError from the child process to the parent process. Also
+    # prints error to $stdout, just in case something goes wrong with the error
+    # marshaling stuff.
+    def send_side_channel_error(message)
+      $stderr.puts(message)
+      $stderr.puts(caller)
+      e = RuntimeError.new(message)
+      error_write.print(Marshal.dump(e))
+    end
+
+    # Read the error (if any) from the error channel. If a marhaled error is
+    # present, it is unmarshaled and raised (which will fail the test)
+    def raise_side_channel_error!
+      error_write.close
+      err = error_read.read
+      error_read.close
+      begin
+        # ArgumentError from Marshal.load indicates no data, which we assume
+        # means no error in child process.
+        raise Marshal.load(err)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    ##
+    # Interprocess synchronization via a pipe. This allows us to control the
+    # state of the processes competing over the lock without relying on sleep.
+
+    let!(:sync_pipe) do
+      r,w = IO.pipe
+      w.sync = true
+      [r,w]
+    end
+    let(:sync_read) { sync_pipe[0] }
+    let(:sync_write) { sync_pipe[1] }
+
+    after do
+      sync_read.close unless sync_read.closed?
+      sync_write.close unless sync_write.closed?
+    end
+
+    # Wait on synchronization signal. If not received within the timeout, an
+    # error is sent via the error channel, and the process exits.
+    def sync_wait
+      if IO.select([sync_read], nil, nil, 20).nil?
+        # timeout reading from the sync pipe.
+        send_side_channel_error("Error syncing processes in run lock test (timeout)")
+        exit!(1)
+      else
+        sync_read.getc
+      end
+    end
+
+    # Sends a character in the sync pipe, which wakes ("unlocks") another
+    # process that is waiting on the sync signal
+    def sync_send
+      sync_write.putc("!")
+      sync_write.flush
+    end
+
+    ##
+    # IPC to record test results in a pipe. Tests can read pipe contents to
+    # check that operations occur in the expected order.
+
+    let!(:results_pipe) do
+      r,w = IO.pipe
+      w.sync = true
+      [r,w]
+    end
+    let(:results_read) { results_pipe[0] }
+    let(:results_write) { results_pipe[1] }
+
+    after do
+      results_read.close unless results_read.closed?
+      results_write.close unless results_write.closed?
+    end
+
+    # writes the message to the results pipe for later checking.
+    # note that nothing accounts for the pipe filling and waiting forever on a
+    # read or write call, so don't put too much data in.
+    def record(message)
+      results_write.puts(message)
+      results_write.flush
+    end
+
+    def results
+      results_write.flush
+      results_write.close
+      message = results_read.read
+      results_read.close
+      message
+    end
+
+    ##
+    # Run lock is the system under test
+    let!(:run_lock) { Chef::RunLock.new(:file_cache_path => file_cache_path, :lockfile => lockfile) }
+
+    it "creates the full path to the lockfile" do
+      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
+      # First process, gets the lock and keeps it.
+      p1 = fork do
+        run_lock.acquire
+        record "p1 has lock"
+        # Wait until the other process is trying to get the lock:
+        sync_wait
+        # sleep a little bit to make process p2 wait on the lock
+        sleep 2
+        record "p1 releasing lock"
+        run_lock.release
+        exit!(0)
+      end
+
+      # Wait until p1 creates the lockfile
+      wait_on_lock
+
+      p2 = fork do
+        # inform process p1 that we're trying to get the lock
+        sync_send
+        run_lock.acquire
+        record "p2 has lock"
+        run_lock.release
+        exit!(0)
+      end
+
+      Process.waitpid2(p1)
+      Process.waitpid2(p2)
+
+      raise_side_channel_error!
+
+      expected=<<-E
+p1 has lock
+p1 releasing lock
+p2 has lock
+E
+      results.should == expected
+    end
+
+    it "clears the lock if the process dies unexpectedly" do
+      p1 = fork do
+        run_lock.acquire
+        record "p1 has lock"
+        sleep 60
+        record "p1 still has lock"
+        exit! 1
+      end
+
+      wait_on_lock
+      Process.kill(:KILL, p1)
+      Process.waitpid2(p1)
+
+
+      p2 = fork do
+        run_lock.acquire
+        record "p2 has lock"
+        run_lock.release
+        exit! 0
+      end
+
+      Process.waitpid2(p2)
+
+      results.should =~ /p2 has lock\Z/
+    end
+  end
+
+end
+