cuke_linter 0.11.1 → 0.12.0

data/testing/cucumber/step_definitions/setup_steps.rb

@@ -29,6 +29,10 @@ Given(/^a linter for features with invalid file names$/) do
   @linter = CukeLinter::FeatureFileWithInvalidNameLinter.new
 end
 
+And(/^a linter for features with mismatched file names$/) do
+  @linter = CukeLinter::FeatureFileWithMismatchedNameLinter.new
+end
+
 Given(/^no other linters have been registered or unregistered$/) do
   CukeLinter.reset_linters
 end
@@ -89,6 +93,10 @@ Given(/^a linter for elements with too many tags has been registered$/) do
   CukeLinter.register_linter(linter: CukeLinter::ElementWithTooManyTagsLinter.new, name: 'ElementWithTooManyTagsLinter')
 end
 
+Given(/^a linter for elements with duplicate tags has been registered$/) do
+  CukeLinter.register_linter(linter: CukeLinter::ElementWithDuplicateTagsLinter.new, name: 'ElementWithDuplicateTagsLinter')
+end
+
 Given(/^a linter for tests with too many steps has been registered$/) do
   CukeLinter.register_linter(linter: CukeLinter::TestWithTooManyStepsLinter.new, name: 'TestWithTooManyStepsLinter')
 end
@@ -121,6 +129,14 @@ Given(/^a linter for tests with an action step as the final step$/) do
   @linter = CukeLinter::TestWithActionStepAsFinalStepLinter.new
 end
 
+Given(/^a linter for elements with duplicate tags$/) do
+  @linter = CukeLinter::ElementWithDuplicateTagsLinter.new
+end
+
+Given(/^a linter for elements with common tags$/) do
+  @linter = CukeLinter::ElementWithCommonTagsLinter.new
+end
+
 Given(/^a linter for test steps with too many characters has been registered$/) do
   CukeLinter.register_linter(linter: CukeLinter::StepWithTooManyCharactersLinter.new, name: 'StepWithTooManyCharactersLinter')
 end
@@ -203,3 +219,12 @@ Given(/^a feature file model named "([^"]*)"$/) do |file_path|
 
   @model.path = file_path
 end
+
+Given(/^a feature file model based on the file "([^"]*)" with the following text:$/) do |file_name, text|
+  file_path = CukeLinter::FileHelper.create_file(directory: @root_test_directory, extension: '.feature', text: text, name: file_name)
+
+  @created_files ||= []
+  @created_files << file_path
+
+  @model = CukeModeler::FeatureFile.new(file_path)
+end

data/testing/gemfiles/cuke_modeler1.gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in cuke_linter.gemspec
+gemspec :path => "../../"
+
+gem 'cuke_modeler', '~> 1.0'

data/testing/gemfiles/cuke_modeler2.gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in cuke_linter.gemspec
+gemspec :path => "../../"
+
+gem 'cuke_modeler', '~> 2.0'

data/testing/model_factory.rb

@@ -7,6 +7,12 @@ module CukeLinter
     include CukeModeler::Sourceable
     include CukeModeler::Taggable
 
+    def initialize
+      super
+
+      @tags = []
+    end
+
   end
 end
 
@@ -24,11 +30,13 @@ module CukeLinter
       model              = CukeModeler::Feature.new(source_text)
       model.parent_model = fake_parent_model
 
+      fake_parent_model.feature = model
+
       model
     end
 
     def self.generate_feature_file_model
-      model              = CukeModeler::FeatureFile.new
+      model = CukeModeler::FeatureFile.new
 
       model
     end
@@ -42,7 +50,7 @@ module CukeLinter
       model
     end
 
-    def self.generate_outline_model(source_text: "Scenario Outline:\n*a step\nExamples:\n|param|", parent_file_path: 'path_to_file')
+    def self.generate_outline_model(source_text: "Scenario Outline:", parent_file_path: 'path_to_file')
       fake_parent_model = generate_feature_model(parent_file_path: parent_file_path)
 
       model              = CukeModeler::Outline.new(source_text)
@@ -78,6 +86,10 @@ module CukeLinter
       model
     end
 
+    def self.generate_tag_model(source_text: '@a_tag')
+      CukeModeler::Tag.new(source_text)
+    end
+
     def self.generate_lintable_model(parent_file_path: 'path_to_file', source_line: 1, children: [])
       fake_file_model      = CukeModeler::FeatureFile.new
       fake_file_model.path = parent_file_path

data/testing/rspec/spec/integration/cli_integration_spec.rb

