cuke_linter 0.13.0 → 1.0.0

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

@@ -1,11 +0,0 @@
-shared_examples_for 'a configurable linter at the unit level' do
-
-  it 'is configurable' do
-    expect(subject).to respond_to(:configure)
-  end
-
-  it 'is configured via a set of options' do
-    expect(subject.method(:configure).arity).to eq(1)
-  end
-
-end

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

@@ -1,248 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::ElementWithCommonTagsLinter 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('ElementWithCommonTagsLinter')
-  end
-
-  describe 'linting' do
-
-    ELEMENTS_WITH_TAGGABLE_CHILDREN.each do |model_type|
-
-      context "with a #{model_type} that has common tags on all of its children" do
-
-        let(:test_model) do
-          model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-
-          2.times do
-            child_model      = CukeLinter::ModelFactory.generate_lintable_model
-            child_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@same')]
-
-            case model_type
-              when 'feature'
-                model.tests << child_model
-              when 'outline'
-                model.examples << child_model
-              else
-                raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
-            end
-
-          end
-
-          model
-        end
-
-        it_should_behave_like 'a linter linting a bad model'
-
-
-        it 'records a problem' do
-          result = subject.lint(test_model)
-
-          case model_type
-            when 'feature'
-              expect(result[:problem]).to match(/^All tests in Feature have tag '@\w+'\. Move tag to Feature level\.$/)
-            when 'outline'
-              expect(result[:problem]).to match(/^All Examples in Outline have tag '@\w+'\. Move tag to Outline level\.$/)
-            else
-              raise(ArgumentError, "Don't know how to verify a '#{model_type}'. Add a new case?")
-          end
-        end
-
-        it 'includes the name of the common tag found in the problem record' do
-          common_tag = test_model.children.first.tags.first.name
-          result     = subject.lint(test_model)
-          expect(result[:problem]).to match(/have tag '#{common_tag}'\./)
-
-          test_model.children.first.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@still_same')]
-          test_model.children.last.tags  = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@still_same')]
-
-          common_tag = test_model.children.first.tags.first.name
-          result     = subject.lint(test_model)
-          expect(result[:problem]).to match(/have tag '#{common_tag}'\./)
-        end
-
-      end
-
-      context "with a #{model_type} that does not have common tags on all of its children" do
-
-        context 'because none of their tags are common' do
-
-          let(:test_model) do
-            model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-
-            2.times do |count|
-              child_model      = CukeLinter::ModelFactory.generate_lintable_model
-              child_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: "@tag_#{count}")]
-
-              case model_type
-                when 'feature'
-                  model.tests << child_model
-                when 'outline'
-                  model.examples << child_model
-                else
-                  raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
-              end
-
-            end
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-        context 'because some of them have no tags' do
-
-          context 'because their tags are empty' do
-
-            let(:test_model) do
-              model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-
-              2.times do
-                child_model      = CukeLinter::ModelFactory.generate_lintable_model
-                child_model.tags = []
-
-                case model_type
-                  when 'feature'
-                    model.tests << child_model
-                  when 'outline'
-                    model.examples << child_model
-                  else
-                    raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
-                end
-
-              end
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-          context 'because their tags are nil' do
-
-            let(:test_model) do
-              model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-
-              2.times do
-                child_model      = CukeLinter::ModelFactory.generate_lintable_model
-                child_model.tags = nil
-
-                case model_type
-                  when 'feature'
-                    model.tests << child_model
-                  when 'outline'
-                    model.examples << child_model
-                  else
-                    raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
-                end
-
-              end
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-        context 'because the model only has one child' do
-
-          let(:test_model) do
-            model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-
-            1.times do
-              child_model      = CukeLinter::ModelFactory.generate_lintable_model
-              child_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@a_tag')]
-
-              case model_type
-                when 'feature'
-                  model.tests << child_model
-                when 'outline'
-                  model.examples << child_model
-                else
-                  raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
-              end
-
-            end
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-        context 'because the model has no children' do
-
-          context 'because the children are empty' do
-
-            let(:test_model) do
-              model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-
-              case model_type
-                when 'feature'
-                  model.tests = []
-                when 'outline'
-                  model.examples = []
-                else
-                  raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
-              end
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-          context 'because the children are nil' do
-
-            let(:test_model) do
-              model = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-
-              case model_type
-                when 'feature'
-                  model.tests = nil
-                when 'outline'
-                  model.examples = nil
-                else
-                  raise(ArgumentError, "Don't know how to setup a '#{model_type}'. Add a new case?")
-              end
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-      end
-
-    end
-
-
-    context 'a model that is not a type that has taggable children' 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/element_with_duplicate_tags_linter_unit_spec.rb

