cuke_linter 0.13.0 → 1.0.0

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

@@ -1,84 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::FeatureWithoutNameLinter 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('FeatureWithoutNameLinter')
-  end
-
-  describe 'linting' do
-
-    context 'with a feature that has no name' do
-
-      context 'because its name is empty' do
-
-        let(:test_model) do
-          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
-
-      end
-
-      context 'because its name is nil' do
-
-        let(:test_model) do
-          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
-
-      end
-
-    end
-
-    context 'with a feature that does have a name' do
-
-      let(:test_model) do
-        model      = CukeLinter::ModelFactory.generate_feature_model
-        model.name = 'foo'
-
-        model
-      end
-
-      it_should_behave_like 'a linter linting a good model'
-
-    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

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

@@ -1,102 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::FeatureWithoutScenariosLinter 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('FeatureWithoutScenariosLinter')
-  end
-
-  describe 'linting' do
-
-    context 'a feature with no tests' do
-
-      context 'because the tests are empty' do
-
-        let(:test_model) do
-          model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
-          model.tests = []
-
-          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 has no scenarios')
-        end
-
-      end
-
-      context 'because the tests are nil' do
-
-        let(:test_model) do
-          model       = CukeLinter::ModelFactory.generate_feature_model(parent_file_path: model_file_path)
-          model.tests = 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 has no scenarios')
-        end
-
-      end
-
-    end
-
-    context 'a feature with tests' do
-
-      context 'with a scenario' do
-
-        let(:test_model) do
-          gherkin = 'Feature:
-
-                     Scenario:'
-
-          CukeLinter::ModelFactory.generate_feature_model(source_text: gherkin)
-        end
-
-        it_should_behave_like 'a linter linting a good model'
-
-      end
-
-      context 'with an outline' do
-
-        let(:test_model) do
-          gherkin = 'Feature:
-
-                     Scenario Outline:
-                       * a step
-                     Examples:
-                       | param |'
-
-          CukeLinter::ModelFactory.generate_feature_model(source_text: gherkin)
-        end
-
-        it_should_behave_like 'a linter linting a good model'
-
-      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

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

