RubyGems - cuke_linter - Versions diffs - 0.13.0 → 1.0.0 - Mend

cuke_linter 0.13.0 → 1.0.0

Files changed (91) hide show

data/testing/rspec/spec/integration/linters/test_with_no_action_step_integration_spec.rb DELETED

@@ -1,8 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::TestWithNoActionStepLinter do
-  it_should_behave_like 'a linter at the integration level'
-end

data/testing/rspec/spec/integration/linters/test_with_no_name_integration_spec.rb DELETED

@@ -1,8 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::TestWithNoNameLinter do
-  it_should_behave_like 'a linter at the integration level'
-end

data/testing/rspec/spec/integration/linters/test_with_no_verification_step_integration_spec.rb DELETED

@@ -1,8 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::TestWithNoVerificationStepLinter do
-  it_should_behave_like 'a linter at the integration level'
-end

data/testing/rspec/spec/integration/linters/test_with_setup_step_after_action_step_linter_integration_spec.rb DELETED

@@ -1,8 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::TestWithSetupStepAfterActionStepLinter do
-  it_should_behave_like 'a linter at the integration level'
-end

data/testing/rspec/spec/integration/linters/test_with_setup_step_after_verification_step_linter_integration_spec.rb DELETED

@@ -1,8 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::TestWithSetupStepAfterVerificationStepLinter do
-  it_should_behave_like 'a linter at the integration level'
-end

data/testing/rspec/spec/integration/linters/test_with_setup_step_as_final_step_linter_integration_spec.rb DELETED

@@ -1,8 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::TestWithSetupStepAsFinalStepLinter do
-  it_should_behave_like 'a linter at the integration level'
-end

data/testing/rspec/spec/integration/linters/test_with_too_many_steps_linter_integration_spec.rb DELETED

@@ -1,8 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::TestWithTooManyStepsLinter do
-  it_should_behave_like 'a linter at the integration level'
-end

data/testing/rspec/spec/unit/cuke_linter_unit_spec.rb DELETED

@@ -1,114 +0,0 @@
-require_relative '../../../../environments/rspec_env'
-RSpec.describe 'the gem' do
-  let(:gemspec) { eval(File.read "#{__dir__}/../../../../cuke_linter.gemspec") }
-  it 'has an executable' do
-    expect(gemspec.executables).to include('cuke_linter')
-  end
-  it 'validates cleanly' do
-    mock_ui = Gem::MockGemUi.new
-    Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
-    expect(mock_ui.error).to_not match(/warn/i)
-  end
-end
-RSpec.describe CukeLinter do
-  it "has a version number" do
-    expect(CukeLinter::VERSION).not_to be nil
-  end
-  it "has a default keyword for 'Given'" do
-    expect(CukeLinter::DEFAULT_GIVEN_KEYWORD).to eq('Given')
-  end
-  it "has a default keyword for 'When'" do
-    expect(CukeLinter::DEFAULT_WHEN_KEYWORD).to eq('When')
-  end
-  it "has a default keyword for 'Then'" do
-    expect(CukeLinter::DEFAULT_THEN_KEYWORD).to eq('Then')
-  end
-  it 'can lint' do
-    expect(CukeLinter).to respond_to(:lint)
-  end
-  it 'lints the (optionally) given model trees and (optionally) file paths using the (optionally) provided set of linters and formats the output with the (optionally) provided formatters' do
-    expect(CukeLinter.method(:lint).arity).to eq(-1)
-    expect(CukeLinter.method(:lint).parameters).to match_array([[:key, :model_trees],
-                                                                [:key, :linters],
-                                                                [:key, :formatters],
-                                                                [:key, :file_paths]])
-  end
-  it 'can register a linter' do
-    expect(CukeLinter).to respond_to(:register_linter)
-  end
-  it 'can unregister a linter' do
-    expect(CukeLinter).to respond_to(:unregister_linter)
-  end
-  it 'registers a linter by name' do
-    expect(CukeLinter.method(:register_linter).arity).to eq(1)
-    expect(CukeLinter.method(:register_linter).parameters).to match_array([[:keyreq, :linter],
-                                                                           [:keyreq, :name]])
-  end
-  it 'unregisters a linter by name' do
-    expect(CukeLinter.method(:unregister_linter).arity).to eq(1)
-    expect(CukeLinter.method(:unregister_linter).parameters).to match_array([[:req, :name]])
-  end
-  it 'knows its currently registered linters' do
-    expect(CukeLinter).to respond_to(:registered_linters)
-  end
-  it 'correctly registers, unregisters, and tracks linters', :linter_registration do
-    CukeLinter.clear_registered_linters
-    CukeLinter.register_linter(name: 'foo', linter: :linter_1)
-    CukeLinter.register_linter(name: 'bar', linter: :linter_2)
-    CukeLinter.register_linter(name: 'baz', linter: :linter_3)
-    CukeLinter.unregister_linter('bar')
-    expect(CukeLinter.registered_linters).to eq({ 'foo' => :linter_1,
-                                                  'baz' => :linter_3, })
-  end
-  it 'can clear all of its currently registered linters', :linter_registration do
-    expect(CukeLinter).to respond_to(:clear_registered_linters)
-    CukeLinter.register_linter(name: 'some_linter', linter: :the_linter)
-    CukeLinter.clear_registered_linters
-    expect(CukeLinter.registered_linters).to eq({})
-  end
-  it 'can reset to its default set of linters' do
-    expect(CukeLinter).to respond_to(:reset_linters)
-  end
-  describe 'configuration' do
-    it 'can load a configuration' do
-      expect(CukeLinter).to respond_to(:load_configuration)
-    end
-    it 'is configured optionally via a file or a directly provided configuration' do
-      expect(CukeLinter.method(:load_configuration).arity).to eq(-1)
-      expect(CukeLinter.method(:load_configuration).parameters).to match_array([[:key, :config_file_path],
-                                                                                [:key, :config]])
-    end
-  end
-end

