chef 18.8.11 → 18.8.54

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -1,229 +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 "chef/cookbook/syntax_check"
-
-describe Chef::Cookbook::SyntaxCheck do
-  before do
-    allow(ChefUtils).to receive(:windows?) { false }
-  end
-
-  let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks", "openldap") }
-  let(:unsafe_cookbook_path) { 'C:\AGENT-HOME\xml-data\build-dir\76808194-76906499\artifact\cookbooks/java' }
-  let(:syntax_check) { Chef::Cookbook::SyntaxCheck.new(cookbook_path) }
-
-  let(:open_ldap_cookbook_files) do
-    %w{ attributes/default.rb
-        attributes/smokey.rb
-        definitions/client.rb
-        definitions/server.rb
-        libraries/openldap.rb
-        libraries/openldap/version.rb
-        metadata.rb
-        recipes/default.rb
-        recipes/gigantor.rb
-        recipes/one.rb
-        recipes/return.rb
-        spec/spec_helper.rb }.map { |f| File.join(cookbook_path, f) }
-  end
-
-  before do
-    Chef::Log.logger = Logger.new(StringIO.new)
-    @original_log_level = Chef::Log.level
-    Chef::Log.level = :warn # suppress "Syntax OK" messages
-
-    @attr_files = %w{default.rb smokey.rb}.map { |f| File.join(cookbook_path, "attributes", f) }
-    @libr_files = %w{openldap.rb openldap/version.rb}.map { |f| File.join(cookbook_path, "libraries", f) }
-    @defn_files = %w{client.rb server.rb}.map { |f| File.join(cookbook_path, "definitions", f) }
-    @recipes = %w{default.rb gigantor.rb one.rb return.rb}.map { |f| File.join(cookbook_path, "recipes", f) }
-    @spec_files = [ File.join(cookbook_path, "spec", "spec_helper.rb") ]
-    @ruby_files = @attr_files + @libr_files + @defn_files + @recipes + @spec_files + [File.join(cookbook_path, "metadata.rb")]
-    @basenames = %w{ helpers_via_partial_test.erb
-                    helper_test.erb
-                    helpers.erb
-                    openldap_stuff.conf.erb
-                    nested_openldap_partials.erb
-                    nested_partial.erb
-                    openldap_nested_variable_stuff.erb
-                    openldap_variable_stuff.conf.erb
-                    test.erb
-                    some_windows_line_endings.erb
-                    all_windows_line_endings.erb
-                    no_windows_line_endings.erb }
-    @template_files = @basenames.map { |f| File.join(cookbook_path, "templates", "default", f) }
-  end
-
-  after do
-    Chef::Log.level = @original_log_level
-  end
-
-  it "creates a syntax checker given the cookbook name when Chef::Config.cookbook_path is set" do
-    Chef::Config[:cookbook_path] = File.dirname(cookbook_path)
-    syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:openldap)
-    expect(syntax_check.cookbook_path).to eq(cookbook_path)
-    expect(syntax_check.ruby_files.sort).to eq(open_ldap_cookbook_files.sort)
-  end
-
-  it "creates a syntax checker given the cookbook name and cookbook_path" do
-    syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:openldap, File.join(CHEF_SPEC_DATA, "cookbooks"))
-    expect(syntax_check.cookbook_path).to eq(cookbook_path)
-    expect(syntax_check.ruby_files.sort).to eq(open_ldap_cookbook_files.sort)
-  end
-
-  context "when using a standalone cookbook" do
-    let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "standalone_cookbook") }
-
-    it "creates a syntax checker given the cookbook name and cookbook_path for a standalone cookbook" do
-      syntax_check = Chef::Cookbook::SyntaxCheck.for_cookbook(:standalone_cookbook, CHEF_SPEC_DATA)
-      expect(syntax_check.cookbook_path).to eq(cookbook_path)
-      expect(syntax_check.ruby_files).to eq([File.join(cookbook_path, "recipes/default.rb")])
-    end
-  end
-
-  it "safely handles a path containing control characters" do
-    syntax_check = Chef::Cookbook::SyntaxCheck.new(unsafe_cookbook_path)
-    expect { syntax_check.remove_uninteresting_ruby_files(@basenames) }.not_to raise_error
-  end
-
-  describe "when first created" do
-    it "has the path to the cookbook to syntax check" do
-      expect(syntax_check.cookbook_path).to eq(cookbook_path)
-    end
-
-    it "lists the ruby files in the cookbook" do
-      expect(syntax_check.ruby_files.sort).to eq(@ruby_files.sort)
-    end
-
-    it "lists the erb templates in the cookbook" do
-      expect(syntax_check.template_files.sort).to eq(@template_files.sort)
-    end
-
-  end
-
-  describe "when validating cookbooks" do
-    let(:cache_path) { Dir.mktmpdir }
-
-    before do
-      Chef::Config[:syntax_check_cache_path] = cache_path
-    end
-
-    after do
-      FileUtils.rm_rf(cache_path) if File.exist?(cache_path)
-    end
-
-    describe "and the files have not been syntax checked previously" do
-      it "shows that all ruby files require a syntax check" do
-        expect(syntax_check.untested_ruby_files.sort).to eq(@ruby_files.sort)
-      end
-
-      it "shows that all template files require a syntax check" do
-        expect(syntax_check.untested_template_files.sort).to eq(@template_files.sort)
-      end
-
-      it "removes a ruby file from the list of untested files after it is marked as validated" do
-        recipe = File.join(cookbook_path, "recipes", "default.rb")
-        syntax_check.validated(recipe)
-        expect(syntax_check.untested_ruby_files).not_to include(recipe)
-      end
-
-      it "removes a template file from the list of untested files after it is marked as validated" do
-        template = File.join(cookbook_path, "templates", "default", "test.erb")
-        syntax_check.validated(template)
-        expect(syntax_check.untested_template_files).not_to include(template)
-      end
-
-      it "validates all ruby files" do
-        expect(syntax_check.validate_ruby_files).to be_truthy
-        expect(syntax_check.untested_ruby_files).to be_empty
-      end
-
-      it "validates all templates" do
-        expect(syntax_check.validate_templates).to be_truthy
-        expect(syntax_check.untested_template_files).to be_empty
-      end
-
-      describe "and a file has a syntax error" do
-
-        before do
-          cookbook_path = File.join(CHEF_SPEC_DATA, "cookbooks", "borken")
-          syntax_check.cookbook_path.replace(cookbook_path)
-        end
-
-        it "it indicates that a ruby file has a syntax error" do
-          expect(Chef::Log).to receive(:fatal).with("Cookbook file borken/recipes/default.rb has a ruby syntax error.")
-          allow(Chef::Log).to receive(:fatal)
-          expect(syntax_check.validate_ruby_files).to be_falsey
-        end
-
-        it "does not remove the invalid file from the list of untested files" do
-          expect(syntax_check.untested_ruby_files).to include(File.join(cookbook_path, "recipes", "default.rb"))
-          syntax_check.validate_ruby_files
-          expect(syntax_check.untested_ruby_files).to include(File.join(cookbook_path, "recipes", "default.rb"))
-        end
-
-        it "indicates that a template file has a syntax error" do
-          expect(syntax_check.validate_templates).to be_falsey
-        end
-
-        it "does not remove the invalid template from the list of untested templates" do
-          expect(syntax_check.untested_template_files).to include(File.join(cookbook_path, "templates", "default", "borken.erb"))
-          expect { syntax_check.validate_templates }.not_to change(syntax_check, :untested_template_files)
-        end
-
-      end
-
-      describe "and an ignored file has a syntax error" do
-        before do
-          cookbook_path = File.join(CHEF_SPEC_DATA, "cookbooks", "ignorken")
-          Chef::Config[:cookbook_path] = File.dirname(cookbook_path)
-          syntax_check.cookbook_path.replace(cookbook_path)
-          @ruby_files = [File.join(cookbook_path, "metadata.rb"), File.join(cookbook_path, "recipes/default.rb")]
-        end
-
-        it "shows that ignored ruby files do not require a syntax check" do
-          expect(syntax_check.untested_ruby_files.sort).to eq(@ruby_files.sort)
-        end
-
-        it "does not indicate that a ruby file has a syntax error" do
-          expect(syntax_check.validate_ruby_files).to be_truthy
-          expect(syntax_check.untested_ruby_files).to be_empty
-        end
-
-      end
-
-    end
-
-    describe "and the files have been syntax checked previously" do
-      before do
-        syntax_check.untested_ruby_files.each { |f| syntax_check.validated(f) }
-        syntax_check.untested_template_files.each { |f| syntax_check.validated(f) }
-      end
-
-      it "does not syntax check ruby files" do
-        expect(syntax_check).not_to receive(:shell_out)
-        expect(syntax_check.validate_ruby_files).to be_truthy
-      end
-
-      it "does not syntax check templates" do
-        expect(syntax_check).not_to receive(:shell_out)
-        expect(syntax_check.validate_templates).to be_truthy
-      end
-    end
-  end
-end

