cuke_linter 0.13.0 → 1.0.0

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

@@ -1,233 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::TestWithSetupStepAfterVerificationStepLinter 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('TestWithSetupStepAfterVerificationStepLinter')
-  end
-
-  describe 'linting' do
-
-    ['scenario', 'outline'].each do |model_type|
-
-      context "with a #{model_type} that has a setup step after a verification step" do
-
-        let(:test_model) do
-          model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model",
-                                                      parent_file_path: model_file_path)
-          model.steps = [CukeModeler::Step.new('Then a step'),
-                         CukeModeler::Step.new('Given a step')]
-
-          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("Test has 'Given' step after 'Then' step.")
-        end
-
-      end
-
-      context "with a #{model_type} that does not have a setup step after a verification step" do
-
-        context 'because it has no steps' do
-
-          context 'because its steps are empty' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = []
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-          context 'because its steps are nil' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = nil
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-        context 'because its setup steps come before its verification steps' do
-
-          let(:test_model) do
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.steps = [CukeModeler::Step.new('Given a step'),
-                           CukeModeler::Step.new('Then a step'),]
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-      end
-
-      context "with a #{model_type} that has an associated background" do
-
-        let(:test_model) do
-          feature_model = CukeLinter::ModelFactory.generate_feature_model(source_text: 'Feature:
-                                                                                          Background:
-                                                                                            Given a step
-                                                                                            Then a step
-                                                                                            Given a step
-                                                                                            Then a step')
-
-          model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-          model.steps = [CukeModeler::Step.new('Given a step')]
-
-          model.parent_model = feature_model
-          feature_model.tests << model
-
-          model
-        end
-
-        it 'does not consider those steps when linting' do
-          expect(subject.lint(test_model)).to eq(nil)
-        end
-
-      end
-
-    end
-
-    describe 'configuration' do
-
-      let(:test_model) do
-        CukeLinter::ModelFactory.generate_scenario_model(source_text: 'Scenario:
-                                                                         Then a step
-                                                                         Given a step')
-      end
-
-      context 'with configuration' do
-
-        before(:each) do
-          subject.configure(configuration)
-        end
-
-        context "with a configured 'Given' keyword" do
-
-          let(:given_keyword) { 'Foo' }
-          let(:configuration) { { 'Given' => given_keyword } }
-
-          it "uses the configured 'Given' keyword" do
-            test_model.steps.last.keyword = given_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 'Given' keyword" do
-            test_model.steps.last.keyword = CukeLinter::DEFAULT_GIVEN_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 'Given' keyword" do
-
-          before(:each) do
-            subject.configure(configuration)
-          end
-
-          let(:configuration) { {} }
-
-          it "uses the default 'Given' keyword" do
-            test_model.steps.last.keyword = CukeLinter::DEFAULT_GIVEN_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-test 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/test_with_setup_step_as_final_step_linter_unit_spec.rb

@@ -1,164 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::TestWithSetupStepAsFinalStepLinter 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('TestWithSetupStepAsFinalStepLinter')
-  end
-
-  describe 'linting' do
-
-    ['scenario', 'outline'].each do |model_type|
-
-      context "with a #{model_type} that has a setup step as its final step" do
-
-        let(:test_model) do
-          model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-          model.steps = [CukeModeler::Step.new('When a step'),
-                         CukeModeler::Step.new('Given a step')]
-
-          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("Test has 'Given' as the final step.")
-        end
-
-      end
-
-      context "with a #{model_type} that does not have a setup step as its final step" do
-
-        context 'because it has no steps' do
-
-          context 'because its steps are empty' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = []
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-          context 'because its steps are nil' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = nil
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-        context 'because its final step is not a setup step' do
-
-          let(:test_model) do
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.steps = [CukeModeler::Step.new('Then a step')]
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-      end
-
-    end
-
-    describe 'configuration' do
-
-      let(:test_model) do
-        CukeLinter::ModelFactory.generate_scenario_model(source_text: 'Scenario:
-                                                                         * a step')
-      end
-
-      context 'with configuration' do
-
-        before(:each) do
-          subject.configure(configuration)
-        end
-
-        context "with a configured 'Given' keyword" do
-
-          let(:given_keyword) { 'Foo' }
-          let(:configuration) { { 'Given' => given_keyword } }
-
-          it "uses the configured 'Given' keyword" do
-            test_model.steps.last.keyword = given_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 'Given' keyword" do
-            test_model.steps.last.keyword = CukeLinter::DEFAULT_GIVEN_KEYWORD
-
-            result = subject.lint(test_model)
-
-            expect(result).to_not be_nil
-          end
-
-        end
-
-        context "because configuration did not set a 'Given' keyword" do
-
-          before(:each) do
-            subject.configure(configuration)
-          end
-
-          let(:configuration) { {} }
-
-          it "uses the default 'Given' keyword" do
-            test_model.steps.last.keyword = CukeLinter::DEFAULT_GIVEN_KEYWORD
-
-            result = subject.lint(test_model)
-
-            expect(result).to_not be_nil
-          end
-
-        end
-
-      end
-
-    end
-
-    context 'a non-test 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/test_with_too_many_steps_linter_unit_spec.rb

@@ -1,192 +0,0 @@
-require_relative '../../../../../environments/rspec_env'
-
-
-RSpec.describe CukeLinter::TestWithTooManyStepsLinter 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('TestWithTooManyStepsLinter')
-  end
-
-  describe 'linting' do
-
-    ['scenario', 'outline'].each do |model_type|
-
-      context "with a #{model_type} that has too many steps" do
-
-        let(:test_model) do
-          model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: model_file_path)
-          model.steps = [:step_1,
-                         :step_2,
-                         :step_3,
-                         :step_4,
-                         :step_5,
-                         :step_6,
-                         :step_7,
-                         :step_8,
-                         :step_9,
-                         :step_10,
-                         :step_11]
-
-          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(/^Test has too many steps. \d+ steps found \(max 10\)/)
-        end
-
-        it 'includes the number of steps found in the problem record' do
-          step_count = test_model.steps.count
-          result     = subject.lint(test_model)
-          expect(result[:problem]).to eq("Test has too many steps. #{step_count} steps found (max 10).")
-
-          test_model.steps << :another_step
-          result = subject.lint(test_model)
-          expect(result[:problem]).to eq("Test has too many steps. #{step_count + 1} steps found (max 10).")
-        end
-
-      end
-
-      context "with a #{model_type} that does not have too many steps" do
-
-        context 'because it has fewer than 10 steps' do
-
-          let(:test_model) do
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: 'path_to_file')
-            model.steps = [:step_1]
-
-            model
-          end
-
-          it_should_behave_like 'a linter linting a good model'
-
-        end
-
-        context 'because it has no steps' do
-
-          context 'because its steps are empty' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: 'path_to_file')
-              model.steps = []
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-          context 'because its steps are nil' do
-
-            let(:test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model", parent_file_path: 'path_to_file')
-              model.steps = nil
-
-              model
-            end
-
-            it_should_behave_like 'a linter linting a good model'
-
-          end
-
-        end
-
-      end
-
-
-      describe 'configuration' do
-
-        context 'with no configuration' do
-
-          let(:default_step_threshhold) { 10 }
-
-          context 'because configuration never happened' do
-
-            let(:unconfigured_test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = []
-              (default_step_threshhold + 1).times { model.steps << :a_step }
-
-              model
-            end
-
-            it 'defaults to a step threshold of 10 steps' do
-              result = subject.lint(unconfigured_test_model)
-
-              expect(result[:problem]).to match(/^Test has too many steps. #{unconfigured_test_model.steps.count} steps found \(max 10\)/)
-            end
-
-          end
-
-          context 'because configuration did not set a step threshold' do
-            let(:configuration) { {} }
-            let(:configured_test_model) do
-              model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-              model.steps = []
-              (default_step_threshhold + 1).times { model.steps << :a_step }
-
-              subject.configure(configuration)
-
-              model
-            end
-
-            it 'defaults to a step threshold of 10 steps' do
-              result = subject.lint(configured_test_model)
-
-              expect(result[:problem]).to match(/^Test has too many steps. #{configured_test_model.steps.count} steps found \(max 10\)/)
-            end
-
-          end
-
-        end
-
-
-        context 'with configuration' do
-
-          let(:step_threshhold) { 3 }
-          let(:configuration) { { 'StepThreshold' => step_threshhold } }
-
-          subject { linter = CukeLinter::TestWithTooManyStepsLinter.new
-                    linter.configure(configuration)
-                    linter }
-
-          let(:test_model) do
-            model       = CukeLinter::ModelFactory.send("generate_#{model_type}_model")
-            model.steps = []
-            (step_threshhold + 1).times { model.steps << :a_step }
-
-            model
-          end
-
-          it 'the step threshold used is the configured value' do
-            result = subject.lint(test_model)
-
-            expect(result[:problem]).to match(/^Test has too many steps. #{test_model.steps.count} steps found \(max #{step_threshhold}\)/)
-          end
-
-        end
-
-      end
-
-    end
-
-    context 'a non-test model' do
-
-      let(:test_model) { CukeModeler::Model.new }
-
-      it_should_behave_like 'a linter linting a good model'
-
-    end
-  end
-end