@@ -1,197 +0,0 @@
-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) { 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
-
-  end
-
-
-  context 'with custom values' do
-
-    subject { CukeLinter::Linter.new(linter_options) }
-
-    it 'uses the provided name' do
-      expect(subject.name).to eq(linter_name)
-    end
-
-    it 'uses the provided rule' do
-      expect(subject.lint(good_data)).to be_nil
-      expect(subject.lint(bad_data)).to_not be_nil
-    end
-
-    it 'uses the provided message' do
-      result = subject.lint(bad_data)
-
-      expect(result[:problem]).to eq(linter_message)
-    end
-
-  end
-
-  context 'with custom methods' do
-
-    subject { linter = CukeLinter::Linter.new
-
-              linter.define_singleton_method('rule') do |model|
-                !model.is_a?(CukeModeler::Example)
-              end
-
-              linter.define_singleton_method('name') do
-                'FooLinter'
-              end
-
-              linter.define_singleton_method('message') do
-                'Foo!'
-              end
-
-
-              linter }
-
-
-    it 'uses the provided #name' do
-      expect(subject.name).to eq(linter_name)
-    end
-
-    it 'uses the provided #rule' do
-      expect(subject.lint(good_data)).to be_nil
-      expect(subject.lint(bad_data)).to_not be_nil
-    end
-
-    it 'uses the provided #message' do
-      result = subject.lint(bad_data)
-
-      expect(result[:problem]).to eq(linter_message)
-    end
-
-  end
-
-  context 'with both custom values and methods' do
-
-    let(:good_data) do
-      CukeLinter::ModelFactory.generate_outline_model
-    end
-
-    let(:bad_data) do
-      CukeLinter::ModelFactory.generate_example_model
-    end
-
-    subject { linter = CukeLinter::Linter.new(linter_options)
-
-              linter.define_singleton_method('rule') do |model|
-                model.is_a?(CukeModeler::Example)
-              end
-
-              linter.define_singleton_method('name') do
-                'Method Linter'
-              end
-
-              linter.define_singleton_method('message') do
-                'Method Foo!'
-              end
-
-
-              linter }
-
-
-    it 'uses #name instead of the provided name' do
-      expect(subject.name).to eq('Method Linter')
-    end
-
-    it 'uses #rule instead of the provided rule' do
-      expect(subject.lint(good_data)).to be_nil
-      expect(subject.lint(bad_data)).to_not be_nil
-    end
-
-    it 'uses #message instead of the provided message' do
-      result = subject.lint(bad_data)
-
-      expect(result[:problem]).to eq('Method Foo!')
-    end
-
-  end
-
-  context 'with neither custom values nor methods' do
-
-    subject { CukeLinter::Linter.new }
-
-
-    it 'complains if not provided with a rule' do
-      expect { subject.lint('Anything') }.to raise_error('No linting rule provided!')
-    end
-
-
-    it 'has a default name based on its class' do
-      expect(subject.name).to eq('Linter')
-
-      class CustomLinter < CukeLinter::Linter;
-      end
-
-      expect(CustomLinter.new.name).to eq('CustomLinter')
-    end
-
-    it 'has a default message based on its name' do
-      linter_options[:message] = nil
-
-      # Default name
-      linter_options[:name] = nil
-      linter                = CukeLinter::Linter.new(linter_options)
-      result                = linter.lint(bad_data)
-
-      expect(result[:problem]).to eq('Linter problem detected')
-
-      # Value name
-      linter_options[:name] = 'Value name'
-      linter                = CukeLinter::Linter.new(linter_options)
-      result                = linter.lint(bad_data)
-
-      expect(result[:problem]).to eq('Value name problem detected')
-
-      # Method name
-      class CustomLinter < CukeLinter::Linter;
-        def name
-          'Method name'
-        end
-      end
-
-      linter_options[:name] = nil
-      linter                = CustomLinter.new(linter_options)
-      result                = linter.lint(bad_data)
-
-      expect(result[:problem]).to eq('Method name problem detected')
-    end
-
-  end
-
-end

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

@@ -1,57 +0,0 @@
-shared_examples_for 'a linter at the unit level' do
-
-  it 'is named' do
-    expect(subject).to respond_to(:name)
-    expect(subject.name).to be_a_kind_of(String)
-    expect(subject.name).to_not be_empty
-  end
-
-  it 'can lint' do
-    expect(subject).to respond_to(:lint)
-  end
-
-  it 'lints a model' do
-    expect(subject.method(:lint).arity).to eq(1)
-  end
-
-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
-
-end
-
-
-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
-
-  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
-    if test_model.is_a?(CukeModeler::FeatureFile)
-      result                 = subject.lint(test_model)
-      expect(result[:location]).to eq("#{model_file_path}")
-    else
-      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
-
-end

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

@@ -1,184 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::OutlineWithSingleExampleRowLinter 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('OutlineWithSingleExampleRowLinter')
-  end
-
-  describe 'linting' do
-
-    context 'an outline with only one example row' do
-
-      context 'with only one example set' do
-
-        let(:test_model) do
-          gherkin = 'Scenario Outline:
-                       * a step
-                     Examples:
-                       | param |
-                       | value |'
-
-          CukeLinter::ModelFactory.generate_outline_model(parent_file_path: model_file_path,
-                                                          source_text:      gherkin)
-        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('Outline has only one example row')
-        end
-
-      end
-
-      context 'with multiple example sets' do
-
-        let(:test_model) do
-          gherkin = 'Scenario Outline:
-                       * a step
-                     Examples:
-                       | param |
-                     Examples:
-                       | param |
-                       | value |'
-
-          CukeLinter::ModelFactory.generate_outline_model(parent_file_path: model_file_path,
-                                                          source_text:      gherkin)
-        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('Outline has only one example row')
-        end
-
-      end
-
-    end
-
-    context 'an outline with more than one example row' do
-
-      context 'with only one example set' do
-
-        let(:test_model) do
-          gherkin = 'Scenario Outline:
-                       * a step
-                     Examples:
-                       | param   |
-                       | value 1 |
-                       | value 2 |'
-
-          CukeLinter::ModelFactory.generate_outline_model(source_text: gherkin)
-        end
-
-        it_should_behave_like 'a linter linting a good model'
-
-      end
-
-      context 'with multiple example sets' do
-
-        let(:test_model) do
-          gherkin = 'Scenario Outline:
-                       * a step
-                     Examples:
-                       | param   |
-                       | value 1 |
-                     Examples:
-                       | param   |
-                       | value 1 |'
-
-          CukeLinter::ModelFactory.generate_outline_model(source_text: gherkin)
-        end
-
-        it_should_behave_like 'a linter linting a good model'
-
-      end
-
-    end
-
-    context 'an outline with no example rows' do
-
-      context 'because it has no example sets' do
-
-        context 'because its examples are nil' do
-
-          let(:test_model) do
-            model          = CukeLinter::ModelFactory.generate_outline_model
-            model.examples = nil
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-        context 'because its examples are empty' do
-          let(:test_model) do
-            model          = CukeLinter::ModelFactory.generate_outline_model
-            model.examples = []
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-      end
-
-      context 'with only one example set' do
-
-        let(:test_model) do
-          gherkin = 'Scenario Outline:
-                       * a step
-                     Examples:
-                       | param |'
-
-          CukeLinter::ModelFactory.generate_outline_model(source_text: gherkin)
-        end
-
-        it_should_behave_like 'a linter linting a good model'
-
-      end
-
-      context 'with multiple example sets' do
-
-        let(:test_model) do
-          gherkin = 'Scenario Outline:
-                       * a step
-                     Examples:
-                       | param |
-                     Examples:
-                       | param |'
-
-          CukeLinter::ModelFactory.generate_outline_model(source_text: gherkin)
-        end
-
-        it_should_behave_like 'a linter linting a good model'
-
-      end
-
-    end
-
-    context 'a non-outline model' do
-
-      let(:test_model) { CukeModeler::Model.new }
-
-      it_should_behave_like 'a linter linting a good model'
-
-    end
-  end
-end