cuke_linter 0.9.0 → 0.10.0

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

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

@@ -0,0 +1,98 @@
+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_no_action_step_linter_unit_spec.rb

@@ -3,16 +3,7 @@ require_relative '../../../../../environments/rspec_env'
 
 RSpec.describe CukeLinter::TestWithNoActionStepLinter do
 
-  let(:good_data) do
-    CukeLinter::ModelFactory.generate_scenario_model(source_text: 'Scenario:
-                                                                     When an action step')
-  end
-
-  let(:bad_data) do
-    CukeLinter::ModelFactory.generate_scenario_model(source_text: 'Scenario:
-                                                                     * no action step')
-  end
-
+  let(:model_file_path) { 'some_file_path' }
 
   it_should_behave_like 'a linter at the unit level'
 
@@ -32,7 +23,7 @@ RSpec.describe CukeLinter::TestWithNoActionStepLinter do
           context 'because its steps are empty' do
 
             let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: 'path_to_file')
+              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
               model.steps = []
 
               model
@@ -44,22 +35,14 @@ RSpec.describe CukeLinter::TestWithNoActionStepLinter do
               expect(result[:problem]).to eq("Test does not have a 'When' step.")
             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
+            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: 'path_to_file')
+              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
               model.steps = nil
 
               model
@@ -71,15 +54,7 @@ RSpec.describe CukeLinter::TestWithNoActionStepLinter do
               expect(result[:problem]).to eq("Test does not have a 'When' step.")
             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
+            it_should_behave_like 'a linter linting a bad model'
 
           end
 
@@ -88,7 +63,7 @@ RSpec.describe CukeLinter::TestWithNoActionStepLinter do
         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: 'path_to_file')
+            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
             model.steps = [CukeModeler::Step.new('* not an action step')]
 
             model
@@ -100,15 +75,7 @@ RSpec.describe CukeLinter::TestWithNoActionStepLinter do
             expect(result[:problem]).to eq("Test does not have a 'When' step.")
           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
+          it_should_behave_like 'a linter linting a bad model'
 
         end
 
@@ -128,9 +95,7 @@ RSpec.describe CukeLinter::TestWithNoActionStepLinter do
             model
           end
 
-          it 'does not record a problem' do
-            expect(subject.lint(test_model)).to eq(nil)
-          end
+          it_should_behave_like 'a linter linting a good model'
 
         end
 
@@ -143,9 +108,7 @@ RSpec.describe CukeLinter::TestWithNoActionStepLinter do
             model
           end
 
-          it 'does not record a problem' do
-            expect(subject.lint(test_model)).to eq(nil)
-          end
+          it_should_behave_like 'a linter linting a good model'
 
         end
 
@@ -206,11 +169,7 @@ RSpec.describe CukeLinter::TestWithNoActionStepLinter do
 
       let(:test_model) { CukeModeler::Model.new }
 
-      it 'returns no result' do
-        result = subject.lint(test_model)
-
-        expect(result).to eq(nil)
-      end
+      it_should_behave_like 'a linter linting a good model'
 
     end
   end