RubyGems - cuke_linter - Versions diffs - 0.12.1 → 1.2.0 - Mend

cuke_linter 0.12.1 → 1.2.0

Files changed (120) hide show

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

@@ -1,80 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::FeatureWithoutDescriptionLinter 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('FeatureWithoutDescriptionLinter')
-  end
-  describe 'linting' do
-    context 'a feature with no description' do
-      context 'because the description is empty' do
-        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(test_model)
-          expect(result[:problem]).to eq('Feature has no description')
-        end
-      end
-      context 'because the description is nil' do
-        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(test_model)
-          expect(result[:problem]).to eq('Feature has no description')
-        end
-        it_should_behave_like 'a linter linting a bad model'
-      end
-    end
-    context 'a 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,
-                                                        parent_file_path: 'path_to_file')
-      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_name_linter_unit_spec.rb DELETED

@@ -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 DELETED

@@ -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 DELETED

@@ -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