microwave 1.0.4 → 11.400.2

data/spec/unit/run_context/cookbook_compiler_spec.rb

@@ -0,0 +1,181 @@
+#
+# 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'
+
+# Keeps track of what file got loaded in what order.
+module LibraryLoadOrder
+  extend self
+
+  def load_order
+    @load_order ||= []
+  end
+
+  def reset!
+    @load_order = nil
+  end
+
+  def record(file)
+    load_order << file
+  end
+end
+
+# These tests rely on fixture data in spec/data/run_context/cookbooks.
+#
+# Dependencies (circular or not) are specified by `depends` directives in the
+# metadata of these cookbooks.
+#
+# Side effects used to verify the behavior are implemented as code in the various file types.
+#
+describe Chef::RunContext::CookbookCompiler do
+
+  let(:node) { Chef::Node.new }
+
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+
+  let(:cookbook_loader) do
+    cl = Chef::CookbookLoader.new(chef_repo_path)
+    cl.load_cookbooks
+    cl
+  end
+
+  let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
+
+  let(:chef_repo_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "run_context", "cookbooks")) }
+
+  let(:cookbook_collection) { Chef::CookbookCollection.new(cookbook_loader) }
+
+  # Lazy evaluation of `expansion` here is used to mutate the run list before expanding it
+  let(:run_list_expansion) { node.run_list.expand('_default') }
+
+  let(:compiler) do
+    Chef::RunContext::CookbookCompiler.new(run_context, run_list_expansion, events)
+  end
+
+
+  describe "loading attribute files" do
+
+    # Attribute files in the fixture data will append their
+    # "cookbook_name::attribute_file_name" to the node's `:attr_load_order`
+    # attribute when loaded.
+
+    it "loads default.rb first, then other files in sort order" do
+      node.run_list("dependency1::default")
+
+      compiler.compile_attributes
+      node[:attr_load_order].should == ["dependency1::default", "dependency1::aa_first", "dependency1::zz_last"]
+    end
+
+    it "loads dependencies before loading the depending cookbook's attributes" do
+      # Also make sure that attributes aren't loaded twice if we have two
+      # recipes from the same cookbook in the run list
+      node.run_list("test-with-deps::default", "test-with-deps::server")
+
+      compiler.compile_attributes
+
+      # dependencies are stored in a hash so therefore unordered, but they should be loaded in sort order
+      node[:attr_load_order].should == ["dependency1::default",
+                                        "dependency1::aa_first",
+                                        "dependency1::zz_last",
+                                        "dependency2::default",
+                                        "test-with-deps::default"]
+    end
+
+    it "does not follow infinite dependency loops" do
+      node.run_list("test-with-circular-deps::default")
+
+      # Circular deps should not cause infinite loops
+      compiler.compile_attributes
+
+      node[:attr_load_order].should == ["circular-dep2::default", "circular-dep1::default", "test-with-circular-deps::default"]
+    end
+
+    it "loads attributes from cookbooks that don't have a default.rb attribute file" do
+      node.run_list("no-default-attr::default.rb")
+
+      compiler.compile_attributes
+
+      node[:attr_load_order].should == ["no-default-attr::server"]
+    end
+  end
+
+  describe "loading libraries" do
+    before do
+      LibraryLoadOrder.reset!
+    end
+
+    # One big test for everything. Individual behaviors are tested by the attribute code above.
+    it "loads libraries in run list order" do
+      node.run_list("test-with-deps::default", "test-with-circular-deps::default")
+
+      compiler.compile_libraries
+      LibraryLoadOrder.load_order.should == ["dependency1", "dependency2", "test-with-deps", "circular-dep2", "circular-dep1", "test-with-circular-deps"]
+    end
+  end
+
+  describe "loading LWRPs" do
+    before do
+      LibraryLoadOrder.reset!
+    end
+
+    # One big test for everything. Individual behaviors are tested by the attribute code above.
+    it "loads LWRPs in run list order" do
+      node.run_list("test-with-deps::default", "test-with-circular-deps::default")
+
+      compiler.compile_lwrps
+      LibraryLoadOrder.load_order.should == ["dependency1-provider",
+                                             "dependency1-resource",
+                                             "dependency2-provider",
+                                             "dependency2-resource",
+                                             "test-with-deps-provider",
+                                             "test-with-deps-resource",
+                                             "circular-dep2-provider",
+                                             "circular-dep2-resource",
+                                             "circular-dep1-provider",
+                                             "circular-dep1-resource",
+                                             "test-with-circular-deps-provider",
+                                             "test-with-circular-deps-resource"]
+    end
+  end
+
+  describe "loading resource definitions" do
+    before do
+      LibraryLoadOrder.reset!
+    end
+
+    # One big test for all load order concerns. Individual behaviors are tested
+    # by the attribute code above.
+    it "loads resource definitions in run list order" do
+      node.run_list("test-with-deps::default", "test-with-circular-deps::default")
+
+      compiler.compile_resource_definitions
+      LibraryLoadOrder.load_order.should == ["dependency1-definition",
+                                             "dependency2-definition",
+                                             "test-with-deps-definition",
+                                             "circular-dep2-definition",
+                                             "circular-dep1-definition",
+                                             "test-with-circular-deps-definition"]
+    end
+
+  end
+
+  describe "loading recipes" do
+    # Tests for this behavior are in RunContext's tests
+  end
+
+end

