foodcritic 15.0.0 → 15.1.0

data/spec/unit/chef_spec.rb

@@ -1,66 +0,0 @@
-require "spec_helper"
-
-describe FoodCritic::Chef do
-
-  let(:api) { Object.new.extend(FoodCritic::Api) }
-
-  describe "#chef_dsl_methods" do
-    it "returns an enumerable" do
-      api.chef_dsl_methods.each { |m| m }
-    end
-    it "does not return an empty" do
-      expect(api.chef_dsl_methods).to_not be_empty
-    end
-    it "returns dsl methods as symbols" do
-      expect(api.chef_dsl_methods.all? { |m| m == m.to_sym }).to be_truthy
-    end
-  end
-
-  describe "#resource_attribute?" do
-    it "raises if the resource_type is nil" do
-      expect { api.resource_attribute?(nil, :name) }.to raise_error ArgumentError
-    end
-    it "raises if the resource_type is empty" do
-      expect { api.resource_attribute?("", :name) }.to raise_error ArgumentError
-    end
-    it "raises if the attribute_name is nil" do
-      expect { api.resource_attribute?(:file, nil) }.to raise_error ArgumentError
-    end
-    it "raises if the attribute_name is empty" do
-      expect { api.resource_attribute?(:file, "") }.to raise_error ArgumentError
-    end
-    it "returns true if the resource attribute is known" do
-      expect(api.resource_attribute?(:file, :name)).to be_truthy
-    end
-    it "returns false if the resource attribute is not known" do
-      expect(api.resource_attribute?(:file, :size)).to be_falsey
-    end
-    it "returns true for unrecognised resources" do
-      expect(api.resource_attribute?(:cluster_file, :size)).to be_truthy
-    end
-    it "allows the resource type to be passed as a string" do
-      expect(api.resource_attribute?("file", :size)).to be_falsey
-    end
-    it "allows the attribute_name to be passed as a string" do
-      expect(api.resource_attribute?(:file, "mode")).to be_truthy
-    end
-  end
-
-  describe "#valid_query?" do
-    it "raises if the query is nil" do
-      expect { api.valid_query?(nil) }.to raise_error ArgumentError
-    end
-    it "raises if the query is empty" do
-      expect { api.valid_query?("") }.to raise_error ArgumentError
-    end
-    it "coerces the provided object to a string" do
-      query = Class.new do
-        def to_s
-          "*:*"
-        end
-      end.new
-      expect(api.valid_query?(query)).to be_truthy
-    end
-  end
-
-end

data/spec/unit/command_line_spec.rb

