foodcritic 10.2.2 → 10.3.0

data/spec/{foodcritic → unit}/chef_spec.rb

@@ -1,4 +1,4 @@
-require_relative "../spec_helper"
+require "spec_helper"
 
 describe FoodCritic::Chef do
 
@@ -9,49 +9,49 @@ describe FoodCritic::Chef do
       api.chef_dsl_methods.each { |m| m }
     end
     it "does not return an empty" do
-      api.chef_dsl_methods.wont_be_empty
+      expect(api.chef_dsl_methods).to_not be_empty
     end
     it "returns dsl methods as symbols" do
-      assert api.chef_dsl_methods.all? { |m| m == m.to_sym }
+      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
-      lambda { api.resource_attribute?(nil, :name) }.must_raise(ArgumentError)
+      expect { api.resource_attribute?(nil, :name) }.to raise_error ArgumentError
     end
     it "raises if the resource_type is empty" do
-      lambda { api.resource_attribute?("", :name) }.must_raise(ArgumentError)
+      expect { api.resource_attribute?("", :name) }.to raise_error ArgumentError
     end
     it "raises if the attribute_name is nil" do
-      lambda { api.resource_attribute?(:file, nil) }.must_raise(ArgumentError)
+      expect { api.resource_attribute?(:file, nil) }.to raise_error ArgumentError
     end
     it "raises if the attribute_name is empty" do
-      lambda { api.resource_attribute?(:file, "") }.must_raise(ArgumentError)
+      expect { api.resource_attribute?(:file, "") }.to raise_error ArgumentError
     end
     it "returns true if the resource attribute is known" do
-      assert api.resource_attribute?(:file, :name)
+      expect(api.resource_attribute?(:file, :name)).to be_truthy
     end
     it "returns false if the resource attribute is not known" do
-      refute api.resource_attribute?(:file, :size)
+      expect(api.resource_attribute?(:file, :size)).to be_falsey
     end
     it "returns true for unrecognised resources" do
-      assert api.resource_attribute?(:cluster_file, :size)
+      expect(api.resource_attribute?(:cluster_file, :size)).to be_truthy
     end
     it "allows the resource type to be passed as a string" do
-      refute api.resource_attribute?("file", :size)
+      expect(api.resource_attribute?("file", :size)).to be_falsey
     end
     it "allows the attribute_name to be passed as a string" do
-      assert api.resource_attribute?(:file, "mode")
+      expect(api.resource_attribute?(:file, "mode")).to be_truthy
     end
   end
 
   describe "#valid_query?" do
     it "raises if the query is nil" do
-      lambda { api.valid_query?(nil) }.must_raise(ArgumentError)
+      expect { api.valid_query?(nil) }.to raise_error ArgumentError
     end
     it "raises if the query is empty" do
-      lambda { api.valid_query?("") }.must_raise(ArgumentError)
+      expect { api.valid_query?("") }.to raise_error ArgumentError
     end
     it "coerces the provided object to a string" do
       query = Class.new do
@@ -59,7 +59,7 @@ describe FoodCritic::Chef do
           "*:*"
         end
       end.new
-      assert api.valid_query?(query)
+      expect(api.valid_query?(query)).to be_truthy
     end
   end
 

data/spec/unit/command_line_spec.rb

@@ -0,0 +1,122 @@
+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
+end

data/spec/{foodcritic → unit}/domain_spec.rb

@@ -1,4 +1,4 @@
-require_relative "../spec_helper"
+require "spec_helper"
 
 describe FoodCritic::Review do
   it "is instantiable with no warnings" do
@@ -6,19 +6,19 @@ describe FoodCritic::Review do
   end
   describe "#cookbook_paths" do
     it "returns the cookbook paths provided" do
-      FoodCritic::Review.new(["example"], []).cookbook_paths.must_equal ["example"]
+      expect(FoodCritic::Review.new(["example"], []).cookbook_paths).to eq ["example"]
     end
     it "returns the cookbook paths provided when there are multiple" do
-      FoodCritic::Review.new(%w{example example2}, []).cookbook_paths.must_equal %w{example example2}
+      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
-      FoodCritic::Review.new("example", []).warnings.must_be_empty
+      expect(FoodCritic::Review.new("example", []).warnings).to be_empty
     end
     it "makes the warnings available" do
       warning = "Danger Will Robinson"
-      FoodCritic::Review.new("example", [warning]).warnings.must_equal [warning]
+      expect(FoodCritic::Review.new("example", [warning]).warnings).to eq [warning]
     end
   end
 end
@@ -33,11 +33,11 @@ describe FoodCritic::RuleList do
   describe "#rules" do
 
     it "is empty when instantiated with an empty rule list" do
-      assert FoodCritic::RuleList.new([]).rules.empty?
+      expect(FoodCritic::RuleList.new([]).rules).to be_empty
     end
 
     it "contains the given rule" do
-      assert FoodCritic::RuleList.new([rule]).rules.include?(rule)
+      expect(FoodCritic::RuleList.new([rule]).rules).to include rule
     end
   end
 end
@@ -47,17 +47,17 @@ describe FoodCritic::Rule do
 
   describe "#matches_tags?" do
     it "matches the rule's code" do
-      rule.matches_tags?(["FCTEST001"]).must_equal true
+      expect(rule.matches_tags?(["FCTEST001"])).to be_truthy
     end
 
     it "doesn't match an unrelated code" do
-      rule.matches_tags?(["FCTEST999"]).must_equal false
+      expect(rule.matches_tags?(["FCTEST999"])).to be_falsey
     end
   end
 
   describe "#tags" do
     it "returns any + the rule's code" do