data/spec/unit/run_context_spec.rb

@@ -24,11 +24,12 @@ Chef::Log.level = :debug
 
 describe Chef::RunContext do
   before(:each) do
-    Chef::Config.node_path(File.expand_path(File.join(CHEF_SPEC_DATA, "run_context", "nodes")))
     @chef_repo_path = File.expand_path(File.join(CHEF_SPEC_DATA, "run_context", "cookbooks"))
-    @cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(@chef_repo_path))
+    cl = Chef::CookbookLoader.new(@chef_repo_path)
+    cl.load_cookbooks
+    @cookbook_collection = Chef::CookbookCollection.new(cl)
     @node = Chef::Node.new
-    @node.find_file("run_context")
+    @node.run_list << "test" << "test::one" << "test::two"
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
   end
@@ -53,12 +54,25 @@ describe Chef::RunContext do
     end
 
     it "should load all the recipes specified for this node" do
-      @run_context.resource_collection[0].to_s.should == "cat[einstein]"  
+      @run_context.resource_collection[0].to_s.should == "cat[einstein]"
       @run_context.resource_collection[1].to_s.should == "cat[loulou]"
       @run_context.resource_collection[2].to_s.should == "cat[birthday]"
       @run_context.resource_collection[3].to_s.should == "cat[peanut]"
       @run_context.resource_collection[4].to_s.should == "cat[fat peanut]"
     end
+
+    it "loads all the attribute files in the cookbook collection" do
+      @run_context.loaded_fully_qualified_attribute?("test", "george").should be_true
+      @node[:george].should == "washington"
+    end
+
+    it "registers attributes files as loaded so they won't be reloaded" do
+      # This test unfortunately is pretty tightly intertwined with the
+      # implementation of how nodes load attribute files, but is the only
+      # convenient way to test this behavior.
+      @node.should_not_receive(:from_file)
+      @node.include_attribute("test::george")
+    end
   end
 
 end

data/spec/unit/run_list_spec.rb

@@ -23,13 +23,6 @@ require 'spec_helper'
 require 'chef/version_class'
 require 'chef/version_constraint'
 
-# dep_selector/gecode on many platforms is currenly a bowel of hurt
-begin
-require 'chef/cookbook_version_selector'
-rescue LoadError
-  STDERR.puts "\n*** dep_selector not installed. marking all unit tests 'pending' that have a transitive dependency on dep_selector. ***\n\n"
-end
-
 describe Chef::RunList do
   before(:each) do
     @run_list = Chef::RunList.new
@@ -255,13 +248,6 @@ describe Chef::RunList do
 
     end
 
-    describe "from couchdb" do
-      it "should load the role from couchdb" do
-        Chef::Role.should_receive(:cdb_load).and_return(@role)
-        @run_list.expand("_default", "couchdb")
-      end
-    end
-
     it "should return the list of expanded recipes" do
       expansion = @run_list.expand("_default")
       expansion.recipes[0].should == "one"
@@ -323,199 +309,4 @@ describe Chef::RunList do
 
   end
 