@@ -1,136 +0,0 @@
-require "spec_helper"
-
-describe FoodCritic::CommandLine do
-  it "is instantiable" do
-    expect(FoodCritic::CommandLine.new([])).to_not be_nil
-  end
-
-  describe "#cookbook_paths" do
-    it "returns an empty array if no paths are specified" do
-      expect(FoodCritic::CommandLine.new([]).cookbook_paths).to be_empty
-    end
-
-    it "returns a single item array for a specified directory" do
-      expect(FoodCritic::CommandLine.new(["example"]).cookbook_paths).to eq ["example"]
-    end
-
-    it "returns multiple items for multiple specified directories" do
-      expect(FoodCritic::CommandLine.new(%w{example another_example}).cookbook_paths).to eq %w{example another_example}
-    end
-
-    it "ignores known arguments" do
-      expect(FoodCritic::CommandLine.new(["example", "--context"]).cookbook_paths).to eq ["example"]
-    end
-  end
-
-  describe "#role_paths" do
-    it "returns an empty if no role paths are specified" do
-      expect(FoodCritic::CommandLine.new([]).role_paths).to be_empty
-    end
-    it "returns the provided role path" do
-      expect(FoodCritic::CommandLine.new(["-R", "roles"]).role_paths).to eq %w{roles}
-    end
-    it "returns the provided role paths when there are multiple" do
-      expect(FoodCritic::CommandLine.new(["-R", "roles1",
-        "-R", "roles2"]).role_paths).to eq %w{roles1 roles2}
-    end
-  end
-
-  describe "#valid_paths?" do
-    it "returns false if no paths are specified" do
-      expect(FoodCritic::CommandLine.new([]).valid_paths?).to be_falsey
-    end
-
-    it "returns true if the specified directory exists" do
-      expect(FoodCritic::CommandLine.new(["lib"]).valid_paths?).to be_truthy
-    end
-
-    it "returns false if the specified directory does not exist" do
-      expect(FoodCritic::CommandLine.new(["lib2"]).valid_paths?).to be_falsey
-    end
-
-    it "returns true if the specified file exists" do
-      expect(FoodCritic::CommandLine.new(["lib/foodcritic.rb"]).valid_paths?).to be_truthy
-    end
-
-    it "returns true if both specified paths exist" do
-      expect(FoodCritic::CommandLine.new(["lib", "lib/foodcritic.rb"]).valid_paths?).to be_truthy
-    end
-
-    it "returns false if any on the specified paths do not exist" do
-      expect(FoodCritic::CommandLine.new(%w{lib lib2}).valid_paths?).to be_falsey
-    end
-  end
-
-  describe "#list_rules?" do
-    it "returns false if ---list is not specified" do
-      expect(FoodCritic::CommandLine.new([]).list_rules?).to be_falsey
-    end
-
-    it "returns true if --list is specified" do
-      expect(FoodCritic::CommandLine.new(["--list"]).list_rules?).to be_truthy
-    end
-  end
-
-  describe ":progress" do
-    it "is true by default" do
-      expect(FoodCritic::CommandLine.new(["."]).options[:progress]).to be_truthy
-    end
-
-    it "is true if -P is specified" do
-      expect(FoodCritic::CommandLine.new(["-P", "."]).options[:progress]).to be_truthy
-    end
-
-    it "is true if --progres is specified" do
-      expect(FoodCritic::CommandLine.new(["--progress", "."]).options[:progress]).to be_truthy
-    end
-
-    it "is false if --no-progress is specified" do
-      expect(FoodCritic::CommandLine.new(["--no-progress", "."]).options[:progress]).to be_falsey
-    end
-  end
-
-  describe ":search_gems" do
-    it "is unset if -G/--search-gems is not specified" do
-      expect(FoodCritic::CommandLine.new(["."]).options[:search_gems].nil?).to be_truthy
-    end
-
-    it "is true if -G is specified" do
-      expect(FoodCritic::CommandLine.new(["-G", "."]).options[:search_gems]).to be_truthy
-    end
-
-    it "is true if --search-gems is specified" do
-      expect(FoodCritic::CommandLine.new(["--search-gems", "."]).options[:search_gems]).to be_truthy
-    end
-  end
-
-  describe "#show_context?" do
-    it "is unset by default" do
-      expect(FoodCritic::CommandLine.new(["."]).show_context?).to be_falsey
-    end
-
-    it "is true if -C is specified" do
-      expect(FoodCritic::CommandLine.new(["-C", "."]).show_context?).to be_truthy
-    end
-    it "is true if --context is specified" do
-      expect(FoodCritic::CommandLine.new(["--context", "."]).show_context?).to be_truthy
-    end
-    it "is false if --no-context is specified" do
-      expect(FoodCritic::CommandLine.new(["--no-context", "."]).show_context?).to be_falsey
-    end
-  end
-
-  describe ":rule_file" do
-    it "is unset if -r/--rule-file is not specified" do
-      expect(FoodCritic::CommandLine.new(["."]).options[:rule_file].nil?).to be_truthy
-    end
-
-    it "is equal to the provided path if -r is set and path is specified" do
-      expect(FoodCritic::CommandLine.new(["-r", "example", "."]).options[:rule_file]).to eq "example"
-    end
-
-    it "is equal to the provided path if --rule-file is set and path is specified" do
-      expect(FoodCritic::CommandLine.new(["--rule-file", "example", "."]).options[:rule_file]).to eq "example"
-    end
-  end
-end

data/spec/unit/domain_spec.rb

