chef 18.8.11 → 18.8.54

data/spec/unit/run_list/run_list_item_spec.rb

@@ -1,117 +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::RunListItem do
-
-  describe "when creating from a Hash" do
-    it "raises an exception when the hash doesn't have a :type key" do
-      expect { Chef::RunList::RunListItem.new(name: "tatft") }.to raise_error(ArgumentError)
-    end
-
-    it "raises an exception when the hash doesn't have an :name key" do
-      expect { Chef::RunList::RunListItem.new(type: "R") }.to raise_error(ArgumentError)
-    end
-
-    it "sets the name and type as given in the hash" do
-      item = Chef::RunList::RunListItem.new(type: "fuuu", name: "uuuu")
-      expect(item.to_s).to eq("fuuu[uuuu]")
-    end
-
-  end
-
-  describe "when creating an item from a string" do
-    it "parses a qualified recipe" do
-      item = Chef::RunList::RunListItem.new("recipe[rage]")
-      expect(item).to be_a_recipe
-      expect(item).not_to be_a_role
-      expect(item.to_s).to eq("recipe[rage]")
-      expect(item.name).to eq("rage")
-    end
-
-    it "parses a qualified recipe with a version" do
-      item = Chef::RunList::RunListItem.new("recipe[rage@0.1.0]")
-      expect(item).to be_a_recipe
-      expect(item).not_to be_a_role
-      expect(item.to_s).to eq("recipe[rage@0.1.0]")
-      expect(item.name).to eq("rage")
-      expect(item.version).to eq("0.1.0")
-    end
-
-    it "parses a qualified role" do
-      item = Chef::RunList::RunListItem.new("role[fist]")
-      expect(item).to be_a_role
-      expect(item).not_to be_a_recipe
-      expect(item.to_s).to eq("role[fist]")
-      expect(item.name).to eq("fist")
-    end
-
-    it "parses an unqualified recipe" do
-      item = Chef::RunList::RunListItem.new("lobster")
-      expect(item).to be_a_recipe
-      expect(item).not_to be_a_role
-      expect(item.to_s).to eq("recipe[lobster]")
-      expect(item.name).to eq("lobster")
-    end
-
-    it "raises an exception when the string has typo on the type part" do
-      expect { Chef::RunList::RunListItem.new("Recipe[lobster]") }.to raise_error(ArgumentError)
-    end
-
-    it "raises an exception when the string has extra space between the type and the name" do
-      expect { Chef::RunList::RunListItem.new("recipe [lobster]") }.to raise_error(ArgumentError)
-    end
-
-    it "raises an exception when the string does not close the bracket" do
-      expect { Chef::RunList::RunListItem.new("recipe[lobster") }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "comparing to other run list items" do
-    it "is equal to another run list item that has the same name and type" do
-      item1 = Chef::RunList::RunListItem.new("recipe[lrf]")
-      item2 = Chef::RunList::RunListItem.new("recipe[lrf]")
-      expect(item1).to eq(item2)
-    end
-
-    it "is not equal to another run list item with the same name and different type" do
-      item1 = Chef::RunList::RunListItem.new("recipe[lrf]")
-      item2 = Chef::RunList::RunListItem.new("role[lrf]")
-      expect(item1).not_to eq(item2)
-    end
-
-    it "is not equal to another run list item with the same type and different name" do
-      item1 = Chef::RunList::RunListItem.new("recipe[lrf]")
-      item2 = Chef::RunList::RunListItem.new("recipe[lobsterragefist]")
-      expect(item1).not_to eq(item2)
-    end
-
-    it "is not equal to another run list item with the same name and type but different version" do
-      item1 = Chef::RunList::RunListItem.new("recipe[lrf,0.1.0]")
-      item2 = Chef::RunList::RunListItem.new("recipe[lrf,0.2.0]")
-      expect(item1).not_to eq(item2)
-    end
-  end
-
-  describe "comparing to strings" do
-    it "is equal to a string if that string matches its to_s representation" do
-      expect(Chef::RunList::RunListItem.new("recipe[lrf]")).to eq("recipe[lrf]")
-    end
-  end
-end

