cuke_linter 0.9.0 → 0.10.0

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

@@ -3,25 +3,7 @@ require_relative '../../../../../environments/rspec_env'
 
 RSpec.describe CukeLinter::ElementWithTooManyTagsLinter do
 
-  let(:good_data) do
-    model      = CukeLinter::ModelFactory.generate_scenario_model
-    model.tags = [:tag_1]
-
-    model
-  end
-
-  let(:bad_data) do
-    model      = CukeLinter::ModelFactory.generate_scenario_model
-    model.tags = [:tag_1,
-                  :tag_2,
-                  :tag_3,
-                  :tag_4,
-                  :tag_5,
-                  :tag_6]
-
-    model
-  end
-
+  let(:model_file_path) { 'some_file_path' }
 
   it_should_behave_like 'a linter at the unit level'
   it_should_behave_like 'a configurable linter at the unit level'
@@ -33,12 +15,15 @@ RSpec.describe CukeLinter::ElementWithTooManyTagsLinter do
 
   describe 'linting' do
 
-    ['feature', 'scenario', 'outline', 'example'].each do |model_type|
+    # Descriptive variable name, just in case what kinds of elements are taggable ever changes
+    taggable_elements = ['feature', 'scenario', 'outline', 'example']
+
+    taggable_elements.each do |model_type|
 
       context "with a #{model_type} that has too many tags" 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.tags = [:tag_1,
                         :tag_2,
                         :tag_3,
@@ -49,22 +34,15 @@ RSpec.describe CukeLinter::ElementWithTooManyTagsLinter do
           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 match(/^#{model_type.capitalize} has too many tags. \d+ tags found \(max 5\)\.$/)
         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 'includes the number of tags found in the problem record' do
           tag_count = test_model.tags.count
           result    = subject.lint(test_model)
@@ -82,7 +60,7 @@ RSpec.describe CukeLinter::ElementWithTooManyTagsLinter do
         context 'because it has 5 tags' 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")
             model.tags = [:tag_1,
                           :tag_2,
                           :tag_3,
@@ -92,24 +70,20 @@ RSpec.describe CukeLinter::ElementWithTooManyTagsLinter 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
 
         context 'because it has fewer than 5 tags' 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")
             model.tags = [:tag_1]
 
             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
 
@@ -118,30 +92,26 @@ RSpec.describe CukeLinter::ElementWithTooManyTagsLinter do
           context 'because its tags 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")
               model.tags = []
 
               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
 
           context 'because its tags 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")
               model.tags = nil
 
               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
 
@@ -320,11 +290,7 @@ RSpec.describe CukeLinter::ElementWithTooManyTagsLinter 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
 

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

@@ -3,20 +3,7 @@ require_relative '../../../../../environments/rspec_env'
 
 RSpec.describe CukeLinter::ExampleWithoutNameLinter do
 
-  let(:good_data) do
-    model      = CukeLinter::ModelFactory.generate_example_model
-    model.name = 'foo'
-
-    model
-  end
-
-  let(:bad_data) do
-    model      = CukeLinter::ModelFactory.generate_example_model
-    model.name = ''
-
-    model
-  end
-
+  let(:model_file_path) { 'some_file_path' }
 
   it_should_behave_like 'a linter at the unit level'
 
@@ -29,54 +16,65 @@ RSpec.describe CukeLinter::ExampleWithoutNameLinter do
 
     context 'an example with no name' do
 
-      let(:test_model_with_nil_name) do
-        model      = CukeLinter::ModelFactory.generate_example_model(parent_file_path: 'path_to_file')
-        model.name = nil
+      context 'because the name is nil' do
 
-        model
-      end
+        let(:test_model) do
+          model      = CukeLinter::ModelFactory.generate_example_model(parent_file_path: model_file_path)
+          model.name = nil
 
-      let(:test_model_with_blank_name) do
-        model      = CukeLinter::ModelFactory.generate_example_model(parent_file_path: 'path_to_file')
-        model.name = ''
+          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('Example grouping has no name')
+        end
 
-        model
       end
 
-      it 'records a problem' do
-        result = subject.lint(test_model_with_nil_name)
+      context 'because the name is empty' do
+
+        let(:test_model) do
+          model      = CukeLinter::ModelFactory.generate_example_model(parent_file_path: model_file_path)
+          model.name = ''
+
+          model
+        end
 
-        expect(result[:problem]).to eq('Example has no name')
+        it_should_behave_like 'a linter linting a bad model'
 
-        result = subject.lint(test_model_with_blank_name)
+        it 'records a problem' do
+          result = subject.lint(test_model)
+
+          expect(result[:problem]).to eq('Example grouping has no name')
+        end
 
-        expect(result[:problem]).to eq('Example has no name')
       end
 
-      it 'records the location of the problem' do
-        model_1             = CukeLinter::ModelFactory.generate_example_model(parent_file_path: 'path_to_file')
-        model_1.name        = nil
-        model_1.source_line = 1
-        model_2             = CukeLinter::ModelFactory.generate_example_model(parent_file_path: 'path_to_file')
-        model_2.name        = nil
-        model_2.source_line = 3
+    end
+
+    context 'an example with a name' do
 
-        result = subject.lint(model_1)
-        expect(result[:location]).to eq('path_to_file:1')
+      let(:test_model) do
+        model      = CukeLinter::ModelFactory.generate_example_model
+        model.name = 'a name'
 
-        result = subject.lint(model_2)
-        expect(result[:location]).to eq('path_to_file:3')
+        model
       end
 
+      it_should_behave_like 'a linter linting a good model'
+
     end
 
+
     context 'a non-example model' do
 
-      it 'returns no result' do
-        result = subject.lint(CukeModeler::Model.new)
+      let(:test_model) { CukeModeler::Model.new }
 
-        expect(result).to eq(nil)
-      end
+      it_should_behave_like 'a linter linting a good model'
 
     end
   end

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

@@ -0,0 +1,293 @@
+require_relative '../../../../../environments/rspec_env'
+
+
+RSpec.describe CukeLinter::FeatureWithTooManyDifferentTagsLinter do
+
+  let(:model_file_path) { 'some_file_path' }
+
+  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('FeatureWithTooManyDifferentTagsLinter')
+  end
+
+  describe 'linting' do
+
+    context 'with a feature that contains too many different tags' do
+
+      let(:test_model) do
+        model      = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
+        model.tags = [CukeModeler::Tag.new('@1'),
+                      CukeModeler::Tag.new('@2'),
+                      CukeModeler::Tag.new('@3'),
+                      CukeModeler::Tag.new('@4'),
+                      CukeModeler::Tag.new('@5'),
+                      CukeModeler::Tag.new('@6'),
+                      CukeModeler::Tag.new('@7'),
+                      CukeModeler::Tag.new('@8'),
+                      CukeModeler::Tag.new('@9'),
+                      CukeModeler::Tag.new('@10'),
+                      CukeModeler::Tag.new('@11')]
+
+        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 match(/^Feature contains too many different tags. \d+ tags found \(max 10\)\.$/)
+      end
+
+      it 'includes the number of different tags found in the problem record' do
+        unique_tag_count = test_model.tags.count
+        result           = subject.lint(test_model)
+        expect(result[:problem]).to eq("Feature contains too many different tags. #{unique_tag_count} tags found (max 10).")
+
+        test_model.tags << CukeModeler::Tag.new('@had_better_be_unique')
+        result = subject.lint(test_model)
+        expect(result[:problem]).to eq("Feature contains too many different tags. #{unique_tag_count + 1} tags found (max 10).")
+      end
+
+      it 'only counts unique tags' do
+        model      = CukeLinter::ModelFactory.generate_feature_model
+        model.tags = []
+        100.times { model.tags << CukeModeler::Tag.new('@A') }
+
+        result = subject.lint(model)
+
+        expect(result).to eq(nil)
+      end
+
+      context 'with child models' do
+
+        let(:test_model) do
+          model      = CukeLinter::ModelFactory.generate_feature_model
+          model.tags = [CukeModeler::Tag.new('@1'),
+                        CukeModeler::Tag.new('@2'),
+                        CukeModeler::Tag.new('@3'),
+                        CukeModeler::Tag.new('@4'),
+                        CukeModeler::Tag.new('@5'),
+                        CukeModeler::Tag.new('@6'),
+                        CukeModeler::Tag.new('@7'),
+                        CukeModeler::Tag.new('@8'),
+                        CukeModeler::Tag.new('@9'),
+                        CukeModeler::Tag.new('@10'),
+                        CukeModeler::Tag.new('@11')]
+
+          # Not all model types are a test but the models dont care and it's good enough for the test
+          model.tests = [child_model]
+
+          model
+        end
+
+        # Descriptive variable name, just in case what kinds of elements are taggable ever changes
+        taggable_elements = ['feature', 'scenario', 'outline', 'example']
+
+        taggable_elements.each do |model_type|
+
+          context 'that have tags' do
+
+            let(:child_model) do
+              model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
+              model.tags = [CukeModeler::Tag.new('@12'),
+                            CukeModeler::Tag.new('@13'),
+                            CukeModeler::Tag.new('@14')]
+
+              model
+            end
+
+            it "considers tags from a #{model_type}" do
+              result = subject.lint(test_model)
+              expect(result[:problem]).to eq('Feature contains too many different tags. 14 tags found (max 10).')
+            end
+
+          end
+
+          context 'that do not have tags' do
+
+            context 'because their tags are empty' do
+
+              let(:child_model) do
+                model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
+                model.tags = []
+
+                model
+              end
+
+              it 'can handle the child model without problem' do
+                expect { subject.lint(test_model) }.to_not raise_error
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+
+    context 'with a feature that does not contain too many different tags' do
+
+      context 'because it contains 10 different tags' do
+
+        let(:test_model) do
+          model      = CukeLinter::ModelFactory.generate_feature_model
+          model.tags = [CukeModeler::Tag.new('@1'),
+                        CukeModeler::Tag.new('@2'),
+                        CukeModeler::Tag.new('@3'),
+                        CukeModeler::Tag.new('@4'),
+                        CukeModeler::Tag.new('@5'),
+                        CukeModeler::Tag.new('@6'),
+                        CukeModeler::Tag.new('@7'),
+                        CukeModeler::Tag.new('@8'),
+                        CukeModeler::Tag.new('@9'),
+                        CukeModeler::Tag.new('@10')]
+
+          model
+        end
+
+        it_should_behave_like 'a linter linting a good model'
+
+      end
+
+      context 'because it contains fewer than 10 different tags' do
+
+        let(:test_model) do
+          model      = CukeLinter::ModelFactory.generate_feature_model
+          model.tags = [CukeModeler::Tag.new('@1')]
+
+          model
+        end
+
+        it_should_behave_like 'a linter linting a good model'
+
+      end
+
+      context 'because it contains no tags' do
+
+        context 'because its tags are empty' do
+
+          let(:test_model) do
+            model      = CukeLinter::ModelFactory.generate_feature_model
+            model.tags = []
+
+            model
+          end
+
+          it_should_behave_like 'a linter linting a good model'
+
+        end
+
+        context 'because its tags are nil' do
+
+          # NOTE: Not handling the case of the model's tags being nil because the model methods used in the
+          # linter's implementation will themselves not work when the tags are nil.
+
+        end
+
+      end
+
+    end
+
+
+    describe 'configuration' do
+
+      let(:default_tag_threshold) { 10 }
+
+
+      describe 'tag threshold configuration' do
+
+        context 'with no configuration' do
+
+          context 'because configuration never happened' do
+
+            let(:unconfigured_test_model) do
+              model      = CukeLinter::ModelFactory.generate_feature_model
+              model.tags = []
+              (default_tag_threshold + 1).times { |count| model.tags << CukeModeler::Tag.new("@#{count}") }
+
+              model
+            end
+
+            it 'defaults to a tag threshold of 10 tags' do
+              result = subject.lint(unconfigured_test_model)
+
+              expect(result[:problem]).to eq("Feature contains too many different tags. #{unconfigured_test_model.tags.count} tags found (max 10).")
+            end
+
+          end
+
+          context 'because configuration did not set a tag threshold' do
+
+            let(:configuration) { {} }
+            let(:test_model) do
+              model      = CukeLinter::ModelFactory.generate_feature_model
+              model.tags = []
+              (default_tag_threshold + 1).times { |count| model.tags << CukeModeler::Tag.new("@#{count}") }
+
+              model
+            end
+
+            before(:each) do
+              subject.configure(configuration)
+            end
+
+            it 'defaults to a tag threshold of 10 tags' do
+              result = subject.lint(test_model)
+
+              expect(result[:problem]).to eq("Feature contains too many different tags. #{test_model.tags.count} tags found (max 10).")
+            end
+
+          end
+
+        end
+
+        context 'with configuration' do
+
+          let(:tag_threshold) { 3 }
+          let(:configuration) { { 'TagCountThreshold' => tag_threshold } }
+
+          before(:each) do
+            subject.configure(configuration)
+          end
+
+          let(:test_model) do
+            model      = CukeLinter::ModelFactory.generate_feature_model
+            model.tags = []
+            (tag_threshold + 1).times { |count| model.tags << CukeModeler::Tag.new("@#{count}") }
+
+            model
+          end
+
+          it 'the tag threshold used is the configured value' do
+            result = subject.lint(test_model)
+
+            expect(result[:problem]).to eq("Feature contains too many different tags. #{test_model.tags.count} tags found (max #{tag_threshold}).")
+          end
+
+        end
+
+      end
+
+    end
+
+
+    context 'a non-feature model' do
+
+      let(:test_model) { CukeModeler::Model.new }
+
+      it_should_behave_like 'a linter linting a good model'
+
+    end
+
+  end
+
+end