@@ -1,78 +0,0 @@
-require "spec_helper"
-
-describe FoodCritic::Review do
-  it "is instantiable with no warnings" do
-    FoodCritic::Review.new("example", [])
-  end
-  describe "#cookbook_paths" do
-    it "returns the cookbook paths provided" do
-      expect(FoodCritic::Review.new(["example"], []).cookbook_paths).to eq ["example"]
-    end
-    it "returns the cookbook paths provided when there are multiple" do
-      expect(FoodCritic::Review.new(%w{example example2}, []).cookbook_paths).to eq %w{example example2}
-    end
-  end
-  describe "#warnings" do
-    it "returns empty when there are no warnings" do
-      expect(FoodCritic::Review.new("example", []).warnings).to be_empty
-    end
-    it "makes the warnings available" do
-      warning = "Danger Will Robinson"
-      expect(FoodCritic::Review.new("example", [warning]).warnings).to eq [warning]
-    end
-  end
-end
-
-describe FoodCritic::RuleList do
-  it "is instantiable with no warnings" do
-    FoodCritic::RuleList.new([])
-  end
-
-  let(:rule) { FoodCritic::Rule.new("FCTEST001", "Test rule") }
-
-  describe "#rules" do
-
-    it "is empty when instantiated with an empty rule list" do
-      expect(FoodCritic::RuleList.new([]).rules).to be_empty
-    end
-
-    it "contains the given rule" do
-      expect(FoodCritic::RuleList.new([rule]).rules).to include rule
-    end
-  end
-end
-
-describe FoodCritic::Rule do
-  let(:rule) { FoodCritic::Rule.new("FCTEST001", "Test rule") }
-
-  describe "#matches_tags?" do
-    it "matches the rule's code" do
-      expect(rule.matches_tags?(["FCTEST001"])).to be_truthy
-    end
-
-    it "doesn't match an unrelated code" do
-      expect(rule.matches_tags?(["FCTEST999"])).to be_falsey
-    end
-  end
-
-  describe "#tags" do
-    it "returns any + the rule's code" do
-      expect(rule.tags).to eq %w{any FCTEST001}
-    end
-  end
-end
-
-describe FoodCritic::Warning do
-  let(:rule) { FoodCritic::Rule.new("FCTEST001", "Test rule") }
-  let(:match_opts) { { filename: "foo/recipes.default.rb", line: 5, column: 40 } }
-
-  describe "failure indication" do
-    it "is false if no fail_tags match" do
-      expect(FoodCritic::Warning.new(rule, match_opts, { fail_tags: [] })).to_not be_failed
-    end
-
-    it "is true if fail_tags do match" do
-      expect(FoodCritic::Warning.new(rule, match_opts, { fail_tags: ["any"] })).to be_failed
-    end
-  end
-end

data/spec/unit/linter_spec.rb