-      rule.tags.must_equal %w{any FCTEST001}
+      expect(rule.tags).to eq %w{any FCTEST001}
     end
   end
 end
@@ -68,11 +68,11 @@ describe FoodCritic::Warning do
 
   describe "failure indication" do
     it "is false if no fail_tags match" do
-      FoodCritic::Warning.new(rule, match_opts, { :fail_tags => [] }).failed?.must_equal false
+      expect(FoodCritic::Warning.new(rule, match_opts, { :fail_tags => [] })).to_not be_failed
     end
 
     it "is true if fail_tags do match" do
-      FoodCritic::Warning.new(rule, match_opts, { :fail_tags => ["any"] }).failed?.must_equal true
+      expect(FoodCritic::Warning.new(rule, match_opts, { :fail_tags => ["any"] })).to be_failed
     end
   end
 end

data/spec/{foodcritic → unit}/linter_spec.rb

@@ -1,33 +1,33 @@
-require_relative "../spec_helper"
+require "spec_helper"
 
 describe FoodCritic::Linter do
   let(:linter) { FoodCritic::Linter.new }
 
   describe "#initialize" do
     it "is instantiable" do
-      linter.wont_be_nil
+      # Check for errors from .new
+      linter
     end
   end
 
   describe "chef version" do
     it "should be the latest stable version of Chef" do
-      FoodCritic::Linter::DEFAULT_CHEF_VERSION.must_equal "12.19.36"
+      expect(FoodCritic::Linter::DEFAULT_CHEF_VERSION).to eq "12.19.36"
     end
   end
 
   describe "#check" do
-
     it "requires a cookbook_path, role_path or environment_path to be specified" do
-      lambda { linter.check({}) }.must_raise ArgumentError
+      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
-        lambda { linter.check(key => nil) }.must_raise ArgumentError
+        expect { linter.check(key => nil) }.to raise_error ArgumentError
       end
       it "requires a #{path_type}_path by itself not to be empty" do
-        lambda { linter.check(key => []) }.must_raise ArgumentError
+        expect { linter.check(key => []) }.to raise_error ArgumentError
       end
       it "accepts a scalar with a single #{path_type} path" do
         linter.check(key => ".")
@@ -36,20 +36,23 @@ describe FoodCritic::Linter do
         linter.check(key => ["."])
       end
       it "returns a review when a #{path_type} path is provided" do
-        linter.check(key => ["."]).must_respond_to(:warnings)
+        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
-      linter.list(:list => true).must_respond_to(:rules)
+      expect(linter.list(:list => true)).to respond_to :rules
     end
   end
 
@@ -59,42 +62,24 @@ describe FoodCritic::Linter do
       Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "../../lib/foodcritic/rules/*")))
     end
 
-    let(:rule_dsl_load_mock) { MiniTest::Mock.new }
-
     it "should add the default rule file" do
-      rule_dsl_load_mock.expect(:call, nil, [default_rule_files, nil])
-      verify_loaded
+      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]
-      rule_dsl_load_mock.expect(:call, nil, [expected_rules, nil])
-
-      metaclass = class << linter; self; end
-      metaclass.send(:define_method, :rule_files_in_gems) do
-        gem_rules
-      end
-
-      verify_loaded :search_gems => true
+      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]
-      rule_dsl_load_mock.expect(:call, nil, [expected_rules, nil])
-
-      verify_loaded :include_rules => include_rules
+      expect(FoodCritic::RuleDsl).to receive(:load).with(expected_rules, nil)
+      linter.load_rules!(:include_rules => include_rules)
     end
-
-    def verify_loaded(options = {})
-      FoodCritic::RuleDsl.stub :load, rule_dsl_load_mock do
-        linter.load_rules! options
-      end
-
-      rule_dsl_load_mock.verify
-    end
-
   end
-
 end

data/spec/{foodcritic → unit}/template_spec.rb

@@ -1,23 +1,23 @@
-require_relative "../spec_helper"
+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
-      extractor.extract("").must_be_empty
+      expect(extractor.extract("")).to be_empty
     end
     it "returns empty if the template contains no erb at all" do
-      extractor.extract(%q{
+      expect(extractor.extract(%q{
         Hello World!
-      }).must_be_empty
+      })).to be_empty
     end
     it "returns erb conditionals" do
-      extractor.extract(%q{
+      expect(extractor.extract(%q{
         <% if true %>
           Hello World!
         <% end %>
-      }).must_equal([{ :type => :statement, :code => "if true", :line => 2 },
-                     { :type => :statement, :code => "end", :line => 4 }])
+      })).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{
@@ -25,9 +25,9 @@ describe FoodCritic::Template::ExpressionExtractor do
       })
     end
     it "extracts an expression from within the template" do
-      extractor.extract(%q{
+      expect(extractor.extract(%q{
         <%= foo %>
-      }).must_equal([{ :type => :expression, :code => "foo", :line => 2 }])
+      })).to eq [{ :type => :expression, :code => "foo", :line => 2 }]
     end
     it "does not evaluate erb expressions" do
       extractor.extract(%q{
@@ -35,18 +35,18 @@ describe FoodCritic::Template::ExpressionExtractor do
       })
     end
     it "extracts multiple expressions" do
-      extractor.extract(%q{
+      expect(extractor.extract(%q{
         <Connector port="<%= node["tomcat"]["port"] %>" protocol="HTTP/1.1"
                    connectionTimeout="20000"
                    URIEncoding="UTF-8"
                    redirectPort="<%= node["tomcat"]["ssl_port"] %>" />
-      }).must_equal([
+      })).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
-      extractor.extract("<%# A comment %>").must_be_empty
+      expect(extractor.extract("<%# A comment %>")).to be_empty
     end
   end