cuke_linter 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 232cb6cefe917fc75ea2c3b21da060298a4b4f1d4c392dd0853ee2cef91bb80d
-  data.tar.gz: b8365e3d6b4b82bb494a9af552ee06db6467dac7e73d144a5c7dcc4df8d7b59c
+  metadata.gz: 6d4a41e4f1d37dde72387b44003228f891855230312e1da57ffe227fa7f1f853
+  data.tar.gz: ec0842ceccb4025aad332923ae0df4d921250f58f5f2a97f82818b0d7d0717c4
 SHA512:
-  metadata.gz: e2ad543a81bd093b5856e82fe7fb2bcf74447dcd96f1816adc47dcb220253d4a5e581e2e7fa7414cbb595b34815e217f431fb658f4ce70f4a779f8ff1bbc603c
-  data.tar.gz: b721820908884a39d786de81e8b87ff3c77daa4ff77037ad87384e301f3391f005328c0147aae9b093aea40552cf35a030db62c563c893838bef275f61dd44f9
+  metadata.gz: c8c38a81b0d6fe47db0f46eaefbc61a8c00305f90273d752fc81e7eb364278f2dc36cc7bf09b487bb183543a27b3380fe219eb7049d934e54fb2f117bc1a31a9
+  data.tar.gz: 8f8a924840f5ce979fe6037e85dca647eb70f91b1f7b2a1a3ee9e31716af04475a9b54095769d703cb796b41c6089366e1dd6d0a61652fd4cc430330fb774df7

data/.gitignore

@@ -1,16 +1,19 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-
-# rspec failure tracking
-.rspec_status
-
-# JetBrains IDE metadata folders
-/.idea
-
-Gemfile.lock
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# JetBrains IDE metadata folders
+/.idea
+
+# Mac metadata directories
+.DS_Store
+
+Gemfile.lock

data/CHANGELOG.md

@@ -8,6 +8,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 Nothing yet...
 
+## [0.5.0] - 2019-05-25
+
+### Added
+ - New linters
+   - BackgroundDoesMoreThanSetupLinter
+   - FeatureWithoutDescriptionLinter
+   - SingleTestBackgroundLinter
+   - StepWithEndPeriodLinter
+   - StepWithTooManyCharactersLinter
+   
 ## [0.4.0] - 2019-05-11
 
 ### Added
@@ -41,7 +51,8 @@ Nothing yet...
 - Custom linters, formatters, and command line usability
 
 
-[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/enkessler/cuke_linter/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/enkessler/cuke_linter/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/enkessler/cuke_linter/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/enkessler/cuke_linter/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/enkessler/cuke_linter/compare/v0.2.0...v0.3.0

data/lib/cuke_linter/linters/background_does_more_than_setup_linter.rb

@@ -0,0 +1,20 @@
+module CukeLinter
+
+  # A linter that detects backgrounds that have non-setup steps
+
+  class BackgroundDoesMoreThanSetupLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Background)
+
+      model.steps.collect(&:keyword).any? { |keyword| (keyword == 'When') || (keyword == 'Then') }
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Background has non-setup steps'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/feature_without_description_linter.rb

@@ -0,0 +1,20 @@
+module CukeLinter
+
+  # A linter that detects features that don't have a description
+
+  class FeatureWithoutDescriptionLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Feature)
+
+      model.description.nil? || model.description.empty?
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      "Feature has no description"
+    end
+
+  end
+end

data/lib/cuke_linter/linters/single_test_background_linter.rb

@@ -0,0 +1,20 @@
+module CukeLinter
+
+  # A linter that detects backgrounds that apply to only one test
+
+  class SingleTestBackgroundLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Background)
+
+      model.parent_model.tests.count == 1
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Background used with only one test'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/step_with_end_period_linter.rb

@@ -0,0 +1,20 @@
+module CukeLinter
+
+  # A linter that detects steps that end in a period
+
+  class StepWithEndPeriodLinter < Linter
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Step)
+
+      model.text.end_with?('.')
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      'Step ends with a period'
+    end
+
+  end
+end

data/lib/cuke_linter/linters/step_with_too_many_characters_linter.rb