@@ -1,107 +0,0 @@
-require "spec_helper"
-
-describe FoodCritic::Linter do
-  let(:linter) { FoodCritic::Linter.new }
-
-  describe "#initialize" do
-    it "is instantiable" do
-      # Check for errors from .new
-      linter
-    end
-  end
-
-  describe "chef version" do
-    it "should be the latest stable version of Chef" do
-      expect(FoodCritic::Linter::DEFAULT_CHEF_VERSION).to eq "14.7.17"
-    end
-  end
-
-  describe "#cookbook_dir" do
-    it "given a root alias file the cookbook is correctly detected" do
-      expect(linter.send(:cookbook_dir, "./cookbook/recipe.rb").to_s).to eq "cookbook"
-    end
-
-    it "given the metadata.rb file the cookbook is correctly detected" do
-      expect(linter.send(:cookbook_dir, "./cookbook/metadata.rb").to_s).to eq "cookbook"
-    end
-
-    it "given a template nested multiple levels deep the cookbook is correctly detected" do
-      expect(linter.send(:cookbook_dir, "./cookbook/templates/foo/bar/file.erb").to_s).to eq "./cookbook"
-    end
-
-    it "given a template directly in the templates directory the cookbook is correctly detected" do
-      expect(linter.send(:cookbook_dir, "./cookbook/templates/file.erb").to_s).to eq "./cookbook"
-    end
-
-    it "given a standard recipe file the cookbook is correctly detected" do
-      expect(linter.send(:cookbook_dir, "./cookbook/recipes/default.rb").to_s).to eq "cookbook"
-    end
-  end
-
-  describe "#check" do
-    it "requires a cookbook_path, role_path or environment_path to be specified" do
-      expect { linter.check({}) }.to raise_error ArgumentError
-    end
-
-    [:cookbook, :role, :environment].each do |path_type|
-      key = "#{path_type}_paths".to_sym
-      it "requires a #{path_type}_path by itself not to be nil" do
-        expect { linter.check(key => nil) }.to raise_error ArgumentError
-      end
-      it "requires a #{path_type}_path by itself not to be empty" do
-        expect { linter.check(key => []) }.to raise_error ArgumentError
-      end
-      it "accepts a scalar with a single #{path_type} path" do
-        linter.check(key => ".")
-      end
-      it "accepts an array of #{path_type} paths" do
-        linter.check(key => ["."])
-      end
-      it "returns a review when a #{path_type} path is provided" do
-        expect(linter.check(key => ["."])).to respond_to :warnings
-      end
-    end
-  end
-
-  describe "#list_rules" do
-    it "runs when --list is specified on the command line" do
-      cli = FoodCritic::CommandLine.new %w{--list -t FC001 --search-gems}
-      FoodCritic::Linter.run(cli)
-    end
-
-    it "does not require cookbook_path, role_path or environment_path to be specified" do
-      linter.list(list: true)
-    end
-
-    it "returns a rule listing" do
-      expect(linter.list(list: true)).to respond_to :rules
-    end
-  end
-
-  describe "#load_files!" do
-    let(:default_rule_files) do
-      # an array of each of the absolute paths to the default rules
-      Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "../../lib/foodcritic/rules/*")))
-    end
-
-    it "should add the default rule file" do
-      expect(FoodCritic::RuleDsl).to receive(:load).with(default_rule_files, nil)
-      linter.load_rules!({})
-    end
-
-    it "should include rules found in gems if the :search_gems option is true" do
-      gem_rules = ["/path/to/rules1.rb", "/path/to/rules2.rb"]
-      expected_rules = [*default_rule_files, *gem_rules]
-      expect(FoodCritic::RuleDsl).to receive(:load).with(expected_rules, nil)
-      expect(linter).to receive(:rule_files_in_gems).and_return(gem_rules)
-      linter.load_rules!(search_gems: true)
-    end
-
-    it "should include files found in :include_rules option" do
-      include_rules = ["/path/to/rules1.rb", "/path/to/rules2.rb"]
-      expected_rules = [*default_rule_files, *include_rules]
-      expect(FoodCritic::RuleDsl).to receive(:load).with(expected_rules, nil)
-      linter.load_rules!(include_rules: include_rules)
-    end
-  end
-end

data/spec/unit/template_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe FoodCritic::Template::ExpressionExtractor do
-  let(:extractor) { FoodCritic::Template::ExpressionExtractor.new }
-  describe "#expressions" do
-    it "returns empty if the template is empty" do
-      expect(extractor.extract("")).to be_empty
-    end
-    it "returns empty if the template contains no erb at all" do
-      expect(extractor.extract(%q{
-        Hello World!
-      })).to be_empty
-    end
-    it "returns erb conditionals" do
-      expect(extractor.extract(%q{
-        <% if true %>
-          Hello World!
-        <% end %>
-      })).to eq [{ type: :statement, code: "if true", line: 2 },
-                 { type: :statement, code: "end", line: 4 }]
-    end
-    it "does not evaluate erb statements" do
-      extractor.extract(%q{
-        <% raise 'Should not have been evaluated' %>
-      })
-    end
-    it "extracts an expression from within the template" do
-      expect(extractor.extract(%q{
-        <%= foo %>
-      })).to eq [{ type: :expression, code: "foo", line: 2 }]
-    end
-    it "does not evaluate erb expressions" do
-      extractor.extract(%q{
-        <%= raise 'Should not have been evaluated' %>
-      })
-    end
-    it "extracts multiple expressions" do
-      expect(extractor.extract(%q{
-        <Connector port="<%= node["tomcat"]["port"] %>" protocol="HTTP/1.1"
-                   connectionTimeout="20000"
-                   URIEncoding="UTF-8"
-                   redirectPort="<%= node["tomcat"]["ssl_port"] %>" />
-      })).to eq [
-        { type: :expression, code: 'node["tomcat"]["port"]', line: 2 },
-        { type: :expression, code: 'node["tomcat"]["ssl_port"]', line: 5 },
-      ]
-    end
-    it "excludes comment-only expressions" do
-      expect(extractor.extract("<%# A comment %>")).to be_empty
-    end
-  end
-
-end