data/spec/unit/cookbook_loader_spec.rb

@@ -1,265 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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::CookbookLoader do
-  before do
-    allow(ChefUtils).to receive(:windows?) { false }
-  end
-  let(:repo_paths) do
-    [
-      File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks")),
-    ]
-  end
-
-  let(:cookbook_loader) { Chef::CookbookLoader.new(repo_paths) }
-
-  def full_paths_for_part(cb, part)
-    cookbook_loader[cb].files_for(part).inject([]) { |memo, f| memo << f[:full_path]; memo }
-  end
-
-  it "checks each directory only once when loading (CHEF-3487)" do
-    cookbook_paths = []
-    repo_paths.each do |repo_path|
-      cookbook_paths |= Dir[File.join(repo_path, "*")]
-    end
-
-    cookbook_paths.delete_if { |path| File.basename(path) == "chefignore" }
-
-    cookbook_paths.each do |cookbook_path|
-      expect(Chef::Cookbook::CookbookVersionLoader).to receive(:new)
-        .with(cookbook_path, anything)
-        .once
-        .and_call_original
-    end
-    cookbook_loader.load_cookbooks
-  end
-
-  context "removed cookbook merging" do
-    let(:repo_paths) do
-      [
-        File.expand_path(File.join(CHEF_SPEC_DATA, "kitchen")),
-        File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks")),
-      ]
-    end
-    it "should not support multiple merged cookbooks in the cookbook path" do
-      expect { cookbook_loader.load_cookbooks }.to raise_error(Chef::Exceptions::CookbookMergingError)
-    end
-  end
-
-  context "after loading all cookbooks" do
-    before(:each) do
-      cookbook_loader.load_cookbooks
-    end
-
-    describe "[]" do
-      it "should return cookbook objects with []" do
-        expect(cookbook_loader[:openldap]).to be_a_kind_of(Chef::CookbookVersion)
-      end
-
-      it "should raise an exception if it cannot find a cookbook with []" do
-        expect { cookbook_loader[:monkeypoop] }.to raise_error(Chef::Exceptions::CookbookNotFoundInRepo)
-      end
-
-      it "should allow you to look up available cookbooks with [] and a symbol" do
-        expect(cookbook_loader[:openldap].name).to eql(:openldap)
-      end
-
-      it "should allow you to look up available cookbooks with [] and a string" do
-        expect(cookbook_loader["openldap"].name).to eql(:openldap)
-      end
-    end
-
-    describe "each" do
-      it "should allow you to iterate over cookbooks with each" do
-        seen = {}
-        cookbook_loader.each_key do |cookbook_name|
-          seen[cookbook_name] = true
-        end
-        expect(seen).to have_key("openldap")
-        expect(seen).to have_key("apache2")
-      end
-
-      it "should iterate in alphabetical order" do
-        seen = []
-        cookbook_loader.each_key do |cookbook_name|
-          seen << cookbook_name
-        end
-        expect(seen).to eq %w{angrybash apache2 borken ignorken irssi java name-mismatch openldap preseed starter supports-platform-constraints wget}
-      end
-    end
-
-    describe "referencing cookbook files" do
-      it "should find all the cookbooks in the cookbook path" do
-        expect(cookbook_loader).to have_key(:openldap)
-        expect(cookbook_loader).to have_key(:apache2)
-      end
-
-      it "should load different attribute files from deeper paths" do
-        expect(full_paths_for_part(:openldap, "attributes").detect do |f|
-          f =~ %r{cookbooks/openldap/attributes/smokey.rb}
-        end).not_to eql(nil)
-      end
-
-      it "should load definition files from deeper paths" do
-        expect(full_paths_for_part(:openldap, "definitions").detect do |f|
-          f =~ %r{cookbooks/openldap/definitions/server.rb}
-        end).not_to eql(nil)
-      end
-
-      it "should load recipe files from deeper paths" do
-        expect(full_paths_for_part(:openldap, "recipes").detect do |f|
-          f =~ %r{cookbooks/openldap/recipes/one.rb}
-        end).not_to eql(nil)
-      end
-
-      it "should find files that start with a ." do
-        expect(full_paths_for_part(:openldap, "files").detect do |f|
-          f =~ /\.dotfile$/
-        end).to match(/\.dotfile$/)
-        expect(full_paths_for_part(:openldap, "files").detect do |f|
-          f =~ %r{\.ssh/id_rsa$}
-        end).to match(%r{\.ssh/id_rsa$})
-      end
-
-      it "should load the metadata for the cookbook" do
-        expect(cookbook_loader.metadata[:openldap].name.to_s).to eq("openldap")
-        expect(cookbook_loader.metadata[:openldap]).to be_a_kind_of(Chef::Cookbook::Metadata)
-      end
-
-    end # referencing cookbook files
-
-  end # loading all cookbooks
-
-  context "loading all cookbooks when one has invalid metadata" do
-
-    let(:repo_paths) do
-      [
-        File.join(CHEF_SPEC_DATA, "cookbooks"),
-        File.join(CHEF_SPEC_DATA, "invalid-metadata-chef-repo"),
-      ]
-    end
-
-    it "does not squelch the exception" do
-      expect { cookbook_loader.load_cookbooks }.to raise_error("THIS METADATA HAS A BUG")
-    end
-
-  end
-
-  describe "loading only one cookbook" do
-
-    let(:openldap_cookbook) { cookbook_loader["openldap"] }
-
-    let(:cookbook_as_hash) { Chef::CookbookManifest.new(openldap_cookbook).to_hash }
-
-    before(:each) do
-      cookbook_loader.load_cookbook("openldap")
-    end
-
-    it "should have loaded the correct cookbook" do
-      seen = {}
-      cookbook_loader.each_key do |cookbook_name|
-        seen[cookbook_name] = true
-      end
-      expect(seen).to have_key("openldap")
-    end
-
-    it "should not duplicate keys when serialized to JSON" do
-      # Chef JSON serialization will generate duplicate keys if given
-      # a Hash containing matching string and symbol keys. See CHEF-4571.
-      expect(cookbook_as_hash["metadata"].recipes.keys).not_to include(:openldap)
-      expect(cookbook_as_hash["metadata"].recipes.keys).to include("openldap")
-      expected_desc = "Main Open LDAP configuration"
-      expect(cookbook_as_hash["metadata"].recipes["openldap"]).to eq(expected_desc)
-      raw = Chef::JSONCompat.to_json(cookbook_as_hash["metadata"].recipes)
-      search_str = "\"openldap\":\""
-      key_idx = raw.index(search_str)
-      expect(key_idx).to be > 0
-      dup_idx = raw[(key_idx + 1)..-1].index(search_str)
-      expect(dup_idx).to be_nil
-    end
-
-    it "should not load the cookbook again when accessed" do
-      cookbook_loader.send(:cookbook_version_loaders).each do |cbv_loader|
-        expect(cbv_loader).not_to receive(:load)
-      end
-      cookbook_loader["openldap"]
-    end
-
-    it "should not load the other cookbooks" do
-      seen = {}
-      cookbook_loader.each_key do |cookbook_name|
-        seen[cookbook_name] = true
-      end
-      expect(seen).not_to have_key("apache2")
-    end
-
-    it "should load another cookbook lazily with []" do
-      expect(cookbook_loader["apache2"]).to be_a_kind_of(Chef::CookbookVersion)
-    end
-
-    context "when an unrelated cookbook has invalid metadata" do
-
-      let(:repo_paths) do
-        [
-          File.join(CHEF_SPEC_DATA, "cookbooks"),
-          File.join(CHEF_SPEC_DATA, "invalid-metadata-chef-repo"),
-        ]
-      end
-
-      it "ignores the invalid cookbook" do
-        expect { cookbook_loader["openldap"] }.to_not raise_error
-      end
-
-      it "surfaces the exception if the cookbook is loaded later" do
-        expect { cookbook_loader["invalid-metadata"] }.to raise_error("THIS METADATA HAS A BUG")
-      end
-
-    end
-
-    describe "loading all cookbooks after loading only one cookbook" do
-      before(:each) do
-        cookbook_loader.load_cookbooks
-      end
-
-      it "should load all cookbooks" do
-        seen = {}
-        cookbook_loader.each_key do |cookbook_name|
-          seen[cookbook_name] = true
-        end
-        expect(seen).to have_key("openldap")
-        expect(seen).to have_key("apache2")
-      end
-    end
-  end # loading only one cookbook
-
-  describe "loading a single cookbook with a different name than basename" do
-
-    before(:each) do
-      cookbook_loader.load_cookbook("name-mismatch")
-    end
-
-    it "loads the correct cookbook" do
-      cookbook_version = cookbook_loader["name-mismatch"]
-      expect(cookbook_version).to be_a_kind_of(Chef::CookbookVersion)
-      expect(cookbook_version.name).to eq(:"name-mismatch")
-    end
-
-  end
-end