data/spec/unit/run_list/versioned_recipe_list_spec.rb

@@ -1,197 +0,0 @@
-#
-# Author:: Stephen Delano (<stephen@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::VersionedRecipeList do
-
-  describe "initialize" do
-    it "should create an empty array" do
-      l = Chef::RunList::VersionedRecipeList.new
-      expect(l).to eq([])
-    end
-  end
-
-  let(:list) { described_class.new }
-
-  let(:versioned_recipes) { [] }
-
-  let(:recipes) { [] }
-
-  before do
-    recipes.each { |r| list << r }
-    versioned_recipes.each { |r| list.add_recipe r[:name], r[:version] }
-  end
-
-  describe "add_recipe" do
-
-    let(:recipes) { %w{ apt god apache2 } }
-
-    it "should append the recipe to the end of the list" do
-      list.add_recipe "rails"
-      expect(list).to eq(%w{apt god apache2 rails})
-    end
-
-    it "should not duplicate entries" do
-      list.add_recipe "apt"
-      expect(list).to eq(%w{apt god apache2})
-    end
-
-    it "should allow you to specify a version" do
-      list.add_recipe "rails", "1.0.0"
-      expect(list).to eq(%w{apt god apache2 rails})
-      expect(list.with_versions).to include({ name: "rails", version: "1.0.0" })
-    end
-
-    it "should allow you to specify a version for a recipe that already exists" do
-      list.add_recipe "apt", "1.2.3"
-      expect(list).to eq(%w{apt god apache2})
-      expect(list.with_versions).to include({ name: "apt", version: "1.2.3" })
-    end
-
-    it "should allow you to specify the same version of a recipe twice" do
-      list.add_recipe "rails", "1.0.0"
-      list.add_recipe "rails", "1.0.0"
-      expect(list.with_versions).to include({ name: "rails", version: "1.0.0" })
-    end
-
-    it "should allow you to specify no version, even when a version already exists" do
-      list.add_recipe "rails", "1.0.0"
-      list.add_recipe "rails"
-      expect(list.with_versions).to include({ name: "rails", version: "1.0.0" })
-    end
-
-    it "should not allow multiple versions of the same recipe" do
-      list.add_recipe "rails", "1.0.0"
-      expect { list.add_recipe "rails", "0.1.0" }.to raise_error Chef::Exceptions::CookbookVersionConflict
-    end
-  end
-
-  describe "with_versions" do
-
-    let(:versioned_recipes) do
-      [
-        { name: "apt", version: "1.0.0" },
-        { name: "god", version: nil },
-        { name: "apache2", version: "0.0.1" },
-      ]
-    end
-    it "should return an array of hashes with :name and :version" do
-      expect(list.with_versions).to eq(versioned_recipes)
-    end
-
-    it "should retain the same order as the version-less list" do
-      with_versions = list.with_versions
-      list.each_with_index do |item, index|
-        expect(with_versions[index][:name]).to eq(item)
-      end
-    end
-  end
-
-  describe "with_version_constraints" do
-
-    let(:versioned_recipes) do
-      [
-        { name: "apt", version: "~> 1.2.0" },
-        { name: "god", version: nil },
-        { name: "apache2", version: "0.0.1" },
-      ]
-    end
-
-    it "should return an array of hashes with :name and :version_constraint" do
-      list.with_version_constraints.each_with_index do |recipe_spec, i|
-
-        expected_recipe = versioned_recipes[i]
-
-        expect(recipe_spec[:name]).to eq(expected_recipe[:name])
-        expect(recipe_spec[:version_constraint]).to eq(Chef::VersionConstraint.new(expected_recipe[:version]))
-      end
-    end
-  end
-
-  describe "with_fully_qualified_names_and_version_constraints" do
-
-    let(:fq_names) { list.with_fully_qualified_names_and_version_constraints }
-
-    context "with bare cookbook names" do
-
-      let(:recipes) { %w{ apache2 } }
-
-      it "gives $cookbook_name::default" do
-        expect(fq_names).to eq( %w{ apache2::default } )
-      end
-
-    end
-
-    context "with qualified recipe names but no versions" do
-
-      let(:recipes) { %w{ mysql::server } }
-
-      it "returns the qualified recipe names" do
-        expect(fq_names).to eq( %w{ mysql::server } )
-      end
-
-    end
-
-    context "with unqualified names that have version constraints" do
-
-      let(:versioned_recipes) do
-        [
-          { name: "apt", version: "~> 1.2.0" },
-        ]
-      end
-
-      it "gives qualified names with their versions" do
-        expect(fq_names).to eq([ "apt::default@~> 1.2.0" ])
-      end
-
-      it "does not mutate the recipe name" do
-        expect(fq_names).to eq([ "apt::default@~> 1.2.0" ])
-        expect(list).to eq( [ "apt" ] )
-      end
-
-    end
-
-    context "with fully qualified names that have version constraints" do
-
-      let(:versioned_recipes) do
-        [
-          { name: "apt::cacher", version: "~> 1.2.0" },
-        ]
-      end
-
-      it "gives qualified names with their versions" do
-        expect(fq_names).to eq([ "apt::cacher@~> 1.2.0" ])
-      end
-
-      it "does not mutate the recipe name" do
-        expect(fq_names).to eq([ "apt::cacher@~> 1.2.0" ])
-        expect(list).to eq( [ "apt::cacher" ] )
-      end
-
-    end
-  end
-
-  context "with duplicate names" do
-    let(:fq_names) { list.with_duplicate_names }
-    let(:recipes) { %w{ foo bar::default } }
-
-    it "expands default recipes" do
-      expect(fq_names).to eq(%w{foo foo::default bar bar::default})
-    end
-  end
-end