@@ -0,0 +1,39 @@
+module CukeLinter
+
+  # A linter that detects steps that are too long
+
+  class StepWithTooManyCharactersLinter < Linter
+
+    # The threshold used if not otherwise configured
+    DEFAULT_STEP_LENGTH_THRESHOLD = 80
+
+    # Changes the linting settings on the linter using the provided configuration
+    def configure(options)
+      @step_length_threshold = options['StepLengthThreshold'] if options['StepLengthThreshold']
+    end
+
+    # The rule used to determine if a model has a problem
+    def rule(model)
+      return false unless model.is_a?(CukeModeler::Step)
+        
+      @linted_step_length = model.text&.length || 0
+
+      @linted_step_length > step_length_threshold
+    end
+
+    # The message used to describe the problem that has been found
+    def message
+      "Step is too long. #{@linted_step_length} characters found (max #{step_length_threshold})"
+    end
+
+
+    private
+
+
+    # The maximum length allowable of a step
+    def step_length_threshold
+      @step_length_threshold || DEFAULT_STEP_LENGTH_THRESHOLD
+    end
+
+  end
+end

data/lib/cuke_linter/version.rb

@@ -1,4 +1,4 @@
 module CukeLinter
   # The release version of this gem
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/cuke_linter.rb

@@ -3,9 +3,14 @@ require 'cuke_modeler'
 require "cuke_linter/version"
 require 'cuke_linter/formatters/pretty_formatter'
 require 'cuke_linter/linters/linter'
+require 'cuke_linter/linters/background_does_more_than_setup_linter'
 require 'cuke_linter/linters/example_without_name_linter'
+require 'cuke_linter/linters/feature_without_description_linter'
 require 'cuke_linter/linters/feature_without_scenarios_linter'
 require 'cuke_linter/linters/outline_with_single_example_row_linter'
+require 'cuke_linter/linters/single_test_background_linter'
+require 'cuke_linter/linters/step_with_end_period_linter'
+require 'cuke_linter/linters/step_with_too_many_characters_linter'
 require 'cuke_linter/linters/test_with_too_many_steps_linter'
 
 
@@ -13,10 +18,16 @@ require 'cuke_linter/linters/test_with_too_many_steps_linter'
 
 module CukeLinter
 
