cuke_linter 0.1.0 → 0.2.0

data/lib/cuke_linter.rb

@@ -2,29 +2,42 @@ require 'cuke_modeler'
 
 require "cuke_linter/version"
 require 'cuke_linter/formatters/pretty_formatter'
+require 'cuke_linter/linters/example_without_name_linter'
 require 'cuke_linter/linters/feature_without_scenarios_linter'
+require 'cuke_linter/linters/outline_with_single_example_row_linter'
+require 'cuke_linter/linters/test_with_too_many_steps_linter'
 
 
+# The top level namespace used by this gem
+
 module CukeLinter
 
-  @registered_linters = { 'FeatureWithoutScenariosLinter' => FeatureWithoutScenariosLinter.new }
+  @registered_linters = { 'FeatureWithoutScenariosLinter'     => FeatureWithoutScenariosLinter.new,
+                          'ExampleWithoutNameLinter'          => ExampleWithoutNameLinter.new,
+                          'OutlineWithSingleExampleRowLinter' => OutlineWithSingleExampleRowLinter.new,
+                          'TestWithTooManyStepsLinter'        => TestWithTooManyStepsLinter.new }
 
+  # Registers for linting use the given linter object, tracked by the given name
   def self.register_linter(linter:, name:)
     @registered_linters[name] = linter
   end
 
+  # Unregisters the linter object tracked by the given name so that it is not used for linting
   def self.unregister_linter(name)
     @registered_linters.delete(name)
   end
 
+  # Lists the names of the currently registered linting objects
   def self.registered_linters
     @registered_linters
   end
 
+  # Unregisters all currently registered linting objects
   def self.clear_registered_linters
     @registered_linters.clear
   end
 
+  # Lints the tree of model objects rooted at the given model using the given linting objects and formatting the results with the given formatters and their respective output locations
   def self.lint(model_tree: CukeModeler::Directory.new(Dir.pwd), linters: @registered_linters.values, formatters: [[CukeLinter::PrettyFormatter.new]])
     # puts "model tree: #{model_tree}"
     # puts "linters: #{linters}"

data/testing/cucumber/features/linters/default_linters.feature

@@ -1,7 +1,14 @@
 Feature: Default Linters
 
+  As a user of cuke_linter
+  I want a default set of linters to be used
+  So that I don't have to specifically include every linter
+
 
   Scenario: Using the default linters
     Given no other linters have been registered
     Then the following linters are registered by default
-      | FeatureWithoutScenariosLinter |
+      | ExampleWithoutNameLinter          |
+      | FeatureWithoutScenariosLinter     |
+      | OutlineWithSingleExampleRowLinter |
+      | TestWithTooManyStepsLinter        |

data/testing/cucumber/features/linters/example_without_name.feature

@@ -0,0 +1,27 @@
+Feature: Example without name linter
+
+  As a reader of documentation
+  I want every example to have a name
+  So that I can understand the significance of the example grouping
+
+
+  Scenario: Linting
+    Given a linter for examples without names
+    And the following feature:
+      """
+      Feature:
+
+        Scenario Outline:
+          * a step
+        Examples:
+          | param |
+          | value |
+        Examples:
+          | param |
+          | value |
+      """
+    When it is linted
+    Then an error is reported
+      | linter                   | problem             | location         |
+      | ExampleWithoutNameLinter | Example has no name | <path_to_file>:5 |
+      | ExampleWithoutNameLinter | Example has no name | <path_to_file>:8 |

data/testing/cucumber/features/linters/feature_without_scenarios.feature

@@ -1,5 +1,10 @@
 Feature: Feature without scenarios linter
 
+  As a writer of documentation
+  I want features to have at least one use case
+  So that I do not have incomplete documentation
+
+
   Scenario: Linting
     Given a linter for features without scenarios
     And the following feature:
