microwave 1.0.4 → 11.400.2

data/spec/functional/win32/security_spec.rb

@@ -0,0 +1,37 @@
+#
+# Author:: Serdar Sutay (<serdar@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'
+if Chef::Platform.windows?
+  require 'chef/win32/security'
+end
+
+describe 'Chef::Win32::Security', :windows_only do
+  it "has_admin_privileges? returns true when running as admin" do
+    Chef::ReservedNames::Win32::Security.has_admin_privileges?.should == true
+  end
+
+  # We've done some investigation adding a negative test and it turned
+  # out to be a lot of work since mixlib-shellout doesn't have user
+  # support for windows.
+  #
+  # TODO - Add negative tests once mixlib-shellout has user support
+  it "has_admin_privileges? returns false when running as non-admin" do
+    pending "requires user support in mixlib-shellout"
+  end
+end

data/spec/spec_helper.rb

@@ -18,10 +18,14 @@
 # If you need to add anything in here, don't.
 # Add it to one of the files in spec/support
 
-ENV['MICROWAVE_ROOT'] ||= Dir.pwd
+# Configure this first so it doesn't trigger annoying warning when we use it.
+# Main rspec configuration comes later
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
 
 # Abuse ruby's constant lookup to avoid undefined constant errors
-module Shef
+module Shell
   JUST_TESTING_MOVE_ALONG = true unless defined? JUST_TESTING_MOVE_ALONG
   IRB = nil unless defined? IRB
 end
@@ -40,10 +44,11 @@ require 'chef'
 require 'chef/knife'
 Chef::Knife.load_commands
 require 'chef/mixins'
+require 'chef/dsl'
 require 'chef/application'
 require 'chef/applications'
 
-require 'chef/shef'
+require 'chef/shell'
 require 'chef/util/file_edit'
 
 # If you want to load anything into the testing environment
@@ -66,13 +71,20 @@ RSpec.configure do |config|
   config.filter_run :focus => true
   config.filter_run_excluding :external => true
 
+  # Tests that randomly fail, but may have value.
+  config.filter_run_excluding :volatile => true
+
   # Add jruby filters here
   config.filter_run_excluding :windows_only => true unless windows?
+  config.filter_run_excluding :not_supported_on_win2k3 => true if windows_win2k3?
+  config.filter_run_excluding :windows64_only => true unless windows64?
+  config.filter_run_excluding :windows32_only => true unless windows32?
   config.filter_run_excluding :unix_only => true unless unix?
   config.filter_run_excluding :ruby_18_only => true unless ruby_18?
   config.filter_run_excluding :ruby_19_only => true unless ruby_19?
   config.filter_run_excluding :requires_root => true unless ENV['USER'] == 'root'
   config.filter_run_excluding :requires_unprivileged_user => true if ENV['USER'] == 'root'
+  config.filter_run_excluding :uses_diff => true unless has_diff?
 
   config.run_all_when_everything_filtered = true
   config.treat_symbols_as_metadata_keys_with_true_values = true

data/spec/stress/win32/security_spec.rb

@@ -48,19 +48,19 @@ describe 'Chef::ReservedNames::Win32::Security', :windows_only do
     FileUtils.rm_rf(@test_tempdir)
   end
 
-  it "should not leak when retrieving and reading the ACE from a file" do
+  it "should not leak when retrieving and reading the ACE from a file", :volatile do
     lambda {
       sids = Chef::ReservedNames::Win32::Security::SecurableObject.new(@monkeyfoo).security_descriptor.dacl.select { |ace| ace.sid }
       GC.start
     }.should_not leak_memory(:warmup => 50, :iterations => 100)
   end
 
