cuke_linter 0.9.0 → 0.10.0

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

@@ -3,18 +3,7 @@ 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
+  let(:model_file_path) { 'some_file_path' }
 
   it_should_behave_like 'a linter at the unit level'
 
@@ -22,75 +11,69 @@ RSpec.describe CukeLinter::FeatureWithoutDescriptionLinter do
   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')
+        let(:test_model) do
+          model             = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
           model.description = ''
 
           model
         end
 
+        it_should_behave_like 'a linter linting a bad model'
+
 
         it 'records a problem' do
-          result = subject.lint(feature_with_no_description)
+          result = subject.lint(test_model)
+
           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')
+        let(:test_model) do
+          model             = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
           model.description = nil
 
           model
         end
 
         it 'records a problem' do
-          result = subject.lint(feature_with_no_description)
+          result = subject.lint(test_model)
+
           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
+        it_should_behave_like 'a linter linting a bad model'
 
       end
     end
-    
+
     context 'a feature with a description' do
-      
-      let(:feature_with_a_description) do
+
+      let(:test_model) do
         model_source = "Feature:\n  This feature has a description"
-        CukeLinter::ModelFactory.generate_feature_model(source_text: model_source,
+        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
+
+      it_should_behave_like 'a linter linting a good model'
+
     end
 
     context 'a non-feature model' do
-    
-      it 'returns no results' do
-        result = subject.lint(CukeModeler::Model.new)
 
-        expect(result).to eq(nil)
-      end
+      let(:test_model) { CukeModeler::Model.new }
+
+      it_should_behave_like 'a linter linting a good model'
+
     end
 
   end

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

@@ -3,14 +3,7 @@ require_relative '../../../../../environments/rspec_env'
 
 RSpec.describe CukeLinter::FeatureWithoutNameLinter do
 
-  let(:good_data) do
-    CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature: some name')
-  end
-
-  let(:bad_data) do
-    CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature:')
-  end
-
+  let(:model_file_path) { 'some_file_path' }
 
   it_should_behave_like 'a linter at the unit level'
 
@@ -26,55 +19,40 @@ RSpec.describe CukeLinter::FeatureWithoutNameLinter do
       context 'because its name is empty' do
 
         let(:test_model) do
-          model      = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
+          model      = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
           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('Feature 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.generate_feature_model(parent_file_path: 'path_to_file')
+          model      = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
           model.name = nil
 
           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('Feature 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
@@ -88,9 +66,7 @@ RSpec.describe CukeLinter::FeatureWithoutNameLinter 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
 
@@ -99,11 +75,7 @@ RSpec.describe CukeLinter::FeatureWithoutNameLinter 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/feature_without_scenarios_linter_unit_spec.rb

@@ -3,20 +3,7 @@ require_relative '../../../../../environments/rspec_env'
 
 RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
 
-  let(:good_data) do
-    model       = CukeLinter::ModelFactory.generate_feature_model
-    model.tests = ['totally_a_test']
-
-    model
-  end
-
-  let(:bad_data) do
-    model       = CukeLinter::ModelFactory.generate_feature_model
-    model.tests = []
-
-    model
-  end
-
+  let(:model_file_path) { 'some_file_path' }
 
   it_should_behave_like 'a linter at the unit level'
 
@@ -27,50 +14,49 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
 
   describe 'linting' do
 
-    context 'a feature with no scenarios' do
+    context 'a feature with no tests' do
 
-      let(:test_model_with_empty_scenarios) do
-        model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
-        model.tests = []
+      context 'because the tests are empty' do
 
-        model
-      end
+        let(:test_model) do
+          model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
+          model.tests = []
+
+          model
+        end
 
-      let(:test_model_with_nil_scenarios) do
-        model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
-        model.tests = nil
+        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('Feature has no scenarios')
+        end
 
-        model
       end
 
-      it 'records a problem' do
-        result = subject.lint(test_model_with_empty_scenarios)
+      context 'because the tests are nil' do
 
-        expect(result[:problem]).to eq('Feature has no scenarios')
+        let(:test_model) do
+          model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
+          model.tests = nil
 
-        result = subject.lint(test_model_with_nil_scenarios)
+          model
+        end
 
-        expect(result[:problem]).to eq('Feature has no scenarios')
-      end
+        it_should_behave_like 'a linter linting a bad model'
 
-      it 'records the location of the problem' do
-        model_1             = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
-        model_1.tests       = []
-        model_1.source_line = 1
-        model_2             = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: 'path_to_file')
-        model_2.tests       = []
-        model_2.source_line = 3
+        it 'records a problem' do
+          result = subject.lint(test_model)
 
-        result = subject.lint(model_1)
-        expect(result[:location]).to eq('path_to_file:1')
+          expect(result[:problem]).to eq('Feature has no scenarios')
+        end
 
-        result = subject.lint(model_2)
-        expect(result[:location]).to eq('path_to_file:3')
       end
 
     end
 
-    context 'a feature with scenarios' do
+    context 'a feature with tests' do
 
       context 'with a scenario' do
 
@@ -82,9 +68,7 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
           CukeLinter::ModelFactory.generate_feature_model(source_text: gherkin)
         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
 
@@ -101,9 +85,7 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
           CukeLinter::ModelFactory.generate_feature_model(source_text: gherkin)
         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
 
@@ -111,11 +93,9 @@ RSpec.describe CukeLinter::FeatureWithoutScenariosLinter do
 
     context 'a non-feature 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/linter_unit_spec.rb

@@ -3,17 +3,39 @@ require_relative '../../../../../environments/rspec_env'
 
 RSpec.describe CukeLinter::Linter do
 
+  let(:model_file_path) { 'some_file_path' }
+
   let(:linter_name) { 'FooLinter' }
   let(:linter_message) { 'Foo!' }
   let(:linter_rule) { lambda { |model| !model.is_a?(CukeModeler::Example) } }
   let(:linter_options) { { name: linter_name, message: linter_message, rule: linter_rule } }
 
-  let(:good_data) do
-    CukeLinter::ModelFactory.generate_example_model
-  end
+  let(:good_data) { CukeLinter::ModelFactory.generate_example_model }
+  let(:bad_data) { CukeLinter::ModelFactory.generate_outline_model }
+
+
+  it_should_behave_like 'a linter at the unit level'
+
+  context 'with a linting rule' do
+
+    subject { CukeLinter::Linter.new(linter_options.merge({ rule: linter_rule })) }
+
+    context 'with a good model' do
+
+      let(:test_model) { CukeLinter::ModelFactory.generate_example_model }
+
+      it_should_behave_like 'a linter linting a good model'
+
+    end
+
+    context 'with a bad model' do
+
+      let(:test_model) { CukeLinter::ModelFactory.generate_outline_model(parent_file_path: model_file_path) }
+
+      it_should_behave_like 'a linter linting a bad model'
+
+    end
 
-  let(:bad_data) do
-    CukeLinter::ModelFactory.generate_outline_model
   end
 
 
@@ -21,9 +43,6 @@ RSpec.describe CukeLinter::Linter do
 
     subject { CukeLinter::Linter.new(linter_options) }
 
-
-    it_should_behave_like 'a linter at the unit level'
-
     it 'uses the provided name' do
       expect(subject.name).to eq(linter_name)
     end
@@ -61,8 +80,6 @@ RSpec.describe CukeLinter::Linter do
               linter }
 
 
-    it_should_behave_like 'a linter at the unit level'
-
     it 'uses the provided #name' do
       expect(subject.name).to eq(linter_name)
     end

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

@@ -14,25 +14,39 @@ shared_examples_for 'a linter at the unit level' do
     expect(subject.method(:lint).arity).to eq(1)
   end
 
-  context 'with good data' do
+end
+
 
-    it 'returns no problem' do
-      expect(subject.lint(good_data)).to be_nil
-    end
+shared_examples_for 'a linter linting a good model' do
 
+  it 'returns no problem' do
+    expect(subject.lint(test_model)).to be_nil
   end
 
-  context 'with bad data' do
+end
 
-    it 'returns a detected problems' do
-      expect(subject.lint(bad_data)).to_not be_nil
-    end
 
-    it 'includes the problem and its locations in its result' do
-      result = subject.lint(bad_data)
+shared_examples_for 'a linter linting a bad model' do
+
+  it 'returns a detected problem' do
+    expect(subject.lint(test_model)).to_not be_nil
+  end
 
-      expect(result.keys).to match_array([:problem, :location])
-    end
+  it 'includes the problem and its location in its result' do
+    result = subject.lint(test_model)
 
+    expect(result).to_not be_nil
+    expect(result.keys).to match_array([:problem, :location])
   end
+
+  it 'correctly records the location of the problem' do
+    test_model.source_line = 1
+    result                 = subject.lint(test_model)
+    expect(result[:location]).to eq("#{model_file_path}:1")
+
+    test_model.source_line = 3
+    result                 = subject.lint(test_model)
+    expect(result[:location]).to eq("#{model_file_path}:3")
+  end
+
 end