cuke_linter 0.6.0 → 0.7.0

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

@@ -25,7 +25,7 @@ RSpec.describe CukeLinter::StepWithTooManyCharactersLinter do
   end
 
   describe 'linting' do
-  
+
     let(:default_character_threshold) { 80 }
 
     context 'when the step is too long' do
@@ -34,16 +34,16 @@ RSpec.describe CukeLinter::StepWithTooManyCharactersLinter 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
 
@@ -58,19 +58,19 @@ RSpec.describe CukeLinter::StepWithTooManyCharactersLinter do
       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
@@ -103,50 +103,62 @@ RSpec.describe CukeLinter::StepWithTooManyCharactersLinter do
 
     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
 
   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
+      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
 
-      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
+      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} }
+      let(:configuration) { { 'StepLengthThreshold' => character_threshold } }
 
       subject { linter = CukeLinter::StepWithTooManyCharactersLinter.new
                 linter.configure(configuration)
@@ -156,25 +168,14 @@ RSpec.describe CukeLinter::StepWithTooManyCharactersLinter 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
+      it 'uses the maximum character length provided by configuration' do
         result = subject.lint(test_model)
 
-        expect(result).to eq(nil)
+        expect(result[:problem]).to match(/^Step is too long. \d+ characters found \(max 10\)/)
       end
 
     end
+
   end
 end

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

@@ -0,0 +1,217 @@
+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
+
+
+  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: 'path_to_file')
+              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 '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 '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.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 '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
+
+        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.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 '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
+
+      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 'does not record a problem' do
+            expect(subject.lint(test_model)).to eq(nil)
+          end
+
+        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 'does not record a problem' do
+            expect(subject.lint(test_model)).to eq(nil)
+          end
+
+        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 '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_no_name_linter_unit_spec.rb

@@ -0,0 +1,115 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::TestWithNoNameLinter do
+
+  let(:good_data) do
+    CukeLinter::ModelFactory.generate_scenario_model(source_text: 'Scenario: some name')
+  end
+
+  let(:bad_data) do
+    CukeLinter::ModelFactory.generate_scenario_model(source_text: 'Scenario:')
+  end
+
+
+  it_should_behave_like 'a linter at the unit level'
+
+
+  it 'has a name' do
+    expect(subject.name).to eq('TestWithNoNameLinter')
+  end
+
+  describe 'linting' do
+
+    ['scenario', 'outline'].each do |model_type|
+
+      context "with a #{model_type} that has no name" do
+
+        context 'because its name is empty' do
+
+          let(:test_model) do
+            model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: 'path_to_file')
+            model.name = ''
+
+            model
+          end
+
+          it 'records a problem' do
+            result = subject.lint(test_model)
+
+            expect(result[:problem]).to eq('Test does not have a name.')
+          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 'because its name is nil' do
+
+          let(:test_model) do
+            model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: 'path_to_file')
+            model.name = nil
+
+            model
+          end
+
+          it 'records a problem' do
+            result = subject.lint(test_model)
+
+            expect(result[:problem]).to eq('Test does not have a name.')
+          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
+
+      context "with a #{model_type} that does have a name" do
+
+        let(:test_model) do
+          model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
+          model.name = 'foo'
+
+          model
+        end
+
+        it 'does not record a problem' do
+          expect(subject.lint(test_model)).to eq(nil)
+        end
+
+      end
+
+    end
+
+    context 'a non-test 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