-  describe "constrain" do
-
-    pending "=> can't find 'dep_selector' gem...skipping Chef::CookbookVersionSelector related tests" do
-
-      @fake_db = Object.new
-
-      def cookbook_maker(name, version, deps)
-        book = Chef::CookbookVersion.new(name, @fake_db)
-        book.version = version
-        deps.each { |dep_name, vc| book.metadata.depends(dep_name, vc) }
-        book
-      end
-
-      def vc_maker(cookbook_name, version_constraint)
-        vc = Chef::VersionConstraint.new(version_constraint)
-        { :name => cookbook_name, :version_constraint => vc }
-      end
-
-      def assert_failure_unsatisfiable_item(run_list, all_cookbooks, constraints, expected_message)
-        begin
-          Chef::CookbookVersionSelector.constrain(all_cookbooks, constraints)
-          fail "Should have raised a Chef::Exceptions::CookbookVersionSelection::UnsatisfiableRunListItem exception"
-        rescue Chef::Exceptions::CookbookVersionSelection::UnsatisfiableRunListItem => urli
-          urli.message.should include(expected_message)
-        end
-      end
-
-      def assert_failure_invalid_items(run_list, all_cookbooks, constraints, expected_message)
-        begin
-          Chef::CookbookVersionSelector.constrain(all_cookbooks, constraints)
-          fail "Should have raised a Chef::Exceptions::CookbookVersionSelection::InvalidRunListItems exception"
-        rescue Chef::Exceptions::CookbookVersionSelection::InvalidRunListItems => irli
-          irli.message.should include(expected_message)
-        end
-      end
-
-      before(:each) do
-        a1 = cookbook_maker("a", "1.0", [["c", "< 4.0"]])
-        b1 = cookbook_maker("b", "1.0", [["c", "< 3.0"]])
-
-        c2 = cookbook_maker("c", "2.0", [["d", "> 1.0"], ["f", nil]])
-        c3 = cookbook_maker("c", "3.0", [["d", "> 2.0"], ["e", nil]])
-
-        d1_1 = cookbook_maker("d", "1.1", [])
-        d2_1 = cookbook_maker("d", "2.1", [])
-        e1 = cookbook_maker("e", "1.0", [])
-        f1 = cookbook_maker("f", "1.0", [])
-        g1 = cookbook_maker("g", "1.0", [["d", "> 5.0"]])
-
-        n1_1 = cookbook_maker("n", "1.1", [])
-        n1_2 = cookbook_maker("n", "1.2", [])
-        n1_10 = cookbook_maker("n", "1.10", [])
-
-        depends_on_nosuch = cookbook_maker("depends_on_nosuch", "1.0", [["nosuch", nil]])
-
-        @all_cookbooks = {
-          "a" => [a1],
-          "b" => [b1],
-          "c" => [c2, c3],
-          "d" => [d1_1, d2_1],
-          "e" => [e1],
-          "f" => [f1],
-          "g" => [g1],
-          "n" => [n1_1, n1_2, n1_10],
-          "depends_on_nosuch" => [depends_on_nosuch]
-        }
-
-        $stderr.reopen DEV_NULL
-      end
-
-      after do
-        $stderr.reopen STDERR
-      end
-
-      it "pulls in transitive dependencies" do
-        constraints = [vc_maker("a", "~> 1.0")]
-        cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-        %w(a c d e).each { |k| cookbooks.should have_key k }
-        cookbooks.size.should == 4
-        cookbooks["c"].version.should == "3.0.0"
-        cookbooks["d"].version.should == "2.1.0"
-      end
-
-      it "should satisfy recipe-specific dependencies" do
-        depends_on_recipe = cookbook_maker("depends_on_recipe", "1.0", [["f::recipe", "1.0"]])
-        @all_cookbooks["depends_on_recipe"] = [depends_on_recipe]
-        constraints = [vc_maker("depends_on_recipe", "= 1.0")]
-        cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-        cookbooks["f"].version.should == "1.0.0"
-      end
-
-      it "properly sorts version triples, treating each term numerically" do
-        constraints = [vc_maker("n", "> 1.2")]
-        cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-        cookbooks.size.should == 1
-        cookbooks["n"].version.should == "1.10.0"
-      end
-
-      it "should fail to find a solution when a run list item is constrained to a range that includes no cookbooks" do
-        constraints = [vc_maker("d", "> 5.0")]
-        assert_failure_invalid_items(@run_list, @all_cookbooks, constraints, "Run list contains invalid items: no versions match the constraints on cookbook d.")
-      end
-
-      it "should fail to find a solution when a run list item's dependency is constrained to a range that includes no cookbooks" do
-        constraints = [vc_maker("g", nil)]
-        assert_failure_unsatisfiable_item(@run_list, @all_cookbooks, constraints, "Unable to satisfy constraints on cookbook d due to run list item (g >= 0.0.0)")
-      end
-
-      it "selects 'd 2.1.0' given constraint 'd > 1.2.3'" do
-        constraints = [vc_maker("d", "> 1.2.3")]
-        cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-        cookbooks.size.should == 1
-        cookbooks["d"].version.should == "2.1.0"
-      end
-
-      it "selects largest version when constraint allows multiple" do
-        constraints = [vc_maker("d", "> 1.0")]
-        cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-        cookbooks.size.should == 1
-        cookbooks["d"].version.should == "2.1.0"
-      end
-
-      it "selects 'd 1.1.0' given constraint 'd ~> 1.0'" do
-        constraints = [vc_maker("d", "~> 1.0")]
-        cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-        cookbooks.size.should == 1
-        cookbooks["d"].version.should == "1.1.0"
-      end
-
-      it "raises InvalidRunListItems for an unknown cookbook in the run list" do
-        constraints = [vc_maker("nosuch", "1.0.0")]
-        assert_failure_invalid_items(@run_list, @all_cookbooks, constraints, "Run list contains invalid items: no such cookbook nosuch.")
-      end
-
-      it "raises CookbookVersionConflict for an unknown cookbook in a cookbook's dependencies" do
-        constraints = [vc_maker("depends_on_nosuch", "1.0.0")]
-        assert_failure_unsatisfiable_item(@run_list, @all_cookbooks, constraints, "Unable to satisfy constraints on cookbook nosuch, which does not exist, due to run list item (depends_on_nosuch = 1.0.0). Run list items that may result in a constraint on nosuch: [(depends_on_nosuch = 1.0.0) -> (nosuch >= 0.0.0)]")
-      end
-
-      it "raises UnsatisfiableRunListItem for direct conflict" do
-        constraints = [vc_maker("d", "= 1.1.0"), vc_maker("d", ">= 2.0")]
-        assert_failure_unsatisfiable_item(@run_list, @all_cookbooks, constraints, "Unable to satisfy constraints on cookbook d due to run list item (d >= 2.0.0)")
-      end
-
-      describe "should solve regardless of constraint order" do
-
-        it "raises CookbookVersionConflict a then b" do
-          # Cookbooks a and b both have a dependency on c, but with
-          # differing constraints.
-          constraints = [vc_maker("a", "1.0"), vc_maker("b", "1.0")]
-          cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-          cookbooks.size.should == 5
-          %w(a b c d f).each { |k| cookbooks.should have_key k }
-          cookbooks["a"].version.should == "1.0.0"
-          cookbooks["b"].version.should == "1.0.0"
-          cookbooks["c"].version.should == "2.0.0"
-          cookbooks["d"].version.should == "2.1.0"
-        end
-
-        it "resolves b then a" do
-          # See above comment for a then b.  When b is pulled in first,
-          # we should get a version of c that satifies the constraints
-          # on the c dependency for both b and a.
-          constraints = [vc_maker("b", "1.0"), vc_maker("a", "1.0")]
-          cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-          cookbooks.size.should == 5
-          %w(a b c d f).each { |k| cookbooks.should have_key k }
-          cookbooks["a"].version.should == "1.0.0"
-          cookbooks["b"].version.should == "1.0.0"
-          cookbooks["c"].version.should == "2.0.0"
-          cookbooks["d"].version.should == "2.1.0"
-        end
-
-        it "resolves a then d" do
-          constraints = [vc_maker("a", "1.0"), vc_maker("d", "1.1")]
-          cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-          cookbooks.size.should == 4
-          %w(a c d f).each { |k| cookbooks.should have_key k }
-          cookbooks["a"].version.should == "1.0.0"
-          cookbooks["c"].version.should == "2.0.0"
-          cookbooks["d"].version.should == "1.1.0"
-        end
-
-        it "resolves d then a" do
-          constraints = [vc_maker("d", "1.1"), vc_maker("a", "1.0")]
-          cookbooks = Chef::CookbookVersionSelector.constrain(@all_cookbooks, constraints)
-          cookbooks.size.should == 4
-          %w(a c d f).each { |k| cookbooks.should have_key k }
-          cookbooks["a"].version.should == "1.0.0"
-          cookbooks["c"].version.should == "2.0.0"
-          cookbooks["d"].version.should == "1.1.0"
-        end
-      end
-    end
-  end
 end