data/spec/unit/run_list_spec.rb

@@ -1,312 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Seth Falcon (<seth@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 "chef/version_class"
-require "chef/version_constraint"
-
-describe Chef::RunList do
-  before(:each) do
-    @run_list = Chef::RunList.new
-  end
-
-  describe "<<" do
-    it "should add a recipe to the run list and recipe list with the fully qualified name" do
-      @run_list << "recipe[needy]"
-      expect(@run_list).to include("recipe[needy]")
-      expect(@run_list.recipes).to include("needy")
-    end
-
-    it "should add a role to the run list and role list with the fully qualified name" do
-      @run_list << "role[woot]"
-      expect(@run_list).to include("role[woot]")
-      expect(@run_list.roles).to include("woot")
-    end
-
-    it "should accept recipes that are unqualified" do
-      @run_list << "needy"
-      expect(@run_list).to include("recipe[needy]")
-      expect(@run_list.recipes.include?("needy")).to eq(true)
-    end
-
-    it "should not allow duplicates" do
-      @run_list << "needy"
-      @run_list << "needy"
-      expect(@run_list.run_list.length).to eq(1)
-      expect(@run_list.recipes.length).to eq(1)
-    end
-
-    it "should allow two versions of a recipe" do
-      @run_list << "recipe[needy@0.2.0]"
-      @run_list << "recipe[needy@0.1.0]"
-      expect(@run_list.run_list.length).to eq(2)
-      expect(@run_list.recipes.length).to eq(2)
-      expect(@run_list.recipes.include?("needy")).to eq(true)
-    end
-
-    it "should not allow duplicate versions of a recipe" do
-      @run_list << "recipe[needy@0.2.0]"
-      @run_list << "recipe[needy@0.2.0]"
-      expect(@run_list.run_list.length).to eq(1)
-      expect(@run_list.recipes.length).to eq(1)
-    end
-  end
-
-  describe "add" do
-    # Testing only the basic functionality here
-    # since full behavior is tested above.
-    it "should add a recipe to the run_list" do
-      @run_list.add "recipe[needy]"
-      expect(@run_list).to include("recipe[needy]")
-    end
-
-    it "should add a role to the run_list" do
-      @run_list.add "role[needy]"
-      expect(@run_list).to include("role[needy]")
-    end
-  end
-
-  describe "==" do
-    it "should believe two RunLists are equal if they have the same members" do
-      @run_list << "foo"
-      r = Chef::RunList.new
-      r << "foo"
-      expect(@run_list).to eq(r)
-    end
-
-    it "should believe a RunList is equal to an array named after it's members" do
-      @run_list << "foo"
-      @run_list << "baz"
-      expect(@run_list).to eq(%w{foo baz})
-    end
-  end
-
-  describe "empty?" do
-    it "should be emtpy if the run list has no members" do
-      expect(@run_list.empty?).to eq(true)
-    end
-
-    it "should not be empty if the run list has members" do
-      @run_list << "chromeo"
-      expect(@run_list.empty?).to eq(false)
-    end
-  end
-
-  describe "[]" do
-    it "should let you look up a member in the run list by position" do
-      @run_list << "recipe[loulou]"
-      expect(@run_list[0]).to eq("recipe[loulou]")
-    end
-  end
-
-  describe "[]=" do
-    it "should let you set a member of the run list by position" do
-      @run_list[0] = "recipe[loulou]"
-      expect(@run_list[0]).to eq("recipe[loulou]")
-    end
-
-    it "should properly expand a member of the run list given by position" do
-      @run_list[0] = "loulou"
-      expect(@run_list[0]).to eq("recipe[loulou]")
-    end
-  end
-
-  describe "each" do
-    it "should yield each member to your block" do
-      @run_list << "foo"
-      @run_list << "bar"
-      seen = []
-      @run_list.each { |r| seen << r }
-      expect(seen).to be_include("recipe[foo]")
-      expect(seen).to be_include("recipe[bar]")
-    end
-  end
-
-  describe "each_index" do
-    it "should yield each members index to your block" do
-      to_add = [ "recipe[foo]", "recipe[bar]", "recipe[baz]" ]
-      to_add.each { |i| @run_list << i }
-      @run_list.each_index { |i| expect(@run_list[i]).to eq(to_add[i]) }
-    end
-  end
-
-  describe "include?" do
-    it "should be true if the run list includes the item" do
-      @run_list << "foo"
-      @run_list.include?("foo")
-    end
-  end
-
-  describe "reset" do
-    it "should reset the run_list based on the array you pass" do
-      @run_list << "chromeo"
-      list = %w{camp chairs snakes clowns}
-      @run_list.reset!(list)
-      list.each { |i| expect(@run_list).to be_include(i) }
-      expect(@run_list.include?("chromeo")).to eq(false)
-    end
-  end
-
-  describe "when expanding the run list" do
-    before(:each) do
-      @role = Chef::Role.new
-      @role.name "stubby"
-      @role.run_list "one", "two"
-      @role.default_attributes one: :two
-      @role.override_attributes three: :four
-      @role.env_run_list["production"] = Chef::RunList.new( "one", "two", "five")
-
-      allow(Chef::Role).to receive(:load).and_return(@role)
-      @rest = double("Chef::ServerAPI", { get: @role.to_hash, url: "/" })
-      allow(Chef::ServerAPI).to receive(:new).and_return(@rest)
-
-      @run_list << "role[stubby]"
-      @run_list << "kitty"
-    end
-
-    describe "from disk" do
-      it "should load the role from disk" do
-        expect(Chef::Role).to receive(:from_disk).with("stubby")
-        @run_list.expand("_default", "disk")
-      end
-
-      it "should log a helpful error if the role is not available" do
-        allow(Chef::Role).to receive(:from_disk).and_raise(Chef::Exceptions::RoleNotFound)
-        expect(Chef::Log).to receive(:error).with("Role stubby (included by 'top level') is in the runlist but does not exist. Skipping expand.")
-        @run_list.expand("_default", "disk")
-      end
-    end
-
-    describe "from the chef server" do
-      it "should load the role from the chef server" do
-        # @rest.should_receive(:get).with("roles/stubby")
-        expansion = @run_list.expand("_default", "server")
-        expect(expansion.recipes).to eq(%w{one two kitty})
-      end
-
-      it "should default to expanding from the server" do
-        expect(@rest).to receive(:get).with("roles/stubby")
-        @run_list.expand("_default")
-      end
-
-      describe "with an environment set" do
-        it "expands the run list using the environment specific run list" do
-          expansion = @run_list.expand("production", "server")
-          expect(expansion.recipes).to eq(%w{one two five kitty})
-        end
-
-        describe "and multiply nested roles" do
-          before do
-            @multiple_rest_requests = double("Chef::ServerAPI")
-
-            @role.env_run_list["production"] << "role[prod-base]"
-
-            @role_prod_base = Chef::Role.new
-            @role_prod_base.name("prod-base")
-            @role_prod_base.env_run_list["production"] = Chef::RunList.new("role[nested-deeper]")
-
-            @role_nested_deeper = Chef::Role.new
-            @role_nested_deeper.name("nested-deeper")
-            @role_nested_deeper.env_run_list["production"] = Chef::RunList.new("recipe[prod-secret-sauce]")
-          end
-
-          it "expands the run list using the specified environment for all nested roles" do
-            allow(Chef::ServerAPI).to receive(:new).and_return(@multiple_rest_requests)
-            expect(@multiple_rest_requests).to receive(:get).with("roles/stubby").and_return(@role.to_hash)
-            expect(@multiple_rest_requests).to receive(:get).with("roles/prod-base").and_return(@role_prod_base.to_hash)
-            expect(@multiple_rest_requests).to receive(:get).with("roles/nested-deeper").and_return(@role_nested_deeper.to_hash)
-
-            expansion = @run_list.expand("production", "server")
-            expect(expansion.recipes).to eq(%w{one two five prod-secret-sauce kitty})
-          end
-
-        end
-
-      end
-
-    end
-
-    it "should return the list of expanded recipes" do
-      expansion = @run_list.expand("_default")
-      expect(expansion.recipes[0]).to eq("one")
-      expect(expansion.recipes[1]).to eq("two")
-    end
-
-    it "should return the list of default attributes" do
-      expansion = @run_list.expand("_default")
-      expect(expansion.default_attrs[:one]).to eq(:two)
-    end
-
-    it "should return the list of override attributes" do
-      expansion = @run_list.expand("_default")
-      expect(expansion.override_attrs[:three]).to eq(:four)
-    end
-
-    it "should recurse into a child role" do
-      dog = Chef::Role.new
-      dog.name "dog"
-      dog.default_attributes seven: :nine
-      dog.run_list "three"
-      @role.run_list << "role[dog]"
-      allow(Chef::Role).to receive(:from_disk).with("stubby").and_return(@role)
-      allow(Chef::Role).to receive(:from_disk).with("dog").and_return(dog)
-
-      expansion = @run_list.expand("_default", "disk")
-      expect(expansion.recipes[2]).to eq("three")
-      expect(expansion.default_attrs[:seven]).to eq(:nine)
-    end
-
-    it "should not recurse infinitely" do
-      dog = Chef::Role.new
-      dog.name "dog"
-      dog.default_attributes seven: :nine
-      dog.run_list "role[dog]", "three"
-      @role.run_list << "role[dog]"
-      allow(Chef::Role).to receive(:from_disk).with("stubby").and_return(@role)
-      expect(Chef::Role).to receive(:from_disk).with("dog").once.and_return(dog)
-
-      expansion = @run_list.expand("_default", "disk")
-      expect(expansion.recipes[2]).to eq("three")
-      expect(expansion.recipes[3]).to eq("kitty")
-      expect(expansion.default_attrs[:seven]).to eq(:nine)
-    end
-  end
-
-  describe "when converting to an alternate representation" do
-    before do
-      @run_list << "recipe[nagios::client]" << "role[production]" << "recipe[apache2]"
-    end
-
-    it "converts to an array of the string forms of its items" do
-      expect(@run_list.to_a).to eq(["recipe[nagios::client]", "role[production]", "recipe[apache2]"])
-    end
-
-    it "converts to json by converting its array form" do
-      expect(Chef::JSONCompat.to_json(@run_list)).to eq(Chef::JSONCompat.to_json(["recipe[nagios::client]", "role[production]", "recipe[apache2]"]))
-    end
-
-    include_examples "to_json equivalent to Chef::JSONCompat.to_json" do
-      let(:jsonable) { @run_list }
-    end
-
-  end
-
-end