-  @original_linters = { 'FeatureWithoutScenariosLinter'     => FeatureWithoutScenariosLinter.new,
+  @original_linters = { 'BackgroundDoesMoreThanSetupLinter' => BackgroundDoesMoreThanSetupLinter.new,
                         'ExampleWithoutNameLinter'          => ExampleWithoutNameLinter.new,
+                        'FeatureWithoutDescriptionLinter'   => FeatureWithoutDescriptionLinter.new,
+                        'FeatureWithoutScenariosLinter'     => FeatureWithoutScenariosLinter.new,
                         'OutlineWithSingleExampleRowLinter' => OutlineWithSingleExampleRowLinter.new,
+                        'SingleTestBackgroundLinter'        => SingleTestBackgroundLinter.new,
+                        'StepWithEndPeriodLinter'           => StepWithEndPeriodLinter.new,
+                        'StepWithTooManyCharactersLinter'   => StepWithTooManyCharactersLinter.new,
                         'TestWithTooManyStepsLinter'        => TestWithTooManyStepsLinter.new }
+                        
 
   # Configures linters based on the given options
   def self.load_configuration(config_file_path: nil, config: nil)
@@ -28,7 +39,7 @@ module CukeLinter
     end
 
     config = config || YAML.load_file(config_file_path)
-
+    
     config.each_pair do |linter_name, options|
       unregister_linter(linter_name) if options.key?('Enabled') && !options['Enabled']
 

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

@@ -0,0 +1,50 @@
+Feature: Background does more than setup linter
+
+  As a reader of documentation
+  I want to backgrounds to not contain actions or verifications
+  So that what is being demonstrated in individual use cases is clear
+
+
+  Scenario: Linting backgrounds with action steps
+    Given a linter for backgrounds that do more than setup
+    And the following feature:
+      """
+      Feature:
+
+        Background:
+          Given some setup
+          When some action
+      """
+    When it is linted
+    Then an error is reported
+      | linter                            | problem                        | location         |
+      | BackgroundDoesMoreThanSetupLinter | Background has non-setup steps | <path_to_file>:3 |
+
+  Scenario: Linting backgrounds with verification steps
+    Given a linter for backgrounds that do more than setup
+    And the following feature:
+      """
+      Feature:
+
+        Background:
+          Given some setup
+          Then some verification
+      """
+    When it is linted
+    Then an error is reported
+      | linter                            | problem                        | location         |
+      | BackgroundDoesMoreThanSetupLinter | Background has non-setup steps | <path_to_file>:3 |
+
+  Scenario: Linting backgrounds with only setup steps
+    Given a linter for backgrounds that do more than setup
+    And the following feature:
+      """
+      Feature:
+
+        Background:
+          Given some setup
+          And some more setup
+          * this is also setup
+      """
+    When it is linted
+    Then no error is reported

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

@@ -8,11 +8,18 @@ Feature: Default Linters
   Scenario: Using the default linters
     Given no other linters have been registered or unregistered
     Then the following linters are registered by default
+      | BackgroundDoesMoreThanSetupLinter |
       | ExampleWithoutNameLinter          |
+      | FeatureWithoutDescriptionLinter   |
       | FeatureWithoutScenariosLinter     |
       | OutlineWithSingleExampleRowLinter |
+      | SingleTestBackgroundLinter        |
+      | StepWithEndPeriodLinter           |
+      | StepWithTooManyCharactersLinter   |
       | TestWithTooManyStepsLinter        |
 
+
+
   Scenario: Registering new linters
     Given no linters are currently registered
     When the following code is used:

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

@@ -0,0 +1,17 @@
+Feature: Feature without description linter
+
+  As a writer of documentation
+  I want features to have a description
+  So that I do not have incomplete documentation
+
+
+  Scenario: Linting
+    Given a linter for features without a description
+    And the following feature:
+      """
+      Feature: Features must have a description
+      """
+    When it is linted
+    Then an error is reported
+      | linter                          | problem                    | location         |
+      | FeatureWithoutDescriptionLinter | Feature has no description | <path_to_file>:1 |

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

@@ -0,0 +1,24 @@
+Feature: Single test background linter
+
+
+  As a writer of documentation
+  I want backgrounds to apply to at least two tests
+  So that I am not needlessly using a background instead of adding the background steps directly to the test
+
+
+  Scenario: Linting
+    Given a linter for backgrounds applied to only one test
+    And the following feature:
+      """
+      Feature:
+
+        Background:
+          * a step
+
+        Scenario:
+          * a step
+      """
+    When it is linted
+    Then an error is reported
+      | linter                     | problem                            | location         |
+      | SingleTestBackgroundLinter | Background used with only one test | <path_to_file>:3 |

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

@@ -0,0 +1,43 @@
+Feature: Test step with too many characters
+
+  As a reader of documentation
+  I want test steps not to be unduly long
+  So that I can easily understand its purpose
+
+
+  Scenario: Linting
+
+    Given a linter for test steps with too many characters
+    And the following feature:
+      """
+      Feature:
+
+        Scenario:
+          * tea exists and teapots exist and so do cups and saucers and there might be milk in the milk jug together with sugar cubes
+      """
+    When it is linted
+    Then an error is reported
+      | linter                          | problem                                         | location         |
+      | StepWithTooManyCharactersLinter | Step is too long. 121 characters found (max 80) | <path_to_file>:4 |
+
+
+  Scenario: Configuration of step count threshold
+  
+    Given a linter for test steps with too many characters has been registered
+    And the following configuration file:
+      """
+      StepWithTooManyCharactersLinter:
+        StepLengthThreshold: 55
+      """
+    And the following feature:
+      """
+      Feature:
+
+        Scenario:
+          Given that a rose by any other name would still smell as sweet
+      """
+    When the configuration file is loaded
+    And the feature is linted
+    Then an error is reported
+      | linter                          | problem                                        | location         |
+      | StepWithTooManyCharactersLinter | Step is too long. 56 characters found (max 55) | <path_to_file>:4 |

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

@@ -0,0 +1,21 @@
+Feature: Step that ends with a period linter
+
+  As a writer of documentation
+  I want to avoid periods at the end of steps
+  So that readability is not impacted when they are used elsewhere
+
+
+  Scenario: Linting
+    Given a linter for steps the end with a period
+    And the following feature:
+      """
+      Feature:
+
+        Scenario:
+          * an okay step
+          * a bad step.
+      """
+    When it is linted
+    Then an error is reported
+      | linter                  | problem                 | location         |
+      | StepWithEndPeriodLinter | Step ends with a period | <path_to_file>:5 |

data/testing/cucumber/step_definitions/setup_steps.rb

@@ -41,10 +41,34 @@ Given(/^a linter for tests with too many steps$/) do
   @linter = CukeLinter::TestWithTooManyStepsLinter.new
 end
 
+Given(/^a linter for steps the end with a period$/) do
+  @linter = CukeLinter::StepWithEndPeriodLinter.new
+end
+
+Given(/^a linter for backgrounds applied to only one test$/) do
+  @linter = CukeLinter::SingleTestBackgroundLinter.new
+end
+
+Given(/^a linter for backgrounds that do more than setup$/) do
+  @linter = CukeLinter::BackgroundDoesMoreThanSetupLinter.new
+end
+
+Given("a linter for test steps with too many characters") do
+  @linter = CukeLinter::StepWithTooManyCharactersLinter.new
+end
+
 Given(/^a linter for tests with too many steps has been registered$/) do
   CukeLinter.register_linter(linter: CukeLinter::TestWithTooManyStepsLinter.new, name: 'TestWithTooManyStepsLinter')
 end
 
+Given("a linter for features without a description") do
+  @linter = CukeLinter::FeatureWithoutDescriptionLinter.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
+
 Given(/^the following configuration file(?: "([^"]*)")?:$/) do |file_name, text|
   file_name ||= '.cuke_linter'
 

data/testing/model_factory.rb

@@ -53,6 +53,24 @@ module CukeLinter
       model
     end
 
+    def self.generate_background_model(source_text: "Background:\n* a step", parent_file_path: 'path_to_file')
+      fake_parent_model = generate_feature_model(parent_file_path: parent_file_path)
+
+      model              = CukeModeler::Background.new(source_text)
+      model.parent_model = fake_parent_model
+
+      model
+    end
+
+    def self.generate_step_model(source_text: '* a step', parent_file_path: 'path_to_file')
+      fake_parent_model = generate_scenario_model(parent_file_path: parent_file_path)
+
+      model              = CukeModeler::Step.new(source_text)
+      model.parent_model = fake_parent_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

@@ -110,12 +110,22 @@ RSpec.describe CukeLinter do
   end
 
   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('BackgroundDoesMoreThanSetupLinter')
+    expect(subject.registered_linters['BackgroundDoesMoreThanSetupLinter']).to be_a(CukeLinter::BackgroundDoesMoreThanSetupLinter)
     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('FeatureWithoutDescriptionLinter')
+    expect(subject.registered_linters['FeatureWithoutDescriptionLinter']).to be_a(CukeLinter::FeatureWithoutDescriptionLinter)
+    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('OutlineWithSingleExampleRowLinter')
     expect(subject.registered_linters['OutlineWithSingleExampleRowLinter']).to be_a(CukeLinter::OutlineWithSingleExampleRowLinter)
+    expect(subject.registered_linters.keys).to include('SingleTestBackgroundLinter')
+    expect(subject.registered_linters['SingleTestBackgroundLinter']).to be_a(CukeLinter::SingleTestBackgroundLinter)
+    expect(subject.registered_linters.keys).to include('StepWithEndPeriodLinter')
+    expect(subject.registered_linters['StepWithEndPeriodLinter']).to be_a(CukeLinter::StepWithEndPeriodLinter)
+    expect(subject.registered_linters.keys).to include('StepWithTooManyCharactersLinter')
+    expect(subject.registered_linters['StepWithTooManyCharactersLinter']).to be_a(CukeLinter::StepWithTooManyCharactersLinter)
     expect(subject.registered_linters.keys).to include('TestWithTooManyStepsLinter')
     expect(subject.registered_linters['TestWithTooManyStepsLinter']).to be_a(CukeLinter::TestWithTooManyStepsLinter)
   end

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,114 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::BackgroundDoesMoreThanSetupLinter do
+
+  let(:good_data) do
+    CukeLinter::ModelFactory.generate_background_model(source_text: 'Background:
+                                                                       Given something')
+  end
+
+  let(:bad_data) do
+    CukeLinter::ModelFactory.generate_background_model(source_text: 'Background:
+                                                                       When something')
+  end
+
+
+  it_should_behave_like 'a linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('BackgroundDoesMoreThanSetupLinter')
+  end
+
+  describe 'linting' do
+
+    context 'a background with action steps' do
+
+      let(:test_model) do
+        CukeLinter::ModelFactory.generate_background_model(source_text: 'Background:
+                                                                           When something')
+      end
+
+      it 'records a problem' do
+        result = subject.lint(test_model)
+
+        expect(result[:problem]).to eq('Background has non-setup steps')
+      end
+
+      it 'records the location of the problem' do
+        model = CukeLinter::ModelFactory.generate_background_model(parent_file_path: 'path_to_file',
+                                                                   source_text:      'Background:
+                                                                                        When something')
+
+        model.source_line = 1
+        result            = subject.lint(model)
+        expect(result[:location]).to eq('path_to_file:1')
+
+        model.source_line = 3
+        result            = subject.lint(model)
+        expect(result[:location]).to eq('path_to_file:3')
+      end
+
+    end
+
+    context 'a background with verification steps' do
+
+      let(:test_model) do
+        CukeLinter::ModelFactory.generate_background_model(source_text: 'Background:
+                                                                           Then something')
+      end
+
+      it 'records a problem' do
+        result = subject.lint(test_model)
+
+        expect(result[:problem]).to eq('Background has non-setup steps')
+      end
+
+      it 'records the location of the problem' do
+        model = CukeLinter::ModelFactory.generate_background_model(parent_file_path: 'path_to_file',
+                                                                   source_text:      'Background:
+                                                                                        Then something')
+
+        model.source_line = 1
+        result            = subject.lint(model)
+        expect(result[:location]).to eq('path_to_file:1')
+
+        model.source_line = 3
+        result            = subject.lint(model)
+        expect(result[:location]).to eq('path_to_file:3')
+      end
+
+    end
+
+    context 'a background with only setup steps' do
+
+      context 'with a scenario' do
+
+        let(:test_model) do
+          gherkin = 'Background:
+                       Given something
+                       * (plus something)'
+
+          CukeLinter::ModelFactory.generate_background_model(source_text: gherkin)
+        end
+
+        it 'does not record a problem' do
+          expect(subject.lint(test_model)).to eq(nil)
+        end
+
+      end
+
+    end
+
+    context 'a non-background model' do
+
+      it 'returns no result' do
+        result = subject.lint(CukeModeler::Model.new)
+
+        expect(result).to eq(nil)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::FeatureWithoutDescriptionLinter do
+
+  let(:good_data) do
+    feature_text = 'Feature:
+                      with a description'
+
+    CukeLinter::ModelFactory.generate_feature_model(source_text: feature_text)
+  end
+
+  let(:bad_data) do
+    feature_text = 'Feature: without a description'
+
+    CukeLinter::ModelFactory.generate_feature_model(source_text: feature_text)
+  end
+
+  it_should_behave_like 'a linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('FeatureWithoutDescriptionLinter')
+  end
+  
+  describe 'linting' do
+  
+    context 'a feature with no description' do
+
+      context 'because the description is empty' do
+
+        let(:feature_with_no_description) do
+          model             = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
+          model.description = ''
+
+          model
+        end
+
+
+        it 'records a problem' do
+          result = subject.lint(feature_with_no_description)
+          expect(result[:problem]).to eq('Feature has no description')
+        end
+
+        it 'records the location of the problem' do
+          result = subject.lint(feature_with_no_description)
+          expect(result[:location]).to eq('path_to_file:1')
+        end
+      end
+
+      context 'because the description is nil' do
+
+        let(:feature_with_no_description) do
+          model             = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
+          model.description = nil
+
+          model
+        end
+
+        it 'records a problem' do
+          result = subject.lint(feature_with_no_description)
+          expect(result[:problem]).to eq('Feature has no description')
+        end
+
+        it 'records the location of the problem' do
+          result = subject.lint(feature_with_no_description)
+          expect(result[:location]).to eq('path_to_file:1')
+        end
+
+      end
+    end
+    
+    context 'a feature with a description' do
+      
+      let(:feature_with_a_description) do
+        model_source = "Feature:\n  This feature has a description"
+        CukeLinter::ModelFactory.generate_feature_model(source_text: model_source,
+                                                        parent_file_path: 'path_to_file')
+      end
+      
+      it 'does not record a problem' do
+        result = subject.lint(feature_with_a_description)
+        expect(result).to eq(nil)
+      end
+    end
+
+    context 'a non-feature model' do
+    
+      it 'returns no results' do
+        result = subject.lint(CukeModeler::Model.new)
+
+        expect(result).to eq(nil)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,116 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::SingleTestBackgroundLinter do
+
+  let(:good_data) do
+    CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature:
+                                                                    Background:
+                                                                      * a step
+                                                                    Scenario:
+                                                                    Scenario:').background
+  end
+
+  let(:bad_data) do
+    CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature:
+                                                                    Background:
+                                                                      * a step
+                                                                    Scenario:').background
+  end
+
+
+  it_should_behave_like 'a linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('SingleTestBackgroundLinter')
+  end
+
+  describe 'linting' do
+
+    context 'with a background that affects only one test' do
+
+      ['scenario', 'outline'].each do |model_type|
+
+        context "and that test is a #{model_type}" do
+
+          let(:test_model) do
+            background_model = CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature:
+                                                                                               Background:
+                                                                                                 * a step').background
+
+            background_model.parent_model.tests.clear
+            background_model.parent_model.tests << CukeLinter::ModelFactory.send("generate_#{model_type}_model")
+
+            background_model
+          end
+
+          it 'records a problem' do
+            result = subject.lint(test_model)
+
+            expect(result[:problem]).to match('Background used with only one test')
+          end
+
+          it 'records the location of the problem' do
+            test_model.source_line = 1
+            result                 = subject.lint(test_model)
+            expect(result[:location]).to eq('path_to_file:1')
+
+            test_model.source_line = 3
+            result                 = subject.lint(test_model)
+            expect(result[:location]).to eq('path_to_file:3')
+          end
+
+        end
+
+      end
+
+    end
+
+    context 'with a background that affects multiple tests' do
+
+      let(:test_model) do
+        CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature:
+                                                                        Background:
+                                                                          * a step
+                                                                        Scenario:
+                                                                        Scenario Outline:
+                                                                          * a step
+                                                                        Examples:
+                                                                          |param|
+                                                                          |value|').background
+      end
+
+      it 'does not record a problem' do
+        expect(subject.lint(test_model)).to eq(nil)
+      end
+
+    end
+
+    context 'with a background that affects no tests' do
+
+      let(:test_model) do
+        CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature:
+                                                                        Background:
+                                                                          * a step').background
+      end
+
+      it 'does not record a problem' do
+        expect(subject.lint(test_model)).to eq(nil)
+      end
+
+    end
+
+    context 'with a non-background model' do
+
+      let(:test_model) { CukeModeler::Model.new }
+
+      it 'returns no result' do
+        result = subject.lint(test_model)
+
+        expect(result).to eq(nil)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::StepWithEndPeriodLinter do
+
+  let(:good_data) do
+    CukeLinter::ModelFactory.generate_step_model(source_text: '* without a period')
+  end
+
+  let(:bad_data) do
+    CukeLinter::ModelFactory.generate_step_model(source_text: '* with a period.')
+  end
+
+
+  it_should_behave_like 'a linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('StepWithEndPeriodLinter')
+  end
+
+  describe 'linting' do
+
+    context "with a step that ends with a period" do
+
+      let(:test_model) do
+        CukeLinter::ModelFactory.generate_step_model(source_text: '* with a period.')
+      end
+
+      it 'records a problem' do
+        result = subject.lint(test_model)
+
+        expect(result[:problem]).to match('Step ends with a period')
+      end
+
+      it 'records the location of the problem' do
+        test_model.source_line = 1
+        result                 = subject.lint(test_model)
+        expect(result[:location]).to eq('path_to_file:1')
+
+        test_model.source_line = 3
+        result                 = subject.lint(test_model)
+        expect(result[:location]).to eq('path_to_file:3')
+      end
+
+    end
+
+    context "with a step that does not end with a period" do
+
+
+      let(:test_model) do
+        CukeLinter::ModelFactory.generate_step_model(source_text: '* without a period')
+      end
+
+      it 'does not record a problem' do
+        expect(subject.lint(test_model)).to eq(nil)
+      end
+
+    end
+
+    context 'with a non-step model' do
+
+      let(:test_model) { CukeModeler::Model.new }
+
+      it 'returns no result' do
+        result = subject.lint(test_model)
+
+        expect(result).to eq(nil)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::StepWithTooManyCharactersLinter do
+
+  let(:good_data) do
+    CukeLinter::ModelFactory.generate_step_model(source_text: '* a short step')
+  end
+
+  let(:bad_data) do
+    long_step = <<~EOL.delete("\n")
+      * this is a very long string which will violate the linter 
+      rule which expects step rules to have fewer than one hundred 
+      and twenty characters
+    EOL
+    CukeLinter::ModelFactory.generate_step_model(source_text: long_step)
+  end
+
+  it_should_behave_like 'a linter at the unit level'
+  it_should_behave_like 'a configurable linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('StepWithTooManyCharactersLinter')
+  end
+
+  describe 'linting' do
+  
+    let(:default_character_threshold) { 80 }
+
+    context 'when the step is too long' do
+
+      let(:step_too_long_model) do
+        step = 'x' * (default_character_threshold + 1)
+        CukeLinter::ModelFactory.generate_step_model(source_text: "* #{step}")
+      end
+    
+      it 'reports a problem' do
+        result = subject.lint(step_too_long_model)
+
+        expect(result[:problem]).to match(/^Step is too long. \d+ characters found \(max 80\)/)
+      end
+    
+      it 'records the location of the problem' do
+        result = subject.lint(step_too_long_model)
+      
+        expect(result[:location]).to eq('path_to_file:4')
+      end
+
+      it 'includes the number of characters found in the problem record' do
+        character_count = step_too_long_model.text.length
+        result          = subject.lint(step_too_long_model)
+        expect(result[:problem]).to eq("Step is too long. #{character_count} characters found (max 80)")
+
+        step_too_long_model.text += 'x'
+        result                   = subject.lint(step_too_long_model)
+        expect(result[:problem]).to eq("Step is too long. #{character_count + 1} characters found (max 80)")
+      end
+
+    end
+    
+    context 'when the step is the maximum length' do
+      
+      let(:step_mex_length_model) do
+        step = 'x' * default_character_threshold
+        CukeLinter::ModelFactory.generate_step_model(source_text: "* #{step}")
+      end
+      
+      it 'does not record a problem' do
+        result = subject.lint(step_mex_length_model)
+        expect(result).to eq(nil)
+      end
+      
+    end
+
+    context 'when the step is below the maximum length' do
+
+      let(:step_below_length_model) do
+        step = 'x' * (default_character_threshold - 1)
+        CukeLinter::ModelFactory.generate_step_model(source_text: "* #{step}")
+      end
+
+      it 'does not record a problem' do
+        result = subject.lint(step_below_length_model)
+        expect(result).to eq(nil)
+      end
+
+    end
+
+    context 'when the step has no text' do
+
+      let(:step_with_nil_text_model) do
+        model      = CukeLinter::ModelFactory.generate_step_model
+        model.text = nil
+
+        model
+      end
+
+      it 'does not record a problem' do
+        result = subject.lint(step_with_nil_text_model)
+        expect(result).to eq(nil)
+      end
+
+    end
+
+  end
+
+  describe 'configuration' do
+
+    context 'with no configuration' do
+
+    let(:default_character_threshold) { 80 }
+    
+    context 'because configuration never happened' do
+    
+      let(:default_model) do
+        step = 'x' * (default_character_threshold + 1)
+        CukeLinter::ModelFactory.generate_step_model(source_text: "* #{step}")
+      end
+      
+      it 'defaults to a maximum of 80 characters' do
+        result = subject.lint(default_model)
+        
+        expect( result[:problem]).to match(/^Step is too long. \d+ characters found \(max 80\)/)
+      end
+      
+    end
+    
+    context 'because configuration did not set a step threshold' do
+      let(:configuration) { {} }
+      let(:configured_model) do
+        subject.configure(configuration)
+        step = 'x' * (default_character_threshold + 1)
+        CukeLinter::ModelFactory.generate_step_model(source_text: "* #{step}")
+      end
+
+      it 'defaults to a maximum of 80 characters' do
+        result = subject.lint(configured_model)
+        
+        expect( result[:problem]).to match(/^Step is too long. \d+ characters found \(max 80\)/)
+      end
+
+    end
+
+    end
+
+    context 'when configured' do
+      let(:character_threshold) { 10 }
+      let(:configuration) { {'StepLengthThreshold' => character_threshold} }
+
+      subject { linter = CukeLinter::StepWithTooManyCharactersLinter.new
+                linter.configure(configuration)
+                linter }
+
+      let(:test_model) do
+        step = 'x' * (character_threshold + 1)
+        CukeLinter::ModelFactory.generate_step_model(source_text: "* #{step}")
+      end
+      
+      it 'uses the maximum character length provided by configuration' do
+        result = subject.lint(test_model)
+        
+        expect( result[:problem]).to match(/^Step is too long. \d+ characters found \(max 10\)/)
+      end
+      
+    end
+    
+    context 'a non-step model' do
+
+      let(:test_model) { CukeModeler::Model.new }
+
+      it 'returns no result' do
+        result = subject.lint(test_model)
+
+        expect(result).to eq(nil)
+      end
+
+    end
+  end
+end

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

@@ -192,20 +192,23 @@ RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
 
           let(:step_threshhold) { 3 }
           let(:configuration) { { 'StepThreshold' => step_threshhold } }
-          let(:configured_test_model) do
+
+          subject { linter = CukeLinter::TestWithTooManyStepsLinter.new
+                    linter.configure(configuration)
+                    linter }
+
+          let(:test_model) do
             model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
             model.steps = []
             (step_threshhold + 1).times { model.steps << :a_step }
 
-            subject.configure(configuration)
-
             model
           end
 
           it 'the step threshold used is the configured value' do
-            result = subject.lint(configured_test_model)
+            result = subject.lint(test_model)
 
-            expect(result[:problem]).to match(/^Test has too many steps. #{configured_test_model.steps.count} steps found \(max #{step_threshhold}\)/)
+            expect(result[:problem]).to match(/^Test has too many steps. #{test_model.steps.count} steps found \(max #{step_threshhold}\)/)
           end
 
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cuke_linter
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Eric Kessler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-11 00:00:00.000000000 Z
+date: 2019-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cuke_modeler
@@ -176,21 +176,31 @@ files:
 - exe/cuke_linter
 - lib/cuke_linter.rb
 - lib/cuke_linter/formatters/pretty_formatter.rb
+- lib/cuke_linter/linters/background_does_more_than_setup_linter.rb
 - lib/cuke_linter/linters/example_without_name_linter.rb
+- lib/cuke_linter/linters/feature_without_description_linter.rb
 - lib/cuke_linter/linters/feature_without_scenarios_linter.rb
 - lib/cuke_linter/linters/linter.rb
 - lib/cuke_linter/linters/outline_with_single_example_row_linter.rb
+- lib/cuke_linter/linters/single_test_background_linter.rb
+- lib/cuke_linter/linters/step_with_end_period_linter.rb
+- lib/cuke_linter/linters/step_with_too_many_characters_linter.rb
 - lib/cuke_linter/linters/test_with_too_many_steps_linter.rb
 - lib/cuke_linter/version.rb
 - testing/cucumber/features/command_line.feature
 - testing/cucumber/features/configuration/configuring_linters.feature
 - testing/cucumber/features/configuration/using_configurations.feature
 - testing/cucumber/features/formatters/pretty_formatter.feature
+- testing/cucumber/features/linters/background_does_more_than_setup_linter.feature
 - testing/cucumber/features/linters/custom_linters.feature
 - testing/cucumber/features/linters/default_linters.feature
 - testing/cucumber/features/linters/example_without_name.feature
+- testing/cucumber/features/linters/feature_without_description.feature
 - testing/cucumber/features/linters/feature_without_scenarios.feature
 - testing/cucumber/features/linters/outline_with_single_example_row.feature
+- testing/cucumber/features/linters/single_test_background_linter.feature
+- testing/cucumber/features/linters/step_too_long.feature
+- testing/cucumber/features/linters/step_with_end_period.feature
 - testing/cucumber/features/linters/test_with_too_many_steps.feature
 - testing/cucumber/step_definitions/action_steps.rb
 - testing/cucumber/step_definitions/setup_steps.rb
@@ -202,21 +212,31 @@ files:
 - testing/rspec/spec/integration/cuke_linter_integration_spec.rb
 - testing/rspec/spec/integration/formatters/formatter_integration_specs.rb
 - testing/rspec/spec/integration/formatters/pretty_formatter_integration_spec.rb
+- testing/rspec/spec/integration/linters/background_does_more_than_setup_linter_integration_spec.rb
 - testing/rspec/spec/integration/linters/example_without_name_linter_integration_spec.rb
+- testing/rspec/spec/integration/linters/feature_without_description_linter_integration_spec.rb
 - testing/rspec/spec/integration/linters/feature_without_scenarios_linter_integration_spec.rb
 - testing/rspec/spec/integration/linters/linter_integration_spec.rb
 - testing/rspec/spec/integration/linters/linter_integration_specs.rb
 - testing/rspec/spec/integration/linters/outline_with_single_example_row_linter_integration_spec.rb
+- testing/rspec/spec/integration/linters/single_test_background_linter_integration_spec.rb
+- testing/rspec/spec/integration/linters/step_with_end_period_linter_integration_spec.rb
+- testing/rspec/spec/integration/linters/step_with_too_many_characters_linter_integration_spec.rb
 - testing/rspec/spec/integration/linters/test_with_too_many_steps_linter_integration_spec.rb
 - testing/rspec/spec/unit/cuke_linter_unit_spec.rb
 - testing/rspec/spec/unit/formatters/formatter_unit_specs.rb
 - testing/rspec/spec/unit/formatters/pretty_formatter_unit_spec.rb
+- testing/rspec/spec/unit/linters/background_does_more_than_setup_linter_unit_spec.rb
 - testing/rspec/spec/unit/linters/configurable_linter_unit_specs.rb
 - testing/rspec/spec/unit/linters/example_without_name_linter_unit_spec.rb
+- testing/rspec/spec/unit/linters/feature_without_description_linter_unit_spec.rb
 - testing/rspec/spec/unit/linters/feature_without_scenarios_linter_unit_spec.rb
 - testing/rspec/spec/unit/linters/linter_unit_spec.rb
 - testing/rspec/spec/unit/linters/linter_unit_specs.rb
 - testing/rspec/spec/unit/linters/outline_with_single_example_row_linter_unit_spec.rb
+- testing/rspec/spec/unit/linters/single_test_background_linter_unit_spec.rb
+- testing/rspec/spec/unit/linters/step_with_end_period_linter_unit_spec.rb
+- testing/rspec/spec/unit/linters/step_with_too_many_characters_linter_unit_spec.rb
 - testing/rspec/spec/unit/linters/test_with_too_many_steps_linter_unit_spec.rb
 homepage: https://github.com/enkessler/cuke_linter
 licenses: