chef 10.28.2-x86-mingw32

data/spec/unit/provider_spec.rb

@@ -0,0 +1,169 @@
+#
+# 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 NoWhyrunDemonstrator < Chef::Provider
+  attr_reader :system_state_altered
+  def whyrun_supported?
+    false
+  end
+  def load_current_resource
+
+  end
+  def action_foo
+    @system_state_altered = true
+  end
+end
+
+class ConvergeActionDemonstrator < Chef::Provider
+  attr_reader :system_state_altered
+
+  def whyrun_supported?
+    true
+  end
+
+  def load_current_resource
+  end
+
+  def action_foo
+    converge_by("running a state changing action") do
+      @system_state_altered = true
+    end
+  end
+end
+
+describe Chef::Provider do
+  before(:each) do
+    @cookbook_collection = Chef::CookbookCollection.new([])
+    @node = Chef::Node.new
+    @node.name "latte"
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+    @resource = Chef::Resource.new("funk", @run_context)
+    @resource.cookbook_name = "a_delicious_pie"
+    @provider = Chef::Provider.new(@resource, @run_context)
+  end
+
+  it "should store the resource passed to new as new_resource" do
+    @provider.new_resource.should eql(@resource)
+  end
+
+  it "should store the node passed to new as node" do
+    @provider.node.should eql(@node)
+  end
+
+  it "should have nil for current_resource by default" do
+    @provider.current_resource.should eql(nil)
+  end
+
+  it "should not support whyrun by default" do
+    @provider.send(:whyrun_supported?).should eql(false)
+  end
+
+  it "should return true for action_nothing" do
+    @provider.action_nothing.should eql(true)
+  end
+
+  it "evals embedded recipes with a pristine resource collection" do
+    @provider.run_context.instance_variable_set(:@resource_collection, "doesn't matter what this is")
+    temporary_collection = nil
+    snitch = Proc.new {temporary_collection = @run_context.resource_collection}
+    @provider.send(:recipe_eval, &snitch)
+    temporary_collection.should be_an_instance_of(Chef::ResourceCollection)
+    @provider.run_context.instance_variable_get(:@resource_collection).should == "doesn't matter what this is"
+  end
+
+  it "does not re-load recipes when creating the temporary run context" do
+    # we actually want to test that RunContext#load is never called, but we
+    # can't stub all instances of an object with rspec's mocks. :/
+    Chef::RunContext.stub!(:new).and_raise("not supposed to happen")
+    snitch = Proc.new {temporary_collection = @run_context.resource_collection}
+    @provider.send(:recipe_eval, &snitch)
+  end
+
+  context "when no converge actions are queued" do
+    before do
+      @provider.stub!(:whyrun_supported?).and_return(true)
+      @provider.stub!(:load_current_resource)
+    end
+
+    it "does not mark the new resource as updated" do
+      @resource.should_not be_updated
+      @resource.should_not be_updated_by_last_action
+    end
+  end
+
+  context "when converge actions have been added to the queue" do
+    describe "and provider supports whyrun mode" do
+      before do
+        @provider = ConvergeActionDemonstrator.new(@resource, @run_context)
+      end
+
+      it "should tell us that it does support whyrun" do
+        @provider.should be_whyrun_supported
+      end
+
+      it "queues up converge actions" do
+        @provider.action_foo
+        @provider.send(:converge_actions).should have(1).actions
+      end
+
+      it "executes pending converge actions to converge the system" do
+        @provider.run_action(:foo)
+        @provider.instance_variable_get(:@system_state_altered).should be_true
+      end
+
+      it "marks the resource as updated" do
+        @provider.run_action(:foo)
+        @resource.should be_updated
+        @resource.should be_updated_by_last_action
+      end
+    end
+
+    describe "and provider does not support whyrun mode" do
+      before do
+        Chef::Config[:why_run] = true
+        @provider = NoWhyrunDemonstrator.new(@resource, @run_context)
+      end
+
+      after do
+        Chef::Config[:why_run] = false
+      end
+
+      it "should tell us that it doesn't support whyrun" do
+        @provider.should_not be_whyrun_supported
+      end
+
+      it "should automatically generate a converge_by block on the provider's behalf" do
+        @provider.run_action(:foo)
+        @provider.send(:converge_actions).should have(0).actions
+        @provider.system_state_altered.should be_false
+      end
+
+      it "should automatically execute the generated converge_by block" do
+        @provider.run_action(:foo)
+        @provider.system_state_altered.should be_false
+        @resource.should_not be_updated
+        @resource.should_not be_updated_by_last_action
+      end
+    end
+  end
+
+end