@@ -1,203 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::ElementWithDuplicateTagsLinter 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('ElementWithDuplicateTagsLinter')
-  end
-
-  describe 'linting' do
-
-    TAGGABLE_ELEMENTS.each do |model_type|
-
-      context "with a #{model_type} that has duplicate tags" do
-
-        let(:test_model) do
-          model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-          model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@same'),
-                        CukeLinter::ModelFactory.generate_tag_model(source_text: '@same')]
-
-          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 duplicate tag '@\w+'\.$/)
-        end
-
-        it 'includes the name of the duplicate tag found in the problem record' do
-          duplicate_tag = test_model.tags.first.name
-          result        = subject.lint(test_model)
-          expect(result[:problem]).to eq("#{model_type.capitalize} has duplicate tag '#{duplicate_tag}'.")
-
-          test_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@still_same'),
-                             CukeLinter::ModelFactory.generate_tag_model(source_text: '@still_same')]
-
-          duplicate_tag = test_model.tags.first.name
-          result        = subject.lint(test_model)
-          expect(result[:problem]).to eq("#{model_type.capitalize} has duplicate tag '#{duplicate_tag}'.")
-        end
-
-      end
-
-      context "with a #{model_type} that does not have duplicate tags" do
-
-        context 'because none of it tags are duplicates' do
-
-          let(:test_model) do
-            model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@foo'),
-                          CukeLinter::ModelFactory.generate_tag_model(source_text: '@bar')]
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-        context 'because it has no tags' do
-
-          context 'because its tags are empty' do
-
-            let(:test_model) do
-              model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.tags = []
-
-              model
-            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")
-              model.tags = nil
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-      end
-
-
-      describe 'configuration' do
-
-        describe 'tag inheritance configuration' do
-
-          let(:test_model_with_inherited_tags) do
-            test_model      = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            test_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@same')]
-
-            distant_ancestor_model      = CukeLinter::ModelFactory.generate_lintable_model
-            distant_ancestor_model.tags = [CukeLinter::ModelFactory.generate_tag_model(source_text: '@same')]
-            ancestor_model              = CukeLinter::ModelFactory.generate_lintable_model
-
-            # Adding an extra ancestor in the chain in order to make sure that the linter isn't just checking the parent model
-            ancestor_model.parent_model = distant_ancestor_model
-            test_model.parent_model     = ancestor_model
-
-            test_model
-          end
-
-
-          context 'with no configuration' do
-
-            context 'because configuration never happened' do
-
-              it 'does not include inherited tags' do
-                result = subject.lint(test_model_with_inherited_tags)
-
-                expect(result).to eq(nil)
-              end
-
-            end
-
-            context 'because configuration did not set tag inheritance' do
-
-              let(:configuration) { {} }
-
-              before(:each) do
-                subject.configure(configuration)
-              end
-
-              it 'does not include inherited tags' do
-                result = subject.lint(test_model_with_inherited_tags)
-
-                expect(result).to eq(nil)
-              end
-
-            end
-
-          end
-
-          context 'with configuration' do
-
-            before(:each) do
-              subject.configure(configuration)
-            end
-
-            context 'enabling tag inheritance' do
-
-              let(:configuration) { { 'IncludeInheritedTags' => true } }
-
-              it 'does include inherited tags' do
-                result = subject.lint(test_model_with_inherited_tags)
-
-                expect(result).to_not be_nil
-                expect(result[:problem]).to match(/#{model_type.capitalize} has duplicate tag '@\w+'\./)
-              end
-
-            end
-
-            context 'disabling tag inheritance' do
-
-              let(:configuration) { { 'IncludeInheritedTags' => false } }
-
-              it 'does not include inherited tags' do
-                result = subject.lint(test_model_with_inherited_tags)
-
-                expect(result).to eq(nil)
-              end
-
-            end
-
-          end
-
-        end
-
-      end
-
-    end
-
-
-    context 'a non-taggable model' do
-
-      let(:test_model) { CukeModeler::Model.new }
-
-      it_should_behave_like 'a linter linting a good model'
-
-    end
-
-  end
-
-end