@@ -99,7 +99,7 @@ RSpec.describe 'the Command Line Interface' do
       let!(:linted_file) { CukeLinter::FileHelper.create_file(directory: test_directory,
                                                               name:      'nothing_wrong',
                                                               extension: '.feature',
-                                                              text:      'Feature: A name
+                                                              text:      'Feature: Nothing wrong
                                                                             A description
                                                                             Scenario: A scenario
                                                                               When a step
@@ -148,14 +148,14 @@ RSpec.describe 'the Command Line Interface' do
 
           context 'with path arguments' do
             let(:file_1) { CukeLinter::FileHelper.create_file(directory: test_directory,
-                                                              name:      'some',
+                                                              name:      'some_feature',
                                                               extension: '.feature',
                                                               text:      'Feature: Some feature
                                                                           Scenario: A scenario
                                                                             When a step
                                                                             Then a step') }
             let(:file_2) { CukeLinter::FileHelper.create_file(directory: test_directory,
-                                                              name:      'a_directory/with_a',
+                                                              name:      'a_directory/with/some_feature',
                                                               extension: '.feature',
                                                               text:      'Feature: Some feature
                                                                           Scenario: A scenario
@@ -165,12 +165,13 @@ RSpec.describe 'the Command Line Interface' do
             let(:file_2_directory) { File.dirname(file_2) }
             let(:command) { "bundle exec ruby #{executable_path} #{flag} #{file_1_path} #{flag} #{file_2_directory}" }
 
+            # TODO: add a negative test that makes sure that non-included paths aren't linted when paths are explicitly included
 
             it "lints that locations specified by '#{path_flag}'" do
               expect(results[:std_out]).to eq(['FeatureWithoutDescriptionLinter',
                                                '  Feature has no description',
-                                               '    <path_to>/a_directory/with_a.feature:1',
-                                               '    <path_to>/some.feature:1',
+                                               '    <path_to>/a_directory/with/some_feature.feature:1',
+                                               '    <path_to>/some_feature.feature:1',
                                                '',
                                                '2 issues found',
                                                ''].join("\n").gsub('<path_to>', test_directory))
@@ -209,7 +210,7 @@ RSpec.describe 'the Command Line Interface' do
           let(:flag) { formatter_flag }
 
           context 'with formatter arguments' do
-            let(:linted_file) { CukeLinter::FileHelper.create_file(name:      'some',
+            let(:linted_file) { CukeLinter::FileHelper.create_file(name:      'some_feature',
                                                                    extension: '.feature',
                                                                    text:      'Feature: Some feature
                                                                                Scenario: A scenario
@@ -275,7 +276,7 @@ RSpec.describe 'the Command Line Interface' do
           context 'with output arguments' do
             let(:output_location) { "#{CukeLinter::FileHelper.create_directory}/output.txt" }
             let(:other_output_location) { "#{CukeLinter::FileHelper.create_directory}/other_output.txt" }
-            let(:linted_file) { CukeLinter::FileHelper.create_file(name:      'some',
+            let(:linted_file) { CukeLinter::FileHelper.create_file(name:      'some_feature',
                                                                    extension: '.feature',
                                                                    text:      'Feature: Some feature
                                                                                Scenario: A scenario

data/testing/rspec/spec/integration/cuke_linter_integration_spec.rb

@@ -81,6 +81,8 @@ RSpec.describe CukeLinter do
       linting_options.delete(:model_trees)
     end
 
+    # TODO: add a negative test that makes sure that non-included paths aren't linted when paths are explicitly included
+
     it 'lints every model in each path' do
       results = subject.lint(linting_options)
 
@@ -177,9 +179,12 @@ RSpec.describe CukeLinter do
     subject.reset_linters
 
     default_linter_classes = ['BackgroundDoesMoreThanSetupLinter',
+                              'ElementWithCommonTagsLinter',
+                              'ElementWithDuplicateTagsLinter',
                               'ElementWithTooManyTagsLinter',
                               'ExampleWithoutNameLinter',
                               'FeatureFileWithInvalidNameLinter',
+                              'FeatureFileWithMismatchedNameLinter',
                               'FeatureWithTooManyDifferentTagsLinter',
                               'FeatureWithoutDescriptionLinter',
                               'FeatureWithoutNameLinter',

data/testing/rspec/spec/integration/linters/element_with_common_tags_linter_integration_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::ElementWithCommonTagsLinter do
+
+  it_should_behave_like 'a linter at the integration level'
+
+end

data/testing/rspec/spec/integration/linters/element_with_duplicate_tags_linter_integration_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::ElementWithDuplicateTagsLinter do
+
+  it_should_behave_like 'a linter at the integration level'
+
+end

data/testing/rspec/spec/integration/linters/feature_file_with_mismatched_name_integration_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::FeatureFileWithMismatchedNameLinter do
+
+  it_should_behave_like 'a linter at the integration level'
+
+end

data/testing/rspec/spec/unit/linters/element_with_common_tags_linter_unit_spec.rb

@@ -0,0 +1,248 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::ElementWithCommonTagsLinter do
+
+  let(:model_file_path) { 'some_file_path' }
+
+  it_should_behave_like 'a linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('ElementWithCommonTagsLinter')
+  end
+
+  describe 'linting' do
+
+    ELEMENTS_WITH_TAGGABLE_CHILDREN.each do |model_type|
+
+      context "with a #{model_type} that has common tags on all of its children" do
+
+        let(:test_model) do
+          model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
+
+          2.times do
+            child_model      = CukeLinter::ModelFactory.generate_lintable_model
+            child_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@same')]
+
+            case model_type
+              when 'feature'
+                model.tests << child_model
+              when 'outline'
+                model.examples << child_model
+              else
+                raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
+            end
+
+          end
+
+          model
+        end
+
+        it_should_behave_like 'a linter linting a bad model'
+
+
+        it 'records a problem' do
+          result = subject.lint(test_model)
+
+          case model_type
+            when 'feature'
+              expect(result[:problem]).to match(/^All tests in Feature have tag '@\w+'\. Move tag to Feature level\.$/)
+            when 'outline'
+              expect(result[:problem]).to match(/^All Examples in Outline have tag '@\w+'\. Move tag to Outline level\.$/)
+            else
+              raise(ArgumentError, "Don't know how to verify a '#{model_type}'. Add a new case?")
+          end
+        end
+
+        it 'includes the name of the common tag found in the problem record' do
+          common_tag = test_model.children.first.tags.first.name
+          result     = subject.lint(test_model)
+          expect(result[:problem]).to match(/have tag '#{common_tag}'\./)
+
+          test_model.children.first.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@still_same')]
+          test_model.children.last.tags  = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@still_same')]
+
+          common_tag = test_model.children.first.tags.first.name
+          result     = subject.lint(test_model)
+          expect(result[:problem]).to match(/have tag '#{common_tag}'\./)
+        end
+
+      end
+
+      context "with a #{model_type} that does not have common tags on all of its children" do
+
+        context 'because none of their tags are common' do
+
+          let(:test_model) do
+            model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
+
+            2.times do |count|
+              child_model      = CukeLinter::ModelFactory.generate_lintable_model
+              child_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: "@tag_#{count}")]
+
+              case model_type
+                when 'feature'
+                  model.tests << child_model
+                when 'outline'
+                  model.examples << child_model
+                else
+                  raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
+              end
+
+            end
+
+            model
+          end
+
+          it_should_behave_like 'a linter linting a good model'
+
+        end
+
+        context 'because some of them have no tags' do
+
+          context 'because their tags are empty' do
+
+            let(:test_model) do
+              model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
+
+              2.times do
+                child_model      = CukeLinter::ModelFactory.generate_lintable_model
+                child_model.tags = []
+
+                case model_type
+                  when 'feature'
+                    model.tests << child_model
+                  when 'outline'
+                    model.examples << child_model
+                  else
+                    raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
+                end
+
+              end
+
+              model
+            end
+
+            it_should_behave_like 'a linter linting a good model'
+
+          end
+
+          context 'because their tags are nil' do
+
+            let(:test_model) do
+              model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
+
+              2.times do
+                child_model      = CukeLinter::ModelFactory.generate_lintable_model
+                child_model.tags = nil
+
+                case model_type
+                  when 'feature'
+                    model.tests << child_model
+                  when 'outline'
+                    model.examples << child_model
+                  else
+                    raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
+                end
+
+              end
+
+              model
+            end
+
+            it_should_behave_like 'a linter linting a good model'
+
+          end
+
+        end
+
+        context 'because the model only has one child' do
+
+          let(:test_model) do
+            model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
+
+            1.times do
+              child_model      = CukeLinter::ModelFactory.generate_lintable_model
+              child_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@a_tag')]
+
+              case model_type
+                when 'feature'
+                  model.tests << child_model
+                when 'outline'
+                  model.examples << child_model
+                else
+                  raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
+              end
+
+            end
+
+            model
+          end
+
+          it_should_behave_like 'a linter linting a good model'
+
+        end
+
+        context 'because the model has no children' do
+
+          context 'because the children are empty' do
+
+            let(:test_model) do
+              model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
+
+              case model_type
+                when 'feature'
+                  model.tests = []
+                when 'outline'
+                  model.examples = []
+                else
+                  raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
+              end
+
+              model
+            end
+
+            it_should_behave_like 'a linter linting a good model'
+
+          end
+
+          context 'because the children are nil' do
+
+            let(:test_model) do
+              model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
+
+              case model_type
+                when 'feature'
+                  model.tests = nil
+                when 'outline'
+                  model.examples = nil
+                else
+                  raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
+              end
+
+              model
+            end
+
+            it_should_behave_like 'a linter linting a good model'
+
+          end
+
+        end
+
+      end
+
+    end
+
+
+    context 'a model that is not a type that has taggable children' do
+
+      let(:test_model) { CukeModeler::Model.new }
+
+      it_should_behave_like 'a linter linting a good model'
+
+    end
+
+  end
+
+end