microwave 0.1006.33 → 1.0.0

data/spec/unit/run_status_spec.rb

@@ -0,0 +1,145 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010 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'
+
+describe Chef::RunStatus do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @run_status = Chef::RunStatus.new(@node, @events)
+  end
+
+  describe "before the run context has been set" do
+    it "converts to a hash" do
+      @run_status.to_hash
+    end
+  end
+
+  describe "when the run context has been set" do
+    before do
+      @run_status.run_context = @run_context
+    end
+
+    it "has a run context" do
+      @run_status.run_context.should equal(@run_context)
+    end
+
+    it "provides access to the run context's node" do
+      @run_status.node.should equal(@node)
+    end
+
+    it "converts to a hash" do
+      @run_status.to_hash[:node].should equal(@node)
+      @run_status.to_hash[:success].should be_true
+    end
+
+    describe "after it has recorded timing information" do
+      before do
+        @start_time = Time.new
+        @end_time = @start_time + 23
+        Time.stub!(:now).and_return(@start_time, @end_time)
+        @run_status.start_clock
+        @run_status.stop_clock
+      end
+
+      it "records the start time of the run" do
+        @run_status.start_time.should == @start_time
+      end
+
+      it "records the end time of the run" do
+        @run_status.end_time.should == @end_time
+      end
+
+      it "gives the elapsed time of the chef run" do
+        @run_status.elapsed_time.should == 23
+      end
+
+      it "includes timing information in its hash form" do
+        @run_status.to_hash[:start_time].should == @start_time
+        @run_status.to_hash[:end_time].should == @end_time
+        @run_status.to_hash[:elapsed_time].should == 23
+      end
+
+    end
+
+    describe "with resources in the resource_collection" do
+      before do
+        @all_resources = [Chef::Resource::Cat.new("whiskers"), Chef::Resource::ZenMaster.new('dtz')]
+        @run_context.resource_collection.all_resources.replace(@all_resources)
+      end
+
+      it "lists all resources" do
+        @run_status.all_resources.should == @all_resources
+      end
+
+      it "has no updated resources" do
+        @run_status.updated_resources.should be_empty
+      end
+
+      it "includes the list of all resources in its hash form" do
+        @run_status.to_hash[:all_resources].should == @all_resources
+        @run_status.to_hash[:updated_resources].should be_empty
+      end
+
+      describe "and some have been updated" do
+        before do
+          @all_resources.first.updated = true
+        end
+
+        it "lists the updated resources" do
+          @run_status.updated_resources.should == [@all_resources.first]
+        end
+
+        it "includes the list of updated resources in its hash form" do
+          @run_status.to_hash[:updated_resources].should == [@all_resources.first]
+        end
+      end
+    end
+
+    describe "when the run failed" do
+      before do
+        @exception = Exception.new("just testing")
+        @backtrace = caller
+        @exception.set_backtrace(@backtrace)
+        @run_status.exception = @exception
+      end
+
+      it "stores the exception" do
+        @run_status.exception.should equal(@exception)
+      end
+
+      it "stores the backtrace" do
+        @run_status.backtrace.should == @backtrace
+      end
+
+      it "says the run was not successful" do
+        @run_status.success?.should be_false
+        @run_status.failed?.should be_true
+      end
+
+      it "converts to a hash including the exception information" do
+        @run_status.to_hash[:success].should be_false
+        @run_status.to_hash[:exception].should == "Exception: just testing"
+        @run_status.to_hash[:backtrace].should == @backtrace
+      end
+    end
+  end
+end

data/spec/unit/runner_spec.rb

