cuke_linter 0.12.0 → 1.1.0

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

@@ -1,226 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::TestShouldUseBackgroundLinter 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('TestShouldUseBackgroundLinter')
-  end
-
-  describe 'linting' do
-
-    ['scenario', 'outline'].each do |model_type|
-
-      context "with a #{model_type} that shares a first step with all other tests in the feature" do
-
-        let(:test_model) do
-          step_text     = 'the step'
-          feature_model = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path,
-                                                                          source_text:      "Feature:
-                                                                                               Scenario:
-                                                                                                 * #{step_text}
-                                                                                               Scenario Outline:
-                                                                                                 * #{step_text}
-                                                                                               Examples:
-                                                                                                 | param |
-                                                                                                 | value |")
-
-          model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-          model.steps = [CukeModeler::Step.new("* #{step_text}")]
-
-          model.parent_model = feature_model
-          feature_model.tests << model
-
-          model
-        end
-
-        it_should_behave_like 'a linter linting a bad model'
-
-
-        it 'records a problem' do
-          result = subject.lint(test_model)
-
-          expect(result[:problem]).to eq('Test shares steps with all other tests in feature. Use a background.')
-        end
-
-      end
-
-      context "with a #{model_type} that does not share a first step with all other tests in the feature" do
-
-        context 'because the steps are different' do
-
-          let(:test_model) do
-            step_text     = 'the step'
-            feature_model = CukeLinter::ModelFactory.generate_feature_model(source_text: "Feature:
-                                                                                           Scenario:
-                                                                                             * #{step_text}
-                                                                                           Scenario Outline:
-                                                                                             * #{step_text}
-                                                                                           Examples:
-                                                                                             | param |
-                                                                                             | value |")
-
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.steps = [CukeModeler::Step.new("* #{step_text} plus extra")]
-
-            model.parent_model = feature_model
-            feature_model.tests << model
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-        context 'because it has no steps' do
-
-          context 'because its steps are empty' do
-
-            let(:test_model) do
-              step_text     = 'the step'
-              feature_model = CukeLinter::ModelFactory.generate_feature_model(source_text: "Feature:
-                                                                                           Scenario:
-                                                                                             * #{step_text}
-                                                                                           Scenario Outline:
-                                                                                             * #{step_text}
-                                                                                           Examples:
-                                                                                             | param |
-                                                                                             | value |")
-
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = []
-
-              model.parent_model = feature_model
-              feature_model.tests << model
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-          context 'because its steps are nil' do
-
-            let(:test_model) do
-              step_text     = 'the step'
-              feature_model = CukeLinter::ModelFactory.generate_feature_model(source_text: "Feature:
-                                                                                           Scenario:
-                                                                                             * #{step_text}
-                                                                                           Scenario Outline:
-                                                                                             * #{step_text}
-                                                                                           Examples:
-                                                                                             | param |
-                                                                                             | value |")
-
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = nil
-
-              model.parent_model = feature_model
-              feature_model.tests << model
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-        context 'because another test has no steps' do
-
-          context 'because its steps are empty' do
-
-            let(:test_model) do
-              step_text     = 'the step'
-              feature_model = CukeLinter::ModelFactory.generate_feature_model(source_text: "Feature:
-                                                                                           Scenario:
-                                                                                             * #{step_text}
-                                                                                           Scenario Outline:
-                                                                                             * #{step_text}
-                                                                                           Examples:
-                                                                                             | param |
-                                                                                             | value |")
-
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = [CukeModeler::Step.new("* #{step_text}")]
-
-              model.parent_model              = feature_model
-              feature_model.tests.first.steps = []
-              feature_model.tests << model
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-          context 'because its steps are nil' do
-
-            let(:test_model) do
-              step_text     = 'the step'
-              feature_model = CukeLinter::ModelFactory.generate_feature_model(source_text: "Feature:
-                                                                                           Scenario:
-                                                                                             * #{step_text}
-                                                                                           Scenario Outline:
-                                                                                             * #{step_text}
-                                                                                           Examples:
-                                                                                             | param |
-                                                                                             | value |")
-
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = [CukeModeler::Step.new("* #{step_text}")]
-
-              model.parent_model              = feature_model
-              feature_model.tests.first.steps = nil
-              feature_model.tests << model
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-        context 'because there are not other tests in the feature' do
-
-          let(:test_model) do
-            step_text     = 'the step'
-            feature_model = CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature:')
-
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.steps = [CukeModeler::Step.new("* #{step_text}")]
-
-            model.parent_model = feature_model
-            feature_model.tests << model
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-      end
-
-    end
-
-    context 'a non-test model' do
-
-      let(:test_model) { CukeModeler::Model.new }
-
-      it_should_behave_like 'a linter linting a good model'
-
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::TestWithActionStepAsFinalStepLinter 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('TestWithActionStepAsFinalStepLinter')
-  end
-
-  describe 'linting' do
-
-    ['scenario', 'outline'].each do |model_type|
-
-      context "with a #{model_type} that has an action step as its final step" do
-
-        let(:test_model) do
-          model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-          model.steps = [CukeModeler::Step.new('Given a step'),
-                         CukeModeler::Step.new('When a step')]
-
-          model
-        end
-
-        it_should_behave_like 'a linter linting a bad model'
-
-
-        it 'records a problem' do
-          result = subject.lint(test_model)
-
-          expect(result[:problem]).to eq("Test has 'When' as the final step.")
-        end
-
-      end
-
-      context "with a #{model_type} that does not have an action step as its final step" do
-
-        context 'because it has no steps' do
-
-          context 'because its steps are empty' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = []
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-          context 'because its steps are nil' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = nil
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-        context 'because its final step is not an action step' do
-
-          let(:test_model) do
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.steps = [CukeModeler::Step.new('Then a step')]
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-      end
-
-    end
-
-
-    context 'a non-test model' do
-
-      let(:test_model) { CukeModeler::Model.new }
-
-      it_should_behave_like 'a linter linting a good model'
-
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::TestWithBadNameLinter 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('TestWithBadNameLinter')
-  end
-
-  describe 'linting' do
-
-    ['scenario', 'outline'].each do |model_type|
-
-      context "with a #{model_type} that has a bad name" do
-
-        context 'because its name contains a bad word' do
-
-          ['test', 'check', 'verify'].each do |bad_word|
-
-            let(:test_model) do
-              model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-              model.name = "#{bad_word} bad names are reported"
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a bad model'
-
-            it 'records a problem' do
-              result = subject.lint(test_model)
-
-              expect(result[:problem]).to eq('"Test", "Verify" and "Check" should not be used in scenario names.')
-            end
-
-          end
-
-          context 'because bad words are case insensitive' do
-
-            ['Test', 'TEST'].each do |bad_word|
-
-              let(:test_model) do
-                model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-                model.name = "#{bad_word} bad names are reported"
-
-                model
-              end
-
-              it_should_behave_like 'a linter linting a bad model'
-
-              it 'records a problem' do
-                result = subject.lint(test_model)
-
-                expect(result[:problem]).to eq('"Test", "Verify" and "Check" should not be used in scenario names.')
-              end
-
-            end
-
-          end
-
-        end
-
-        context 'a non-test model' do
-
-          let(:test_model) { CukeModeler::Model.new }
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,176 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::TestWithNoActionStepLinter 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('TestWithNoActionStepLinter')
-  end
-
-  describe 'linting' do
-
-    ['scenario', 'outline'].each do |model_type|
-
-      context "with a #{model_type} that has no action step" do
-
-        context 'because it has no steps' do
-
-          context 'because its steps are empty' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-              model.steps = []
-
-              model
-            end
-
-            it 'records a problem' do
-              result = subject.lint(test_model)
-
-              expect(result[:problem]).to eq("Test does not have a 'When' step.")
-            end
-
-            it_should_behave_like 'a linter linting a bad model'
-
-          end
-
-          context 'because its steps are nil' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-              model.steps = nil
-
-              model
-            end
-
-            it 'records a problem' do
-              result = subject.lint(test_model)
-
-              expect(result[:problem]).to eq("Test does not have a 'When' step.")
-            end
-
-            it_should_behave_like 'a linter linting a bad model'
-
-          end
-
-        end
-
-        context 'because none of its steps is an action step' do
-
-          let(:test_model) do
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-            model.steps = [CukeModeler::Step.new('* not an action step')]
-
-            model
-          end
-
-          it 'records a problem' do
-            result = subject.lint(test_model)
-
-            expect(result[:problem]).to eq("Test does not have a 'When' step.")
-          end
-
-          it_should_behave_like 'a linter linting a bad model'
-
-        end
-
-      end
-
-      context "with a #{model_type} that does have an action step" do
-
-        context 'that comes from its background' do
-
-          let(:test_model) do
-            model                         = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.steps                   = []
-            background_model              = CukeModeler::Background.new
-            background_model.steps        = [CukeModeler::Step.new('When an action step')]
-            model.parent_model.background = background_model
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-        context 'that is part of itself' do
-
-          let(:test_model) do
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.steps = [CukeModeler::Step.new('When an action step')]
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-      end
-
-    end
-
-    ['scenario', 'outline'].each do |model_type|
-
-      context "with a #{model_type} that has a related background" do
-
-        let(:test_model) do
-          model                         = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-          model.parent_model.background = background_model
-
-          model
-        end
-
-        context 'that has no background steps' do
-          context 'because its steps are empty' do
-
-            let(:background_model) do
-              model       = CukeModeler::Background.new
-              model.steps = []
-
-              model
-            end
-
-            it 'can handle it' do
-              expect { subject.lint(test_model) }.to_not raise_error
-            end
-
-          end
-
-          context 'because its steps are nil' do
-
-            let(:background_model) do
-              model       = CukeModeler::Background.new
-              model.steps = nil
-
-              model
-            end
-
-            it 'can handle it' do
-              expect { subject.lint(test_model) }.to_not raise_error
-            end
-
-          end
-
-        end
-
-      end
-
-    end
-
-
-    context 'a non-test model' do
-
-      let(:test_model) { CukeModeler::Model.new }
-
-      it_should_behave_like 'a linter linting a good model'
-
-    end
-  end
-end