data/spec/unit/recipe_spec.rb

@@ -0,0 +1,268 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2008-2011 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::Recipe do
+  before(:each) do
+    @cookbook_repo = File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "cookbooks"))
+    @cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(@cookbook_repo))
+    @node = Chef::Node.new
+    @node[:tags] = Array.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
+    @recipe = Chef::Recipe.new("hjk", "test", @run_context)
+
+    # Shef/ext.rb is on the run path, and it defines
+    # Chef::Recipe#resources to call pp, which we don't want when
+    # we're running tests.
+    @recipe.stub!(:pp)
+  end
+
+  describe "method_missing" do
+    describe "resources" do
+      it "should load a two word (zen_master) resource" do
+        lambda do
+          @recipe.zen_master "monkey" do
+            peace true
+          end
+        end.should_not raise_error(ArgumentError)
+      end
+
+      it "should load a one word (cat) resource" do
+        lambda do
+          @recipe.cat "loulou" do
+            pretty_kitty true
+          end
+        end.should_not raise_error(ArgumentError)
+      end
+
+      it "should load a four word (one_two_three_four) resource" do
+        lambda do
+          @recipe.one_two_three_four "numbers" do
+            i_can_count true
+          end
+        end.should_not raise_error(ArgumentError)
+      end
+
+      it "should throw an error if you access a resource that we can't find" do
+        lambda { @recipe.not_home("not_home_resource") }.should raise_error(NameError)
+      end
+
+      it "should require a name argument" do
+        lambda {
+          @recipe.cat
+        }.should raise_error(ArgumentError, "You must supply a name when declaring a cat resource")
+      end
+
+      it "should allow regular errors (not NameErrors) to pass unchanged" do
+        lambda {
+          @recipe.cat("felix") { raise ArgumentError, "You Suck" }
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should add our zen_master to the collection" do
+        @recipe.zen_master "monkey" do
+          peace true
+        end
+        @run_context.resource_collection.lookup("zen_master[monkey]").name.should eql("monkey")
+      end
+
+      it "should add our zen masters to the collection in the order they appear" do
+        %w{monkey dog cat}.each do |name|
+          @recipe.zen_master name do
+            peace true
+          end
+        end
+
+        @run_context.resource_collection.map{|r| r.name}.should eql(["monkey", "dog", "cat"])
+      end
+
+      it "should return the new resource after creating it" do
+        res = @recipe.zen_master "makoto" do
+          peace true
+        end
+        res.resource_name.should eql(:zen_master)
+        res.name.should eql("makoto")
+      end
+
+      describe "should locate platform mapped resources" do
+
+        it "locate resource for particular platform" do
+          Object.const_set('ShaunTheSheep', Class.new(Chef::Resource){ provides :laughter, :on_platforms => ["television"] })
+          @node.platform("television")
+          @node.platform_version("123")
+          res = @recipe.laughter "timmy"
+          res.name.should eql("timmy")
+          res.kind_of?(ShaunTheSheep)
+        end
+
+        it "locate a resource for all platforms" do
+          Object.const_set("YourMom", Class.new(Chef::Resource){ provides :love_and_caring })
+          res = @recipe.love_and_caring "mommy"
+          res.name.should eql("mommy")
+          res.kind_of?(YourMom)
+        end
+
+      end
+    end
+
+    describe "resource definitions" do
+      it "should execute defined resources" do
+        crow_define = Chef::ResourceDefinition.new
+        crow_define.define :crow, :peace => false, :something => true do
+          zen_master "lao tzu" do
+            peace params[:peace]
+            something params[:something]
+          end
+        end
+        @run_context.definitions[:crow] = crow_define
+        @recipe.crow "mine" do
+          peace true
+        end
+        @run_context.resource_collection.resources(:zen_master => "lao tzu").name.should eql("lao tzu")
+        @run_context.resource_collection.resources(:zen_master => "lao tzu").something.should eql(true)
+      end
+
+      it "should set the node on defined resources" do
+        crow_define = Chef::ResourceDefinition.new
+        crow_define.define :crow, :peace => false, :something => true do
+          zen_master "lao tzu" do
+            peace params[:peace]
+            something params[:something]
+          end
+        end
+        @run_context.definitions[:crow] = crow_define
+        @node[:foo] = false
+        @recipe.crow "mine" do
+          something node[:foo]
+        end
+        @recipe.resources(:zen_master => "lao tzu").something.should eql(false)
+      end
+    end
+
+  end
+
+  describe "instance_eval" do
+    it "should handle an instance_eval properly" do
+      code = <<-CODE
+  zen_master "gnome" do
+    peace = true
+  end
+  CODE
+      lambda { @recipe.instance_eval(code) }.should_not raise_error
+      @recipe.resources(:zen_master => "gnome").name.should eql("gnome")
+    end
+  end
+
+  describe "from_file" do
+    it "should load a resource from a ruby file" do
+      @recipe.from_file(File.join(CHEF_SPEC_DATA, "recipes", "test.rb"))
+      res = @recipe.resources(:file => "/etc/nsswitch.conf")
+      res.name.should eql("/etc/nsswitch.conf")
+      res.action.should eql([:create])
+      res.owner.should eql("root")
+      res.group.should eql("root")
+      res.mode.should eql(0644)
+    end
+
+    it "should raise an exception if the file cannot be found or read" do
+      lambda { @recipe.from_file("/tmp/monkeydiving") }.should raise_error(IOError)
+    end
+  end
+
+  describe "include_recipe" do
+    it "should evaluate another recipe with include_recipe" do
+      @run_context.include_recipe "openldap::gigantor"
+      res = @run_context.resource_collection.resources(:cat => "blanket")
+      res.name.should eql("blanket")
+      res.pretty_kitty.should eql(false)
+    end
+
+    it "should load the default recipe for a cookbook if include_recipe is called without a ::" do
+      @run_context.include_recipe "openldap"
+      res = @run_context.resource_collection.resources(:cat => "blanket")
+      res.name.should eql("blanket")
+      res.pretty_kitty.should eql(true)
+    end
+
+    it "should store that it has seen a recipe in node.run_state[:seen_recipes]" do
+      @run_context.include_recipe "openldap"
+      @node.run_state[:seen_recipes].should have_key("openldap")
+    end
+
+    it "should not include the same recipe twice" do
+      @cookbook_collection[:openldap].should_receive(:load_recipe).with("default", @run_context)
+      @recipe.include_recipe "openldap"
+      @cookbook_collection[:openldap].should_not_receive(:load_recipe).with("default", @run_context)
+      @recipe.include_recipe "openldap"
+    end
+  end
+
+  describe "tags" do
+    it "should set tags via tag" do
+      @recipe.tag "foo"
+      @node[:tags].should include("foo")
+    end
+
+    it "should set multiple tags via tag" do
+      @recipe.tag "foo", "bar"
+      @node[:tags].should include("foo")
+      @node[:tags].should include("bar")
+    end
+
+    it "should not set the same tag twice via tag" do
+      @recipe.tag "foo"
+      @recipe.tag "foo"
+      @node[:tags].should eql([ "foo" ])
+    end
+
+    it "should return the current list of tags from tag with no arguments" do
+      @recipe.tag "foo"
+      @recipe.tag.should eql([ "foo" ])
+    end
+
+    it "should return true from tagged? if node is tagged" do
+      @recipe.tag "foo"
+      @recipe.tagged?("foo").should be(true)
+    end
+
+    it "should return false from tagged? if node is not tagged" do
+      @recipe.tagged?("foo").should be(false)
+    end
+
+    it "should return false from tagged? if node is not tagged" do
+      @recipe.tagged?("foo").should be(false)
+    end
+
+    it "should remove a tag from the tag list via untag" do
+      @recipe.tag "foo"
+      @recipe.untag "foo"
+      @node[:tags].should eql([])
+    end
+
+    it "should remove multiple tags from the tag list via untag" do
+      @recipe.tag "foo", "bar"
+      @recipe.untag "bar", "foo"
+      @node[:tags].should eql([])
+    end
+  end
+end

data/spec/unit/resource/apt_package_spec.rb

@@ -0,0 +1,43 @@
+#
+# 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'
+
+describe Chef::Resource::AptPackage, "initialize" do
+  
+  before(:each) do
+    @resource = Chef::Resource::AptPackage.new("foo")
+  end
+  
+  it "should return a Chef::Resource::AptPackage" do
+    @resource.should be_a_kind_of(Chef::Resource::AptPackage)
+  end
+  
+  it "should set the resource_name to :apt_package" do
+    @resource.resource_name.should eql(:apt_package)
+  end
+  
+  it "should set the provider to Chef::Provider::Package::Apt" do
+    @resource.provider.should eql(Chef::Provider::Package::Apt)
+  end
+
+  it "should support default_release" do
+    @resource.default_release("lenny-backports")
+    @resource.default_release.should eql("lenny-backports")
+  end
+end