@@ -0,0 +1,303 @@
+
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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'
+
+class SnitchyProvider < Chef::Provider
+  def self.all_actions_called
+    @all_actions_called ||= []
+  end
+
+  def self.action_called(action)
+    all_actions_called << action
+  end
+
+  def self.clear_action_record
+    @all_actions_called = nil
+  end
+
+  def load_current_resource
+    true
+  end
+
+  def action_first_action
+    @new_resource.updated_by_last_action(true)
+    self.class.action_called(:first)
+  end
+
+  def action_second_action
+    @new_resource.updated_by_last_action(true)
+    self.class.action_called(:second)
+  end
+
+  def action_third_action
+    @new_resource.updated_by_last_action(true)
+    self.class.action_called(:third)
+  end
+
+end
+
+describe Chef::Runner do
+
+  before(:each) do
+    @node = Chef::Node.new
+    @node.name "latte"
+    @node.platform "mac_os_x"
+    @node.platform_version "10.5.1"
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, Chef::CookbookCollection.new({}), @events)
+    @first_resource = Chef::Resource::Cat.new("loulou1", @run_context)
+    @run_context.resource_collection << @first_resource
+    Chef::Platform.set(
+      :resource => :cat,
+      :provider => Chef::Provider::SnakeOil
+    )
+    @runner = Chef::Runner.new(@run_context)
+  end
+
+  it "should pass each resource in the collection to a provider" do
+    @run_context.resource_collection.should_receive(:execute_each_resource).once
+    @runner.converge
+  end
+
+  it "should use the provider specified by the resource (if it has one)" do
+    provider = Chef::Provider::Easy.new(@run_context.resource_collection[0], @run_context)
+    # Expect provider to be called twice, because will fall back to old provider lookup
+    @run_context.resource_collection[0].should_receive(:provider).twice.and_return(Chef::Provider::Easy)
+    Chef::Provider::Easy.should_receive(:new).once.and_return(provider)
+    @runner.converge
+  end
+
+  it "should use the platform provider if it has one" do
+    Chef::Platform.should_receive(:find_provider_for_node).once.and_return(Chef::Provider::SnakeOil)
+    @runner.converge
+  end
+
+  it "should run the action for each resource" do
+    Chef::Platform.should_receive(:find_provider_for_node).once.and_return(Chef::Provider::SnakeOil)
+    provider = Chef::Provider::SnakeOil.new(@run_context.resource_collection[0], @run_context)
+    provider.should_receive(:action_sell).once.and_return(true)
+    Chef::Provider::SnakeOil.should_receive(:new).once.and_return(provider)
+    @runner.converge
+  end
+
+  it "should raise exceptions as thrown by a provider" do
+    provider = Chef::Provider::SnakeOil.new(@run_context.resource_collection[0], @run_context)
+    Chef::Provider::SnakeOil.stub!(:new).once.and_return(provider)
+    provider.stub!(:action_sell).once.and_raise(ArgumentError)
+    lambda { @runner.converge }.should raise_error(ArgumentError)
+  end
+
+  it "should not raise exceptions thrown by providers if the resource has ignore_failure set to true" do
+    @run_context.resource_collection[0].stub!(:ignore_failure).and_return(true)
+    provider = Chef::Provider::SnakeOil.new(@run_context.resource_collection[0], @run_context)
+    Chef::Provider::SnakeOil.stub!(:new).once.and_return(provider)
+    provider.stub!(:action_sell).once.and_raise(ArgumentError)
+    lambda { @runner.converge }.should_not raise_error(ArgumentError)
+  end
+
+  it "should retry with the specified delay if retries are specified" do
+    @first_resource.retries 3
+    provider = Chef::Provider::SnakeOil.new(@run_context.resource_collection[0], @run_context)
+    Chef::Provider::SnakeOil.stub!(:new).once.and_return(provider)
+    provider.stub!(:action_sell).and_raise(ArgumentError)
+    @first_resource.should_receive(:sleep).with(2).exactly(3).times
+    lambda { @runner.converge }.should raise_error(ArgumentError)
+  end
+
+  it "should execute immediate actions on changed resources" do
+    notifying_resource = Chef::Resource::Cat.new("peanut", @run_context)
+    notifying_resource.action = :purr # only action that will set updated on the resource
+
+    @run_context.resource_collection << notifying_resource
+    @first_resource.action = :nothing # won't be updated unless notified by other resource
+
+    notifying_resource.notifies(:purr, @first_resource, :immediately)
+
+    @runner.converge
+
+    @first_resource.should be_updated
+  end
+
+  it "should follow a chain of actions" do
+    @first_resource.action = :nothing
+
+    middle_resource = Chef::Resource::Cat.new("peanut", @run_context)
+    middle_resource.action = :nothing
+    @run_context.resource_collection << middle_resource
+    middle_resource.notifies(:purr, @first_resource, :immediately)
+
+    last_resource = Chef::Resource::Cat.new("snuffles", @run_context)
+    last_resource.action = :purr
+    @run_context.resource_collection << last_resource
+    last_resource.notifies(:purr, middle_resource, :immediately)
+
+    @runner.converge
+
+    last_resource.should be_updated   # by action(:purr)
+    middle_resource.should be_updated # by notification from last_resource
+    @first_resource.should be_updated # by notification from middle_resource
+  end
+
+  it "should execute delayed actions on changed resources" do
+    @first_resource.action = :nothing
+    second_resource = Chef::Resource::Cat.new("peanut", @run_context)
+    second_resource.action = :purr
+
+    @run_context.resource_collection << second_resource
+    second_resource.notifies(:purr, @first_resource, :delayed)
+
+    @runner.converge
+
+    @first_resource.should be_updated
+  end
+
+  it "does not duplicate delayed notifications" do
+    SnitchyProvider.clear_action_record
+
+    Chef::Platform.set(
+      :resource => :cat,
+      :provider => SnitchyProvider
+    )
+
+    @first_resource.action = :nothing
+
+    second_resource = Chef::Resource::Cat.new("peanut", @run_context)
+    second_resource.action = :first_action
+    @run_context.resource_collection << second_resource
+
+    third_resource = Chef::Resource::Cat.new("snickers", @run_context)
+    third_resource.action = :first_action
+    @run_context.resource_collection << third_resource
+
+    second_resource.notifies(:second_action, @first_resource, :delayed)
+    second_resource.notifies(:third_action, @first_resource, :delayed)
+
+    third_resource.notifies(:second_action, @first_resource, :delayed)
+    third_resource.notifies(:third_action, @first_resource, :delayed)
+
+    @runner.converge
+    # resources 2 and 3 call :first_action in the course of normal resource
+    # execution, and schedule delayed actions :second and :third on the first
+    # resource. The duplicate actions should "collapse" to a single notification
+    # and order should be preserved.
+    SnitchyProvider.all_actions_called.should == [:first, :first, :second, :third]
+  end
+
+  it "executes delayed notifications in the order they were declared" do
+    SnitchyProvider.clear_action_record
+
+    Chef::Platform.set(
+      :resource => :cat,
+      :provider => SnitchyProvider
+    )
+
+    @first_resource.action = :nothing
+
+    second_resource = Chef::Resource::Cat.new("peanut", @run_context)
+    second_resource.action = :first_action
+    @run_context.resource_collection << second_resource
+
+    third_resource = Chef::Resource::Cat.new("snickers", @run_context)
+    third_resource.action = :first_action
+    @run_context.resource_collection << third_resource
+
+    second_resource.notifies(:second_action, @first_resource, :delayed)
+    second_resource.notifies(:second_action, @first_resource, :delayed)
+
+    third_resource.notifies(:third_action, @first_resource, :delayed)
+    third_resource.notifies(:third_action, @first_resource, :delayed)
+
+    @runner.converge
+    SnitchyProvider.all_actions_called.should == [:first, :first, :second, :third]
+  end
+
+  it "does not fire notifications if the resource was not updated by the last action executed" do
+    # REGRESSION TEST FOR CHEF-1452
+    SnitchyProvider.clear_action_record
+
+    Chef::Platform.set(
+      :resource => :cat,
+      :provider => SnitchyProvider
+    )
+
+    @first_resource.action = :first_action
+
+    second_resource = Chef::Resource::Cat.new("peanut", @run_context)
+    second_resource.action = :nothing
+    @run_context.resource_collection << second_resource
+
+    third_resource = Chef::Resource::Cat.new("snickers", @run_context)
+    third_resource.action = :nothing
+    @run_context.resource_collection << third_resource
+
+    @first_resource.notifies(:second_action, second_resource, :immediately)
+    second_resource.notifies(:third_action, third_resource, :immediately)
+
+    @runner.converge
+
+    # All of the resources should only fire once:
+    SnitchyProvider.all_actions_called.should == [:first, :second, :third]
+
+    # all of the resources should be marked as updated for reporting purposes
+    @first_resource.should be_updated
+    second_resource.should be_updated
+    third_resource.should be_updated
+  end
+
+  it "should check a resource's only_if and not_if if notified by another resource" do
+    @first_resource.action = :nothing
+
+    only_if_called_times = 0
+    @first_resource.only_if {only_if_called_times += 1; true}
+
+    not_if_called_times = 0
+    @first_resource.not_if {not_if_called_times += 1; false}
+
+    second_resource = Chef::Resource::Cat.new("carmel", @run_context)
+    @run_context.resource_collection << second_resource
+    second_resource.notifies(:purr, @first_resource, :delayed)
+    second_resource.action = :purr
+
+    # hits only_if first time when the resource is run in order, second on notify
+    @runner.converge
+
+    only_if_called_times.should == 2
+    not_if_called_times.should == 2
+  end
+
+  it "should resolve resource references in notifications when resources are defined lazily" do
+    @first_resource.action = :nothing
+
+    lazy_resources = lambda {
+      last_resource = Chef::Resource::Cat.new("peanut", @run_context)
+      @run_context.resource_collection << last_resource
+      last_resource.notifies(:purr, @first_resource.to_s, :delayed)
+      last_resource.action = :purr
+    }
+    second_resource = Chef::Resource::RubyBlock.new("myblock", @run_context)
+    @run_context.resource_collection << second_resource
+    second_resource.block { lazy_resources.call }
+
+    @runner.converge
+
+    @first_resource.should be_updated
+  end
+
+end
+