data/testing/rspec/spec/unit/formatters/formatter_unit_specs.rb DELETED

@@ -1,11 +0,0 @@
-shared_examples_for 'a formatter at the unit level' do
-  it 'can format' do
-    expect(subject).to respond_to(:format)
-  end
-  it 'formats linting data' do
-    expect(subject.method(:format).arity).to eq(1)
-  end
-end

data/testing/rspec/spec/unit/formatters/pretty_formatter_unit_spec.rb DELETED

@@ -1,115 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::PrettyFormatter do
-  it_should_behave_like 'a formatter at the unit level'
-  it 'formats linting data as pretty text' do
-    linting_data = [{ linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:1' },
-                    { linter:   'SomeOtherLinter',
-                      problem:  'Some other problem',
-                      location: 'path/to/the_file:1' },
-                    { linter:   'YetAnotherLinter',
-                      problem:  'Yet another problem',
-                      location: 'path/to/the_file' }]
-    results = subject.format(linting_data)
-    expect(results).to eq(['SomeLinter',
-                           '  Some problem',
-                           '    path/to/the_file:1',
-                           'SomeOtherLinter',
-                           '  Some other problem',
-                           '    path/to/the_file:1',
-                           'YetAnotherLinter',
-                           '  Yet another problem',
-                           '    path/to/the_file',
-                           '',
-                           '3 issues found'].join("\n"))
-  end
-  it 'groups data by linter and problem' do
-    linting_data = [{ linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:1' },
-                    { linter:   'SomeOtherLinter',
-                      problem:  'Some other problem',
-                      location: 'path/to/the_file:1' },
-                    { linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:11' }]
-    results = subject.format(linting_data)
-    expect(results).to eq(['SomeLinter',
-                           '  Some problem',
-                           '    path/to/the_file:1',
-                           '    path/to/the_file:11',
-                           'SomeOtherLinter',
-                           '  Some other problem',
-                           '    path/to/the_file:1',
-                           '',
-                           '3 issues found'].join("\n"))
-  end
-  it 'orders violations within the same problem category by file path' do
-    linting_data = [{ linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:1' },
-                    { linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:3' },
-                    { linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/a_different_file:2' }]
-    results = subject.format(linting_data)
-    expect(results).to eq(['SomeLinter',
-                           '  Some problem',
-                           '    path/to/a_different_file:2',
-                           '    path/to/the_file:1',
-                           '    path/to/the_file:3',
-                           '',
-                           '3 issues found'].join("\n"))
-  end
-  it 'orders violations in the same file by line number' do
-    linting_data = [{ linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:2' },
-                    { linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:3' },
-                    { linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:11' }, # larger number that is alphabetically lower
-                    { linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:3' }, # duplicate number
-                    { linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file' }, # no number
-                    { linter:   'SomeLinter',
-                      problem:  'Some problem',
-                      location: 'path/to/the_file:1' }]
-    results = subject.format(linting_data)
-    expect(results).to eq(['SomeLinter',
-                           '  Some problem',
-                           '    path/to/the_file',
-                           '    path/to/the_file:1',
-                           '    path/to/the_file:2',
-                           '    path/to/the_file:3',
-                           '    path/to/the_file:3',
-                           '    path/to/the_file:11',
-                           '',
-                           '6 issues found'].join("\n"))
-  end
-end

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

@@ -1,186 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-RSpec.describe CukeLinter::BackgroundDoesMoreThanSetupLinter 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('BackgroundDoesMoreThanSetupLinter')
-  end
-  describe 'linting' do
-    context 'a background with action steps' do
-      let(:test_model) do
-        CukeLinter::ModelFactory.generate_background_model(parent_file_path: model_file_path,
-                                                           source_text:      'Background:
-                                                                                When something')
-      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('Background has non-setup steps')
-      end
-    end
-    context 'a background with verification steps' do
-      let(:test_model) do
-        CukeLinter::ModelFactory.generate_background_model(parent_file_path: model_file_path,
-                                                           source_text:      'Background:
-                                                                                Then something')
-      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('Background has non-setup steps')
-      end
-    end
-    context 'a background with only setup steps' do
-      let(:test_model) do
-        gherkin = 'Background:
-                       Given something
-                       * (plus something)'
-        CukeLinter::ModelFactory.generate_background_model(source_text: gherkin)
-      end
-      it_should_behave_like 'a linter linting a good model'
-    end
-    describe 'configuration' do
-      let(:test_model) do
-        CukeLinter::ModelFactory.generate_background_model
-      end
-      context 'with configuration' do
-        before(:each) do
-          subject.configure(configuration)
-        end
-        context "with a configured 'When' keyword" do
-          let(:when_keyword) { 'Foo' }
-          let(:configuration) { { 'When' => when_keyword } }
-          it "uses the configured 'When' keyword" do
-            test_model.steps.first.keyword = when_keyword
-            result = subject.lint(test_model)
-            expect(result).to_not be_nil
-          end
-        end
-        context "with a configured 'Then' keyword" do
-          let(:then_keyword) { 'Foo' }
-          let(:configuration) { { 'Then' => then_keyword } }
-          it "uses the configured 'Then' keyword" do
-            test_model.steps.first.keyword = then_keyword
-            result = subject.lint(test_model)
-            expect(result).to_not be_nil
-          end
-        end
-      end
-      context 'without configuration' do
-        context 'because configuration never happened' do
-          it "uses the default 'When' keyword" do
-            test_model.steps.first.keyword = CukeLinter::DEFAULT_WHEN_KEYWORD
-            result = subject.lint(test_model)
-            expect(result).to_not be_nil
-          end
-          it "uses the default 'Then' keyword" do
-            test_model.steps.first.keyword = CukeLinter::DEFAULT_THEN_KEYWORD
-            result = subject.lint(test_model)
-            expect(result).to_not be_nil
-          end
-        end
-        context "because configuration did not set a 'When' keyword" do
-          before(:each) do
-            subject.configure(configuration)
-          end
-          let(:configuration) { {} }
-          it "uses the default 'When' keyword" do
-            test_model.steps.first.keyword = CukeLinter::DEFAULT_WHEN_KEYWORD
-            result = subject.lint(test_model)
-            expect(result).to_not be_nil
-          end
-        end
-        context "because configuration did not set a 'Then' keyword" do
-          before(:each) do
-            subject.configure(configuration)
-          end
-          let(:configuration) { {} }
-          it "uses the default 'Then' keyword" do
-            test_model.steps.first.keyword = CukeLinter::DEFAULT_THEN_KEYWORD
-            result = subject.lint(test_model)
-            expect(result).to_not be_nil
-          end
-        end
-      end
-    end
-    context 'a non-background model' do
-      let(:test_model) { CukeModeler::Model.new }
-      it_should_behave_like 'a linter linting a good model'
-    end
-  end
-end