@@ -8,5 +13,5 @@ Feature: Feature without scenarios linter
       """
     When it is linted
     Then an error is reported
-      | problem                  | location         |
-      | Feature has no scenarios | <path_to_file>:1 |
+      | linter                        | problem                  | location         |
+      | FeatureWithoutScenariosLinter | Feature has no scenarios | <path_to_file>:1 |

data/testing/cucumber/features/linters/outline_with_single_example_row.feature

@@ -0,0 +1,23 @@
+Feature: Outline with single example row linter
+
+  As a writer of documentation
+  I want outlines to have at least two example rows
+  So that I am not needlessly using an outline instead of a scenario
+
+
+  Scenario: Linting
+    Given a linter for outlines with only one example row
+    And the following feature:
+      """
+      Feature:
+
+        Scenario Outline:
+          * a step
+        Examples:
+          | param |
+          | value |
+      """
+    When it is linted
+    Then an error is reported
+      | linter                            | problem                          | location         |
+      | OutlineWithSingleExampleRowLinter | Outline has only one example row | <path_to_file>:3 |

data/testing/cucumber/features/linters/test_with_too_many_steps.feature

@@ -0,0 +1,33 @@
+Feature: Test with too many steps linter
+
+  As a reader of documentation
+  I want scenarios and outlines to not have an excessive number of steps
+  So that I can fit it all in my head at once
+
+
+  Scenario: Linting
+
+  Note: Also works on outlines
+
+    Given a linter for tests with too many steps
+    And the following feature:
+      """
+      Feature:
+
+        Scenario:
+          * step 1
+          * step 2
+          * step 3
+          * step 4
+          * step 5
+          * step 6
+          * step 7
+          * step 8
+          * step 9
+          * step 10
+          * step one too many...
+      """
+    When it is linted
+    Then an error is reported
+      | linter                     | problem                                          | location         |
+      | TestWithTooManyStepsLinter | Test has too many steps. 11 steps found (max 10) | <path_to_file>:3 |

data/testing/cucumber/step_definitions/action_steps.rb

@@ -9,5 +9,9 @@ When(/^it is formatted by the "([^"]*)" formatter$/) do |linter_name|
 end
 
 When(/^it is linted$/) do
-  @results = @linter.lint(@model)
+  options = { model_tree: @model,
+              linters:    [@linter],
+              formatters: [[CukeLinter::FormatterFactory.generate_fake_formatter, "#{CukeLinter::FileHelper::create_directory}/junk_output_file.txt"]] }
+
+  @results = CukeLinter.lint(options)
 end

data/testing/cucumber/step_definitions/setup_steps.rb

@@ -28,3 +28,15 @@ end
 Given(/^no other linters have been registered$/) do
   # There is no way to 'reset' the linters, so just assume that no changes have been made
 end
+
+Given(/^a linter for examples without names$/) do
+  @linter = CukeLinter::ExampleWithoutNameLinter.new
+end
+
+Given(/^a linter for outlines with only one example row$/) do
+  @linter = CukeLinter::OutlineWithSingleExampleRowLinter.new
+end
+
+Given(/^a linter for tests with too many steps$/) do
+  @linter = CukeLinter::TestWithTooManyStepsLinter.new
+end

data/testing/cucumber/step_definitions/verification_steps.rb

@@ -8,11 +8,12 @@ end
 
 Then(/^an error is reported$/) do |table|
   table.hashes.each do |error_record|
-    expect(@results).to include({ problem:  error_record['problem'],
+    expect(@results).to include({ linter:   error_record['linter'],
+                                  problem:  error_record['problem'],
                                   location: error_record['location'].sub('<path_to_file>', @model.get_ancestor(:feature_file).path) })
   end
 end
 
 Then(/^the following linters are registered by default$/) do |linter_names|
-  expect(CukeLinter.registered_linters.keys).to eq(linter_names.raw.flatten)
+  expect(CukeLinter.registered_linters.keys).to match_array(linter_names.raw.flatten)
 end

data/testing/model_factory.rb

@@ -1,4 +1,7 @@
 module CukeLinter
+
+  # A simple model used for testing
+
   class TestModel < CukeModeler::Model
 
     include CukeModeler::Sourceable
@@ -8,6 +11,9 @@ end
 
 
 module CukeLinter
+
+  # A helper module that generates various models for use in testing
+
   module ModelFactory
 
     def self.generate_feature_model(source_text: 'Feature:', parent_file_path: 'path_to_file')
@@ -20,6 +26,36 @@ module CukeLinter
       model
     end
 
+    def self.generate_example_model(source_text: 'Examples:', parent_file_path: 'path_to_file')
+      fake_file_model      = CukeModeler::FeatureFile.new
+      fake_file_model.path = parent_file_path
+
+      model              = CukeModeler::Example.new(source_text)
+      model.parent_model = fake_file_model
+
+      model
+    end
+
+    def self.generate_outline_model(source_text: "Scenario Outline:\n*a step\nExamples:\n|param|", parent_file_path: 'path_to_file')
+      fake_file_model      = CukeModeler::FeatureFile.new
+      fake_file_model.path = parent_file_path
+
+      model              = CukeModeler::Outline.new(source_text)
+      model.parent_model = fake_file_model
+
+      model
+    end
+
+    def self.generate_scenario_model(source_text: 'Scenario:', parent_file_path: 'path_to_file')
+      fake_file_model      = CukeModeler::FeatureFile.new
+      fake_file_model.path = parent_file_path
+
+      model              = CukeModeler::Scenario.new(source_text)
+      model.parent_model = fake_file_model
+
+      model
+    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/cuke_linter_integration_spec.rb

@@ -107,6 +107,12 @@ RSpec.describe CukeLinter do
   it 'has a default set of registered linters' do
     expect(subject.registered_linters.keys).to include('FeatureWithoutScenariosLinter')
     expect(subject.registered_linters['FeatureWithoutScenariosLinter']).to be_a(CukeLinter::FeatureWithoutScenariosLinter)
+    expect(subject.registered_linters.keys).to include('ExampleWithoutNameLinter')
+    expect(subject.registered_linters['ExampleWithoutNameLinter']).to be_a(CukeLinter::ExampleWithoutNameLinter)
+    expect(subject.registered_linters.keys).to include('OutlineWithSingleExampleRowLinter')
+    expect(subject.registered_linters['OutlineWithSingleExampleRowLinter']).to be_a(CukeLinter::OutlineWithSingleExampleRowLinter)
+    expect(subject.registered_linters.keys).to include('TestWithTooManyStepsLinter')
+    expect(subject.registered_linters['TestWithTooManyStepsLinter']).to be_a(CukeLinter::TestWithTooManyStepsLinter)
   end
 
 end

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

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

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

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

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

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

data/testing/rspec/spec/unit/formatters/pretty_formatter_unit_spec.rb

@@ -57,6 +57,9 @@ RSpec.describe CukeLinter::PrettyFormatter do
                     { linter:   'SomeLinter',
                       problem:  'Some problem',
                       location: 'path/to/the_file:3' },
+                    { linter:   'SomeLinter',
+                      problem:  'Some problem',
+                      location: 'path/to/the_file:3' },
                     { linter:   'SomeLinter',
                       problem:  'Some problem',
                       location: 'path/to/the_file:1' }]
@@ -68,8 +71,9 @@ RSpec.describe CukeLinter::PrettyFormatter do
                            '    path/to/the_file:1',
                            '    path/to/the_file:2',
                            '    path/to/the_file:3',
+                           '    path/to/the_file:3',
                            '',
-                           '3 issues found'].join("\n"))
+                           '4 issues found'].join("\n"))
   end
 
 end

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

@@ -0,0 +1,83 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::ExampleWithoutNameLinter do
+
+  let(:good_data) do
+    model      = CukeLinter::ModelFactory.generate_example_model
+    model.name = 'foo'
+
+    model
+  end
+
+  let(:bad_data) do
+    model      = CukeLinter::ModelFactory.generate_example_model
+    model.name = ''
+
+    model
+  end
+
+
+  it_should_behave_like 'a linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('ExampleWithoutNameLinter')
+  end
+
+  describe 'linting' do
+
+    context 'an example with no name' do
+
+      let(:test_model_with_nil_name) do
+        model      = CukeLinter::ModelFactory.generate_example_model(parent_file_path: 'path_to_file')
+        model.name = nil
+
+        model
+      end
+
+      let(:test_model_with_blank_name) do
+        model      = CukeLinter::ModelFactory.generate_example_model(parent_file_path: 'path_to_file')
+        model.name = ''
+
+        model
+      end
+
+      it 'records a problem' do
+        results = subject.lint(test_model_with_nil_name)
+
+        expect(results.first[:problem]).to eq('Example has no name')
+
+        results = subject.lint(test_model_with_blank_name)
+
+        expect(results.first[:problem]).to eq('Example has no name')
+      end
+
+      it 'records the location of the problem' do
+        model_1             = CukeLinter::ModelFactory.generate_example_model(parent_file_path: 'path_to_file')
+        model_1.name        = nil
+        model_1.source_line = 1
+        model_2             = CukeLinter::ModelFactory.generate_example_model(parent_file_path: 'path_to_file')
+        model_2.name        = nil
+        model_2.source_line = 3
+
+        results = subject.lint(model_1)
+        expect(results.first[:location]).to eq('path_to_file:1')
+
+        results = subject.lint(model_2)
+        expect(results.first[:location]).to eq('path_to_file:3')
+      end
+
+    end
+
+    context 'a non-example model' do
+
+      it 'returns an empty set of results' do
+        results = subject.lint(CukeModeler::Model.new)
+
+        expect(results).to eq([])
+      end
+
+    end
+  end
+end

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

@@ -29,15 +29,26 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
 
     context 'a feature with no scenarios' do
 
-      let(:test_model) do
+      let(:test_model_with_empty_scenarios) do
         model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
         model.tests = []
 
         model
       end
 
+      let(:test_model_with_nil_scenarios) do
+        model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
+        model.tests = nil
+
+        model
+      end
+
       it 'records a problem' do
-        results = subject.lint(test_model)
+        results = subject.lint(test_model_with_empty_scenarios)
+
+        expect(results.first[:problem]).to eq('Feature has no scenarios')
+
+        results = subject.lint(test_model_with_nil_scenarios)
 
         expect(results.first[:problem]).to eq('Feature has no scenarios')
       end
@@ -59,6 +70,45 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
 
     end
 
+    context 'a feature with scenarios' do
+
+      context 'with a scenario' do
+
+        let(:test_model) do
+          gherkin = 'Feature:
+
+                     Scenario:'
+
+          CukeLinter::ModelFactory.generate_feature_model(source_text: gherkin)
+        end
+
+        it 'does not record a problem' do
+          expect(subject.lint(test_model)).to eq([])
+        end
+
+      end
+
+      context 'with an outline' do
+
+        let(:test_model) do
+          gherkin = 'Feature:
+
+                     Scenario Outline:
+                       * a step
+                     Examples:
+                       | param |'
+
+          CukeLinter::ModelFactory.generate_feature_model(source_text: gherkin)
+        end
+
+        it 'does not record a problem' do
+          expect(subject.lint(test_model)).to eq([])
+        end
+
+      end
+
+    end
+
     context 'a non-feature model' do
 
       it 'returns an empty set of results' do