chef 18.8.11 → 18.8.54

data/spec/unit/run_context/cookbook_compiler_spec.rb

@@ -1,236 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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"
-require "support/lib/library_load_order"
-
-# 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 a cookbook fully" do
-    it "does not error" do
-      run_context.instance_variable_set(:@cookbook_compiler, compiler)
-      node.run_list("dependency1::default")
-      compiler.compile
-    end
-  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
-      expect(node[:attr_load_order]).to eq(["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
-      expect(node[:attr_load_order]).to eq(["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
-
-      expect(node[:attr_load_order]).to eq(["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
-
-      expect(node[:attr_load_order]).to eq(["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
-      expect(LibraryLoadOrder.load_order).to eq(%w{dependency1 dependency2 test-with-deps circular-dep2 circular-dep1 test-with-circular-deps})
-
-      # additionally test that we only load them once
-      compiler.compile_libraries
-      expect(LibraryLoadOrder.load_order).to eq(%w{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
-      expect(LibraryLoadOrder.load_order).to eq(%w{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
-      expect(LibraryLoadOrder.load_order).to eq(%w{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
-    # Additional tests for this behavior are in RunContext's tests
-
-    describe "event dispatch" do
-      let(:recipe) { "dependency1::default" }
-      let(:recipe_path) do
-        File.expand_path("../../data/run_context/cookbooks/dependency1/recipes/default.rb", __dir__)
-      end
-      before do
-        node.run_list(recipe)
-      end
-      subject { compiler.compile_recipes }
-
-      it "dispatches normally" do
-        allow(run_context).to receive(:load_recipe)
-        expect(events).to receive(:recipe_load_start).with(1)
-        expect(events).to receive(:recipe_file_loaded).with(recipe_path, "dependency1::default")
-        expect(events).to receive(:recipe_load_complete).with(no_args)
-        subject
-      end
-
-      it "dispatches when a recipe is not found" do
-        exc = Chef::Exceptions::RecipeNotFound.new
-        allow(run_context).to receive(:load_recipe).and_raise(exc)
-        expect(events).to receive(:recipe_load_start).with(1)
-        expect(events).to_not receive(:recipe_file_loaded)
-        expect(events).to receive(:recipe_not_found).with(exc)
-        expect(events).to_not receive(:recipe_load_complete)
-        expect { subject }.to raise_error(exc)
-      end
-
-      it "dispatches when a recipe has an error" do
-        exc = ArgumentError.new
-        allow(run_context).to receive(:load_recipe).and_raise(exc)
-        expect(events).to receive(:recipe_load_start).with(1)
-        expect(events).to_not receive(:recipe_file_loaded)
-        expect(events).to receive(:recipe_file_load_failed).with(recipe_path, exc, "dependency1::default")
-        expect(events).to_not receive(:recipe_load_complete)
-        expect { subject }.to raise_error(exc)
-      end
-    end
-
-  end
-
-  describe "listing cookbook order" do
-    it "should return an array of cookbook names as symbols without duplicates" do
-      node.run_list("test-with-circular-deps::default", "circular-dep1::default", "circular-dep2::default")
-
-      expect(compiler.cookbook_order).to eq(%i{circular-dep2
-                                         circular-dep1
-                                         test-with-circular-deps})
-    end
-
-    it "determines if a cookbook is in the list of cookbooks reachable by dependency" do
-      node.run_list("test-with-deps::default", "test-with-deps::server")
-      expect(compiler.cookbook_order).to eq(%i{dependency1 dependency2 test-with-deps})
-      expect(compiler.unreachable_cookbook?(:dependency1)).to be_falsey
-      expect(compiler.unreachable_cookbook?(:dependency2)).to be_falsey
-      expect(compiler.unreachable_cookbook?(:'test-with-deps')).to be_falsey
-      expect(compiler.unreachable_cookbook?(:'circular-dep1')).to be_truthy
-      expect(compiler.unreachable_cookbook?(:'circular-dep2')).to be_truthy
-    end
-
-  end
-end

data/spec/unit/run_context_spec.rb

@@ -1,257 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Tim Hinderliter (<tim@chef.io>)
-# Author:: Christopher Walters (<cw@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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"
-require "support/lib/library_load_order"
-
-describe Chef::RunContext do
-  let(:chef_repo_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "run_context", "cookbooks")) }
-  let(:cookbook_collection) do
-    cl = Chef::CookbookLoader.new(chef_repo_path)
-    cl.load_cookbooks
-    Chef::CookbookCollection.new(cl)
-  end
-  let(:node) do
-    node = Chef::Node.new
-    node.run_list << "test" << "test::one" << "test::two"
-    node
-  end
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
-
-  before(:each) do
-    @original_log_level = Chef::Log.level
-    Chef::Log.level = :debug
-  end
-
-  after(:each) do
-    Chef::Log.level = @original_log_level
-  end
-
-  it "has a cookbook collection" do
-    expect(run_context.cookbook_collection).to eq(cookbook_collection)
-  end
-
-  it "has a node" do
-    expect(run_context.node).to eq(node)
-  end
-
-  it "responds to #default_secret_service" do
-    expect(run_context).to respond_to(:default_secret_service)
-  end
-
-  it "responds to #default_secret_config" do
-    expect(run_context).to respond_to(:default_secret_config)
-  end
-
-  it "#default_secret_service defaults to nil" do
-    expect(run_context.default_secret_service).to eq(nil)
-  end
-
-  it "#default_secret_config defaults to {}" do
-    expect(run_context.default_secret_config).to eq({})
-  end
-
-  it "loads up node[:cookbooks]" do
-    expect(run_context.node[:cookbooks]).to eql(
-      {
-        "circular-dep1" => {
-          "version" => "0.0.0",
-        },
-        "circular-dep2" => {
-          "version" => "0.0.0",
-        },
-        "dependency1" => {
-          "version" => "0.0.0",
-        },
-        "dependency2" => {
-          "version" => "0.0.0",
-        },
-        "include" => {
-          "version" => "0.0.0",
-        },
-        "no-default-attr" => {
-          "version" => "0.0.0",
-        },
-        "test" => {
-          "version" => "0.0.0",
-        },
-        "test-with-circular-deps" => {
-          "version" => "0.0.0",
-        },
-        "test-with-deps" => {
-          "version" => "0.0.0",
-        },
-      }
-    )
-  end
-
-  it "has a nil parent_run_context" do
-    expect(run_context.parent_run_context).to be_nil
-  end
-
-  describe "loading cookbooks for a run list" do
-    before do
-
-      # Each invocation reloads LWRPs, which triggers constant redefinition
-      # warnings. In real usage this isn't an issue because of fork mode.
-      if Chef::Provider.const_defined?(:TestProvider)
-        Chef::Provider.send(:remove_const, :TestProvider)
-      end
-
-      node.run_list << "test" << "test::one" << "test::two"
-      expect(node).to receive(:loaded_recipe).with(:test, "default")
-      expect(node).to receive(:loaded_recipe).with(:test, "one")
-      expect(node).to receive(:loaded_recipe).with(:test, "two")
-      run_context.load(node.run_list.expand("_default"))
-    end
-
-    it "should load all the definitions in the cookbooks for this node" do
-      expect(run_context.definitions).to have_key(:new_cat)
-      expect(run_context.definitions).to have_key(:new_badger)
-      expect(run_context.definitions).to have_key(:new_dog)
-    end
-
-    it "should load all the recipes specified for this node" do
-      expect(run_context.resource_collection[0].to_s).to eq("cat[einstein]")
-      expect(run_context.resource_collection[1].to_s).to eq("cat[loulou]")
-      expect(run_context.resource_collection[2].to_s).to eq("cat[birthday]")
-      expect(run_context.resource_collection[3].to_s).to eq("cat[peanut]")
-      expect(run_context.resource_collection[4].to_s).to eq("cat[fat peanut]")
-    end
-
-    it "loads all the attribute files in the cookbook collection" do
-      expect(run_context.loaded_fully_qualified_attribute?("test", "george")).to be_truthy
-      expect(node[:george]).to eq("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.
-      expect(node).not_to receive(:from_file)
-      node.include_attribute("test::george")
-    end
-
-    it "raises an error when attempting to include_recipe from a cookbook not reachable by run list or dependencies" do
-      expect(node).to receive(:loaded_recipe).with(:ancient, "aliens")
-      expect do
-        run_context.include_recipe("ancient::aliens")
-        # In CHEF-5120, this becomes a Chef::Exceptions::MissingCookbookDependency error:
-      end.to raise_error(Chef::Exceptions::CookbookNotFound)
-    end
-
-    it "raises an error on a recipe with a leading :: with no current_cookbook" do
-      expect do
-        run_context.include_recipe("::aliens")
-      end.to raise_error(RuntimeError)
-    end
-  end
-
-  describe "querying the contents of cookbooks" do
-    let(:chef_repo_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks")) }
-    let(:node) do
-      node = Chef::Node.new
-      node.normal[:platform] = "ubuntu"
-      node.normal[:platform_version] = "13.04"
-      node.name("testing")
-      node
-    end
-
-    it "queries whether a given cookbook has a specific template" do
-      expect(run_context).to have_template_in_cookbook("openldap", "test.erb")
-      expect(run_context).not_to have_template_in_cookbook("openldap", "missing.erb")
-    end
-
-    it "errors when querying for a template in a not-available cookbook" do
-      expect do
-        run_context.has_template_in_cookbook?("no-such-cookbook", "foo.erb")
-      end.to raise_error(Chef::Exceptions::CookbookNotFound)
-    end
-
-    it "queries whether a given cookbook has a specific cookbook_file" do
-      expect(run_context).to have_cookbook_file_in_cookbook("java", "java.response")
-      expect(run_context).not_to have_cookbook_file_in_cookbook("java", "missing.txt")
-    end
-
-    it "errors when querying for a cookbook_file in a not-available cookbook" do
-      expect do
-        run_context.has_cookbook_file_in_cookbook?("no-such-cookbook", "foo.txt")
-      end.to raise_error(Chef::Exceptions::CookbookNotFound)
-    end
-  end
-
-  describe "handling reboot requests" do
-    let(:expected) do
-      { reason: "spec tests require a reboot" }
-    end
-
-    it "stores and deletes the reboot request" do
-      run_context.request_reboot(expected)
-      expect(run_context.reboot_info).to eq(expected)
-      expect(run_context.reboot_requested?).to be_truthy
-
-      run_context.cancel_reboot
-      expect(run_context.reboot_info).to eq({})
-      expect(run_context.reboot_requested?).to be_falsey
-    end
-  end
-
-  describe "notifications" do
-    let(:notification) { Chef::Resource::Notification.new(nil, nil, notifying_resource) }
-
-    shared_context "notifying resource is a Chef::Resource" do
-      let(:notifying_resource) { Chef::Resource.new("gerbil") }
-
-      it "should be keyed off the resource name" do
-        run_context.send(setter, notification)
-        expect(run_context.send(getter, notifying_resource)).to eq([notification])
-      end
-    end
-
-    shared_context "notifying resource is a subclass of Chef::Resource" do
-      let(:declared_type) { :alpaca }
-      let(:notifying_resource) do
-        r = Class.new(Chef::Resource).new("guinea pig")
-        r.declared_type = declared_type
-        r
-      end
-
-      it "should be keyed off the resource declared key" do
-        run_context.send(setter, notification)
-        expect(run_context.send(getter, notifying_resource)).to eq([notification])
-      end
-    end
-
-    describe "of the immediate kind" do
-      let(:setter) { :notifies_immediately }
-      let(:getter) { :immediate_notifications }
-      include_context "notifying resource is a Chef::Resource"
-      include_context "notifying resource is a subclass of Chef::Resource"
-    end
-
-    describe "of the delayed kind" do
-      let(:setter) { :notifies_delayed }
-      let(:getter) { :delayed_notifications }
-      include_context "notifying resource is a Chef::Resource"
-      include_context "notifying resource is a subclass of Chef::Resource"
-    end
-  end
-end

data/spec/unit/run_list/run_list_expansion_spec.rb

@@ -1,147 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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::RunList::RunListExpansion do
-  before do
-    @run_list = Chef::RunList.new
-    @run_list << "recipe[lobster::mastercookbook@0.1.0]" << "role[rage]" << "recipe[fist@0.1]"
-    @expansion = Chef::RunList::RunListExpansion.new("_default", @run_list.run_list_items)
-  end
-
-  describe "before expanding the run list" do
-    it "has an array of run list items" do
-      expect(@expansion.run_list_items).to eq(@run_list.run_list_items)
-    end
-
-    it "has default_attrs" do
-      expect(@expansion.default_attrs).to eq(Mash.new)
-    end
-
-    it "has override attrs" do
-      expect(@expansion.override_attrs).to eq(Mash.new)
-    end
-
-    it "it has an empty list of recipes" do
-      expect(@expansion.recipes.size).to eq(0)
-    end
-
-    it "has not applied its roles" do
-      expect(@expansion.applied_role?("rage")).to be_falsey
-    end
-  end
-
-  describe "after applying a role with environment-specific run lists" do
-    before do
-      @rage_role = Chef::Role.new.tap do |r|
-        r.name("rage")
-        r.env_run_lists("_default" => [], "prod" => ["recipe[prod-only]"])
-      end
-      @expansion = Chef::RunList::RunListExpansion.new("prod", @run_list.run_list_items)
-      expect(@expansion).to receive(:fetch_role).and_return(@rage_role)
-      @expansion.expand
-    end
-
-    it "has the correct list of recipes for the given environment" do
-      expect(@expansion.recipes).to eq(["lobster::mastercookbook", "prod-only", "fist"])
-    end
-
-  end
-
-  describe "after applying a role" do
-    before do
-      allow(@expansion).to receive(:fetch_role).and_return(Chef::Role.new)
-      @expansion.inflate_role("rage", "role[base]")
-    end
-
-    it "tracks the applied role" do
-      expect(@expansion.applied_role?("rage")).to be_truthy
-    end
-
-    it "does not inflate the role again" do
-      expect(@expansion.inflate_role("rage", "role[base]")).to be_falsey
-    end
-  end
-
-  describe "after expanding a run list" do
-    before do
-      @first_role = Chef::Role.new
-      @first_role.name("rage")
-      @first_role.run_list("role[mollusk]")
-      @first_role.default_attributes({ "foo" => "bar" })
-      @first_role.override_attributes({ "baz" => "qux" })
-      @second_role = Chef::Role.new
-      @second_role.name("rage")
-      @second_role.run_list("recipe[crabrevenge]")
-      @second_role.default_attributes({ "foo" => "boo" })
-      @second_role.override_attributes({ "baz" => "bux" })
-      allow(@expansion).to receive(:fetch_role).and_return(@first_role, @second_role)
-      @expansion.expand
-      @json = '{"id":"_default","run_list":[{"type":"recipe","name":"lobster::mastercookbook","version":"0.1.0",'
-        .concat(
-          '"skipped":false},{"type":"role","name":"rage","children":[{"type":"role","name":"mollusk","children":[],"missing":null,'
-                .concat(
-                  '"error":null,"skipped":null},{"type":"recipe","name":"crabrevenge","version":null,"skipped":false}],"missing":null,'
-                        .concat(
-                          '"error":null,"skipped":null},{"type":"recipe","name":"fist","version":"0.1","skipped":false}]}'
-                        )
-                )
-        )
-
-    end
-
-    it "produces json tree upon tracing expansion" do
-      json_run_list = @expansion.to_json
-      expect(json_run_list).to eq(@json)
-    end
-
-    it "has the ordered list of recipes" do
-      expect(@expansion.recipes).to eq(["lobster::mastercookbook", "crabrevenge", "fist"])
-    end
-
-    it "has the merged attributes from the roles with outer roles overriding inner" do
-      expect(@expansion.default_attrs).to eq({ "foo" => "bar" })
-      expect(@expansion.override_attrs).to eq({ "baz" => "qux" })
-    end
-
-    it "has the list of all roles applied" do
-      # this is the correct order, but 1.8 hash order is not stable
-      expect(@expansion.roles).to match_array(%w{rage mollusk})
-    end
-
-  end
-
-  describe "after expanding a run list with a non existent role" do
-    before do
-      allow(@expansion).to receive(:fetch_role) { @expansion.role_not_found("crabrevenge", "role[base]") }
-      @expansion.expand
-    end
-
-    it "is invalid" do
-      expect(@expansion).to be_invalid
-      expect(@expansion.errors?).to be_truthy # aliases
-    end
-
-    it "has a list of invalid role names" do
-      expect(@expansion.errors).to include("crabrevenge")
-    end
-
-  end
-
-end