-  it "should not leak when creating a new ACL and setting it on a file" do
+  it "should not leak when creating a new ACL and setting it on a file", :volatile do
     securable_object = Security::SecurableObject.new(@monkeyfoo)
     lambda {
-      securable_object.dacl = Security::ACL.create([
-        Chef::ReservedNames::Win32::Security::ACE.access_allowed(Security::SID.Everyone, Chef::ReservedNames::Win32::API::Security::GENERIC_READ),
-        Chef::ReservedNames::Win32::Security::ACE.access_denied(Security::SID.from_account("Users"), Chef::ReservedNames::Win32::API::Security::GENERIC_ALL)
+      securable_object.dacl = Chef::ReservedNames::Win32::Security::ACL.create([
+        Chef::ReservedNames::Win32::Security::ACE.access_allowed(Chef::ReservedNames::Win32::Security::SID.Everyone, Chef::ReservedNames::Win32::API::Security::GENERIC_READ),
+        Chef::ReservedNames::Win32::Security::ACE.access_denied(Chef::ReservedNames::Win32::Security::SID.from_account("Users"), Chef::ReservedNames::Win32::API::Security::GENERIC_ALL)
       ])
       GC.start
     }.should_not leak_memory(:warmup => 50, :iterations => 100)

data/spec/support/chef_helpers.rb

@@ -17,8 +17,6 @@ CHEF_SPEC_DATA = File.expand_path(File.dirname(__FILE__) + "/../data/")
 CHEF_SPEC_BACKUP_PATH = File.join(Dir.tmpdir, 'test-backup-path')
 
 Chef::Config[:log_level] = :fatal
-Chef::Config[:cache_type] = "Memory"
-Chef::Config[:cache_options] = { }
 Chef::Config[:persistent_queue] = false
 Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
 
@@ -34,7 +32,7 @@ end
 # From Ruby 1.9.2+
 # Here for backwards compatibility with Ruby 1.8.7
 # http://rubydoc.info/stdlib/tmpdir/1.9.2/Dir/Tmpname
-def make_tmpname(prefix_suffix, n)
+def make_tmpname(prefix_suffix, n = nil)
   case prefix_suffix
   when String
     prefix = prefix_suffix
@@ -50,3 +48,16 @@ def make_tmpname(prefix_suffix, n)
   path << "-#{n}" if n
   path << suffix
 end
+
+# NOTE:
+# This is a temporary fix to get tests passing on systems that have no `diff`
+# until we can replace shelling out to `diff` with ruby diff-lcs
+def has_diff?
+  begin
+    diff_cmd = Mixlib::ShellOut.new("diff -v")
+    diff_cmd.run_command
+    true
+  rescue Errno::ENOENT
+    false
+  end
+end

data/spec/support/lib/chef/resource/cat.rb

@@ -29,12 +29,10 @@ class Chef
       end
       
       def pretty_kitty(arg=nil)
-        set_if_args(@pretty_kitty, arg) do
-          case arg
-          when true, false
-            @pretty_kitty = arg
-          end
+        if arg == true or arg == false
+          @pretty_kitty = arg
         end
+        @pretty_kitty
       end
     end
   end

data/spec/support/lib/chef/resource/one_two_three_four.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -20,23 +20,21 @@ class Chef
   class Resource
     class OneTwoThreeFour < Chef::Resource
       attr_reader :i_can_count
-      
+
       def initialize(name, run_context)
         @resource_name = :one_two_three_four
         super
       end
-      
+
       def i_can_count(tf)
         @i_can_count = tf
       end
-      
+
       def something(arg=nil)
-        set_if_args(@something, arg) do
-          case arg
-          when true, false
-            @something = arg
-          end
+        if arg == true or arg == false
+          @something = arg
         end
+        @something
       end
     end
   end

data/spec/support/lib/chef/resource/zen_master.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -23,23 +23,21 @@ class Chef
   class Resource
     class ZenMaster < Chef::Resource
       attr_reader :peace
-      
+
       def initialize(name, run_context=nil)
         @resource_name = :zen_master
         super
       end
-      
+
       def peace(tf)
         @peace = tf
       end
-      
+
       def something(arg=nil)
-        set_if_args(@something, arg) do
-          case arg
-          when true, false
-            @something = arg
-          end
+        if arg == true or arg == false
+          @something = arg
         end
+        @something
       end
     end
   end

data/spec/support/matchers/leak.rb

@@ -60,7 +60,7 @@ module Matchers
     def profiler
       @profiler ||= begin
         if Chef::Platform.windows?
-          require File.join(File.dirname(__FILE__), '..', 'prof', 'win32')
+          require File.join(File.dirname(__FILE__), '..', 'platforms', 'prof', 'win32')
           RSpec::Prof::Win32::Profiler.new
         else
           require File.join(File.dirname(__FILE__), '..', 'prof', 'gc')

data/spec/support/platform_helpers.rb

@@ -10,6 +10,24 @@ def windows?
   !!(RUBY_PLATFORM =~ /mswin|mingw|windows/)
 end
 
+def windows_win2k3?
+  return false unless windows?
+  require 'ruby-wmi'
+
+  host = WMI::Win32_OperatingSystem.find(:first)
+  (host.version && host.version.start_with?("5.2"))
+end
+
+# detects if the hardware is 64-bit (evaluates to true in "WOW64" mode in a 32-bit app on a 64-bit system)
+def windows64?
+  windows? && ( ENV['PROCESSOR_ARCHITECTURE'] == 'AMD64' || ENV['PROCESSOR_ARCHITEW6432'] == 'AMD64' )
+end
+
+# detects if the hardware is 32-bit
+def windows32?
+  windows? && !windows64?
+end
+
 # def jruby?
 
 def unix?

data/spec/support/shared/functional/directory_resource.rb

@@ -17,42 +17,104 @@
 #
 
 shared_examples_for "a directory resource" do
+
+  let(:expect_updated?) {true}
+
   context "when the target directory does not exist" do
-    it "creates the directory when the :create action is run" do
-      resource.run_action(:create)
-      File.should exist(path)
+    before do
+      # assert pre-condition
+      File.should_not exist(path)
     end
 
-    it "recursively creates required directories if requested" do
-      resource.recursive(true)
-      recursive_path = File.join(path, 'red-headed-stepchild')
-      resource.path(recursive_path)
-      resource.run_action(:create)
-      File.should exist(path)
-      File.should exist(recursive_path)
+    describe "when running action :create" do
+      context "and the recursive option is not set" do
+        before do
+          resource.run_action(:create)
+        end
+
+        it "creates the directory when the :create action is run" do
+          File.should exist(path)
+        end
+
+        it "is marked updated by last action" do
+          resource.should be_updated_by_last_action
+        end
+      end
+
+      context "and the recursive option is set" do
+        before do
+          File.should_not exist(path)
+
+          resource.recursive(true)
+          @recursive_path = File.join(path, 'red-headed-stepchild')
+          resource.path(@recursive_path)
+          resource.run_action(:create)
+        end
+
+        it "recursively creates required directories" do
+          File.should exist(path)
+          File.should exist(@recursive_path)
+        end
+
+        it "is marked updated by last action" do
+          resource.should be_updated_by_last_action
+        end
+      end
     end
   end
 
   context "when the target directory exists" do
     before(:each) do
-      FileUtils.mkdir(path)
-    end
+      # For resources such as remote_directory, simply creating the base
+      # directory isn't enough to test that the system is in the desired state,
+      # so we run the resource twice--otherwise the updated_by_last_action test
+      # will fail.
+      resource.dup.run_action(:create)
+      File.should exist(path)
 
-    it "does not re-create the directory" do
       resource.run_action(:create)
-      File.should exist(path)
     end
 
-    it "deletes the directory when the :delete action is run" do
-      resource.run_action(:delete)
-      File.should_not exist(path)
+    describe "when running action :create" do
+      before do
+        resource.run_action(:create)
+      end
+
+      it "does not re-create the directory" do
+        File.should exist(path)
+      end
+
+      it "is not marked updated by last action" do
+        resource.should_not be_updated_by_last_action
+      end
     end
 
-    it "recursively deletes directories if requested" do
-      FileUtils.mkdir(File.join(path, 'red-headed-stepchild'))
-      resource.recursive(true)
-      resource.run_action(:delete)
-      File.should_not exist(path)
+    describe "when running action :delete" do
+      context "without the recursive option" do
+        before do
+          resource.run_action(:delete)
+        end
+
+        it "deletes the directory" do
+          File.should_not exist(path)
+        end
+
+        it "is marked as updated by last action" do
+          resource.should be_updated_by_last_action
+        end
+      end
+
+      context "with the recursive option" do
+        before do
+          FileUtils.mkdir(File.join(path, 'red-headed-stepchild'))
+          resource.recursive(true)
+          resource.run_action(:delete)
+        end
+
+        it "recursively deletes directories" do
+          File.should_not exist(path)
+        end
+      end
     end
   end
 
@@ -76,7 +138,7 @@ end
 
 shared_context Chef::Resource::Directory do
   let(:path) do
-    File.join(Dir.tmpdir, make_tmpname(directory_base, nil))
+    File.join(Dir.tmpdir, make_tmpname(directory_base))
   end
 
   after(:each) do

data/spec/support/shared/functional/file_resource.rb

@@ -17,86 +17,203 @@
 #
 
 shared_examples_for "a file with the wrong content" do
-  it "overwrites the file with the updated content when the :create action is run" do
-    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
-    sleep 1
-    resource.run_action(:create)
-    File.stat(path).mtime.should > @expected_mtime
-    sha256_checksum(path).should_not == @expected_checksum
-  end
-
-  it "doesn't overwrite the file when the :create_if_missing action is run" do
-    sleep 1
-    resource.run_action(:create_if_missing)
-    File.stat(path).mtime.should == @expected_mtime
+  before do
+    # Assert starting state is as expected
+    File.should exist(path)
+    # Kinda weird, in this case @expected_checksum is the cksum of the file
+    # with incorrect content.
     sha256_checksum(path).should == @expected_checksum
   end
 
-  it "should backup the existing file" do
-    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
-    resource.run_action(:create)
-    Dir.glob(backup_glob).size.should equal(1)
+  context "when running action :create" do
+    context "with backups enabled" do
+      before do
+        Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
+        resource.run_action(:create)
+      end
+
+      it "overwrites the file with the updated content when the :create action is run" do
+        File.stat(path).mtime.should > @expected_mtime
+        sha256_checksum(path).should_not == @expected_checksum
+      end
+
+      it "backs up the existing file" do
+        Dir.glob(backup_glob).size.should equal(1)
+      end
+
+      it "is marked as updated by last action" do
+        resource.should be_updated_by_last_action
+      end
+    end
+
+    context "with backups disabled" do
+      before do
+        Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
+        resource.backup(0)
+        resource.run_action(:create)
+      end
+
+      it "should not attempt to backup the existing file if :backup == 0" do
+        Dir.glob(backup_glob).size.should equal(0)
+      end
+    end
   end
 
-  it "should not attempt to backup the existing file if :backup == 0" do
-    Chef::Config[:file_backup_path] = CHEF_SPEC_BACKUP_PATH
-    resource.backup(0)
-    resource.run_action(:create)
-    Dir.glob(backup_glob).size.should equal(0)
+  describe "when running action :create_if_missing" do
+    before do
+      resource.run_action(:create_if_missing)
+    end
+
+    it "doesn't overwrite the file when the :create_if_missing action is run" do
+      File.stat(path).mtime.should == @expected_mtime
+      sha256_checksum(path).should == @expected_checksum
+    end
+
+    it "is not marked as updated" do
+      resource.should_not be_updated_by_last_action
+    end
   end
 
-  it "deletes the file when the :delete action is run" do
-    resource.run_action(:delete)
-    File.should_not exist(path)
+  describe "when running action :delete" do
+    before do
+      resource.run_action(:delete)
+    end
+
+    it "deletes the file" do
+      File.should_not exist(path)
+    end
+
+    it "is marked as updated by last action" do
+      resource.should be_updated_by_last_action
+    end
   end
 end
 
 shared_examples_for "a file with the correct content" do
-  it "does not overwrite the original when the :create action is run" do
-    resource.run_action(:create)
+  before do
+    # Assert starting state is as expected
+    File.should exist(path)
     sha256_checksum(path).should == @expected_checksum
   end
 
-  it "does not update the mtime/atime of the file when the :create action is run" do
-    sleep 1
-    File.stat(path).mtime.should == @expected_mtime
-    File.stat(path).atime.should be_within(2).of(@expected_atime)
+  describe "when running action :create" do
+    before do
+      resource.run_action(:create)
+    end
+    it "does not overwrite the original when the :create action is run" do
+      sha256_checksum(path).should == @expected_checksum
+    end
+
+    it "does not update the mtime of the file when the :create action is run" do
+      File.stat(path).mtime.should == @expected_mtime
+    end
+
+    it "is not marked as updated by last action" do
+      resource.should_not be_updated_by_last_action
+    end
   end
 
-  it "doesn't overwrite the file when the :create_if_missing action is run" do
-    resource.run_action(:create_if_missing)
-    sha256_checksum(path).should == @expected_checksum
+  describe "when running action :create_if_missing" do
+    before do
+      resource.run_action(:create_if_missing)
+    end
+
+    it "doesn't overwrite the file when the :create_if_missing action is run" do
+      sha256_checksum(path).should == @expected_checksum
+    end
+
+    it "is not marked as updated by last action" do
+      resource.should_not be_updated_by_last_action
+    end
   end
 
-  it "deletes the file when the :delete action is run" do
-    resource.run_action(:delete)
-    File.should_not exist(path)
+  describe "when running action :delete" do
+    before do
+      resource.run_action(:delete)
+    end
+
+    it "deletes the file when the :delete action is run" do
+      File.should_not exist(path)
+    end
+
+    it "is marked as updated by last action" do
+      resource.should be_updated_by_last_action
+    end
   end
 end
 
 shared_examples_for "a file resource" do
+  before do
+    Chef::Log.level = :info
+  end
    # note the stripping of the drive letter from the tmpdir on windows
   let(:backup_glob) { File.join(CHEF_SPEC_BACKUP_PATH, Dir.tmpdir.sub(/^([A-Za-z]:)/, ""), "#{file_base}*") }
 
+  # Most tests update the resource, but a few do not. We need to test that the
+  # resource is marked updated or not correctly, but the test contexts are
+  # composed between correct/incorrect content and correct/incorrect
+  # permissions. We override this "let" definition in the context where content
+  # and permissions are correct.
+  let(:expect_updated?) { true }
+
+  def binread(file)
+    content = File.open(file, "rb") do |f|
+      f.read
+    end
+    content.force_encoding(Encoding::BINARY) if "".respond_to?(:force_encoding)
+    content
+  end
+
   context "when the target file does not exist" do
-    it "creates the file when the :create action is run" do
-      resource.run_action(:create)
-      File.should exist(path)
+    before do
+      # Assert starting state is expected
+      File.should_not exist(path)
     end
 
-    it "creates the file with the correct content when the :create action is run" do
-      resource.run_action(:create)
-      IO.read(path).should == expected_content
+    describe "when running action :create" do
+      before do
+        resource.run_action(:create)
+      end
+
+      it "creates the file when the :create action is run" do
+        File.should exist(path)
+      end
+
+      it "creates the file with the correct content when the :create action is run" do
+        binread(path).should == expected_content
+      end
+
+      it "is marked as updated by last action" do
+        resource.should be_updated_by_last_action
+      end
     end
 
-    it "creates the file with the correct content when the :create_if_missing action is run" do
-      resource.run_action(:create_if_missing)
-      IO.read(path).should == expected_content
+    describe "when running action :create_if_missing" do
+      before do
+        resource.run_action(:create_if_missing)
+      end
+
+      it "creates the file with the correct content" do
+        binread(path).should == expected_content
+      end
+
+      it "is marked as updated by last action" do
+        resource.should be_updated_by_last_action
+      end
     end
 
-    it "deletes the file when the :delete action is run" do
-      resource.run_action(:delete)
-      File.should_not exist(path)
+    describe "when running action :delete" do
+      before do
+        resource.run_action(:delete)
+      end
+
+      it "deletes the file when the :delete action is run" do
+        File.should_not exist(path)
+      end
+
+      it "is not marked updated by last action" do
+        resource.should_not be_updated_by_last_action
+      end
     end
   end
 
@@ -112,7 +229,10 @@ shared_examples_for "a file resource" do
 
   context "when the target file has the wrong content" do
     before(:each) do
-      File.open(path, "w") { |f| f.print "This is so wrong!!!" }
+      File.open(path, "wb") { |f| f.print "This is so wrong!!!" }
+      now = Time.now.to_i
+      File.utime(now - 9000, now - 9000, path)
+
       @expected_mtime = File.stat(path).mtime
       @expected_checksum = sha256_checksum(path)
     end
@@ -129,20 +249,27 @@ shared_examples_for "a file resource" do
       include_context "setup broken permissions"
 
       it_behaves_like "a file with the wrong content"
-  
+
       it_behaves_like "a securable resource"
     end
   end
 
   context "when the target file has the correct content" do
     before(:each) do
-      File.open(path, "w") { |f| f.print expected_content }
+      File.open(path, "wb") { |f| f.print expected_content }
+      now = Time.now.to_i
+      File.utime(now - 9000, now - 9000, path)
+
       @expected_mtime = File.stat(path).mtime
-      @expected_atime = File.stat(path).atime
       @expected_checksum = sha256_checksum(path)
     end
 
     describe "and the target file has the correct permissions" do
+
+      # When permissions and content are correct, chef should do nothing and
+      # the resource should not be marked updated.
+      let(:expect_updated?) { false }
+
       include_context "setup correct permissions"
 
       it_behaves_like "a file with the correct content"
@@ -159,11 +286,29 @@ shared_examples_for "a file resource" do
     end
   end
 
+  it_behaves_like "a file that inherits permissions from a parent directory"
+  
+end
+
+shared_examples_for "a file that inherits permissions from a parent directory" do
+  include_context "use Windows permissions"
+  context "on Windows", :windows_only do
+    it "has only inherited aces if no explicit aces were specified" do
+      File.exist?(path).should == false
+
+      resource.run_action(:create)
+
+      descriptor.dacl_inherits?.should == true
+      descriptor.dacl.each do | ace |
+        ace.inherited?.should == true
+      end
+    end
+  end
 end
 
 shared_context Chef::Resource::File  do
   let(:path) do
-    File.join(Dir.tmpdir, make_tmpname(file_base, nil))
+    File.join(Dir.tmpdir, make_tmpname(file_base))
   end
 
   after(:each) do