data/spec/unit/scan_access_control_spec.rb

@@ -0,0 +1,182 @@
+# 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/scan_access_control'
+
+describe Chef::ScanAccessControl do
+
+  before do
+    @new_resource = Chef::Resource::File.new("/tmp/foo/bar/baz/qux")
+    @current_resource = Chef::Resource::File.new(@new_resource.path)
+    @scanner = Chef::ScanAccessControl.new(@new_resource, @current_resource)
+  end
+
+  describe "when the fs entity does not exist" do
+
+    before do
+      @new_resource.tap do |f|
+        f.owner("root")
+        f.group("root")
+        f.mode('0755')
+      end
+      @scanner.set_all!
+    end
+
+    it "does not set any fields on the current resource" do
+      @current_resource.owner.should be_nil
+      @current_resource.group.should be_nil
+      @current_resource.mode.should be_nil
+    end
+
+  end
+
+  describe "when the fs entity exists" do
+
+    before do
+      @stat = mock("File::Stat for #{@new_resource.path}", :uid => 0, :gid => 0, :mode => 00100644)
+      File.should_receive(:stat).with(@new_resource.path).and_return(@stat)
+      File.should_receive(:exist?).with(@new_resource.path).and_return(true)
+    end
+
+    describe "when new_resource does not specify mode, user or group" do
+      # these tests are necessary for minitest-chef-handler to use as an API, see CHEF-3235
+      before do
+        @scanner.set_all!
+      end
+
+      it "sets the mode of the current resource to the current mode as a String" do
+        @current_resource.mode.should == "644"
+      end
+
+      context "on unix", :unix_only do
+        it "sets the group of the current resource to the current group as a String" do
+          @current_resource.group.should == Etc.getgrgid(0).name
+        end
+  
+        it "sets the owner of the current resource to the current owner as a String" do
+          @current_resource.user.should == "root"
+        end
+      end
+
+      context "on windows", :windows_only do
+        it "sets the group of the current resource to the current group as a String" do
+          @current_resource.group.should == 0
+        end
+  
+        it "sets the owner of the current resource to the current owner as a String" do
+          @current_resource.user.should == 0
+        end
+      end
+    end
+
+    describe "when new_resource specifies the mode with a string" do
+      before do
+        @new_resource.mode("0755")
+        @scanner.set_all!
+      end
+
+      it "sets the mode of the current resource to the file's current mode as a string" do
+        @current_resource.mode.should == "644"
+      end
+    end
+
+    describe "when new_resource specified the mode with an integer" do
+      before do
+        @new_resource.mode(00755)
+        @scanner.set_all!
+      end
+
+      it "sets the mode of the current resource to the current mode as an integer" do
+        @current_resource.mode.should == 00644
+      end
+
+    end
+
+    describe "when new_resource specifies the user with a UID" do
+
+      before do
+        @new_resource.user(0)
+        @scanner.set_all!
+      end
+
+      it "sets the owner of current_resource to the UID of the current owner" do
+        @current_resource.user.should == 0
+      end
+    end
+
+    describe "when new_resource specifies the user with a username" do
+
+      before do
+        @new_resource.user("root")
+      end
+
+      it "sets the owner of current_resource to the username of the current owner" do
+        @root_passwd = mock("Struct::Passwd for uid 0", :name => "root")
+        Etc.should_receive(:getpwuid).with(0).and_return(@root_passwd)
+        @scanner.set_all!
+
+        @current_resource.user.should == "root"
+      end
+
+      describe "and there is no passwd entry for the user" do
+        it "sets the owner of the current_resource to the UID" do
+          Etc.should_receive(:getpwuid).with(0).and_raise(ArgumentError)
+          @scanner.set_all!
+          @current_resource.user.should == 0
+        end
+      end
+    end
+
+    describe "when new_resource specifies the group with a GID" do
+
+      before do
+        @new_resource.group(0)
+        @scanner.set_all!
+      end
+
+      it "sets the group of the current_resource to the gid of the current owner" do
+        @current_resource.group.should == 0
+      end
+
+    end
+
+    describe "when new_resource specifies the group with a group name" do
+      before do
+        @new_resource.group("wheel")
+      end
+
+      it "sets the group of the current resource to the group name" do
+        @group_entry = mock("Struct::Group for wheel", :name => "wheel")
+        Etc.should_receive(:getgrgid).with(0).and_return(@group_entry)
+        @scanner.set_all!
+
+        @current_resource.group.should == "wheel"
+      end
+
+      describe "and there is no group entry for the group" do
+        it "sets the current_resource's group to the GID" do
+          Etc.should_receive(:getgrgid).with(0).and_raise(ArgumentError)
+          @scanner.set_all!
+          @current_resource.group.should == 0
+        end
+      end
+
+    end
+  end
+end
+