gurke 3.3.4 → 3.3.5

data/spec/gurke/reporters/team_city_reporter_spec.rb

@@ -1,110 +1,100 @@
 # frozen_string_literal: true
 
-# rubocop:disable MissingCopEnableDirective
-# rubocop:disable Style/Semicolon
+# rubocop:disable Lint/MissingCopEnableDirective
 
 require 'spec_helper'
 
 RSpec.describe Gurke::Reporters::TeamCityReporter do
-  let(:output) { StringIO.new }
-  let(:reporter) { described_class.new(output) }
+  subject(:statements) do
+    reporter = described_class.new(StringIO.new)
+    reporter.send(*action)
+    reporter.io.string.scan(/##teamcity\[.*\]/)
+  end
 
-  subject { output.string.scan(/##teamcity\[.*\]/) }
+  let(:feature) { instance_double(Gurke::Feature) }
+  let(:scenario) { instance_double(Gurke::Scenario) }
+  let(:step) { instance_double(Gurke::Step) }
 
   describe '#before_feature' do
-    let(:feature) { double('feature') }
+    let(:action) { [:before_feature, feature] }
 
     before do
-      allow(feature).to receive(:name).and_return 'Demo feature'
-      allow(feature).to receive(:file).and_return \
-        File.join(Dir.getwd, 'features', 'file.feature')
-      allow(feature).to receive(:line).and_return 1
-      allow(feature).to receive(:description).and_return \
-        "As a developer\nI would like have this spec passed\nIn order to work on"
+      allow(feature).to receive_messages(name: 'Demo feature', file: File.join(Dir.getwd, 'features', 'file.feature'),
+        line: 1, description: <<~DESC.strip,)
+          As a developer
+          I would like have this spec passed
+          In order to work on
+        DESC
     end
 
-    subject { reporter.before_feature(feature); super() }
-
     it 'include a testSuiteStarted command' do
-      is_expected.to eq [
-        "##teamcity[testSuiteStarted name='Demo feature']"
+      expect(statements).to eq [
+        "##teamcity[testSuiteStarted name='Demo feature']",
       ]
     end
   end
 
   describe '#before_scenario' do
-    let(:scenario) { double('scenario') }
+    let(:action) { [:before_scenario, scenario] }
 
     before do
-      allow(scenario).to receive(:name).and_return 'Running the scenario'
-      allow(scenario).to receive(:file).and_return \
-        File.join(Dir.getwd, 'features', 'file.feature')
-      allow(scenario).to receive(:line).and_return 5
+      allow(scenario).to receive_messages(name: 'Running the scenario',
+        file: File.join(Dir.getwd, 'features', 'file.feature'), line: 5,)
     end
 
-    subject { reporter.before_scenario(scenario); super() }
-
     it do
-      is_expected.to eq [
-        "##teamcity[testStarted name='Running the scenario']"
+      expect(statements).to eq [
+        "##teamcity[testStarted name='Running the scenario']",
       ]
     end
   end
 
   describe '#after_scenario' do
-    let(:scenario) { double('scenario') }
+    let(:action) { [:after_scenario, scenario] }
 
     before do
-      allow(scenario).to receive(:name).and_return 'Running the scenario'
-      allow(scenario).to receive(:passed?).and_return(true)
-      allow(scenario).to receive(:failed?).and_return(false)
-      allow(scenario).to receive(:pending?).and_return(false)
-      allow(scenario).to receive(:aborted?).and_return(false)
+      allow(scenario).to receive_messages(name: 'Running the scenario', passed?: true, failed?: false, pending?: false,
+        aborted?: false,)
     end
 
-    subject { reporter.after_scenario(scenario); super() }
-
     it do
-      is_expected.to eq [
-        "##teamcity[testFinished name='Running the scenario']"
+      expect(statements).to eq [
+        "##teamcity[testFinished name='Running the scenario']",
       ]
     end
 
     context '<failed>' do
-      let(:exception) do
-        begin
-          raise RuntimeError.new
-        rescue RuntimeError => e
-          e
-        end
-      end
-
       before do
-        allow(scenario).to receive(:failed?).and_return(true)
-        allow(scenario).to receive(:exception).and_return(exception)
+        error = RuntimeError.new 'An error occurred'
+        allow(error).to receive(:backtrace).and_return([
+          '/path/to/file.rb:5:in `block (4 levels) in <top (required)>\'',
+          '/path/to/file.rb:24:in in `fail_with\'',
+        ])
+
+        allow(scenario).to receive_messages(failed?: true, exception: error)
       end
 
       it do
-        is_expected.to match [
-          match(/##teamcity\[testFailed name='.*' message='.*' backtrace='.*'\]/),
-          "##teamcity[testFinished name='Running the scenario']"
+        # rubocop:disable Layout/LineLength
+        expect(statements).to eq [
+          "##teamcity[testFailed name='Running the scenario' message='#<RuntimeError: An error occurred>' backtrace='/path/to/file.rb:5:in `block (4 levels) in <top (required)>|$1\\n/path/to/file.rb:24:in in `fail_with|$1']",
+          "##teamcity[testFinished name='Running the scenario']",
         ]
+        # rubocop:enable Layout/LineLength
       end
     end
   end
 
   describe '#after_feature' do
-    let(:feature) { double('feature') }
+    let(:action) { [:after_feature, feature] }
 
     before do
       allow(feature).to receive(:name).and_return 'Demo feature'
     end
 
-    subject { reporter.after_feature(feature); super() }
-
     it do
-      is_expected.to eq [
-        "##teamcity[testSuiteFinished name='Demo feature']"
+      expect(statements).to eq [
+        "##teamcity[testSuiteFinished name='Demo feature']",
       ]
     end
   end

data/spec/gurke/run_list_spec.rb

@@ -3,10 +3,10 @@
 require 'spec_helper'
 
 describe Gurke::RunList do
-  let(:reporter) { Gurke::Reporters::NullReporter.new }
-  let(:runner)   { double 'runner' }
-  let(:object)   { double 'object' }
-  let(:list)     { Gurke::RunList.new }
+  let(:reporter) { instance_double Gurke::Reporters::NullReporter }
+  let(:runner)   { instance_double Gurke::Runner }
+  let(:object)   { double 'runnable' } # rubocop:disable RSpec/VerifiedDoubles
+  let(:list)     { described_class.new }
 
   before do
     list << object
@@ -14,19 +14,17 @@ describe Gurke::RunList do
   end
 
   describe '#run' do
-    subject { list.run runner, reporter }
+    before { list.run runner, reporter }
 
-    it 'should run all objects' do
-      expect(object).to receive(:run).with(runner, reporter)
-      subject
+    it 'runs all objects' do
+      expect(object).to have_received(:run).with(runner, reporter)
     end
 
     context 'with additional args' do
-      subject { list.run runner, reporter, 0, :sym }
+      before { list.run runner, reporter, 0, :sym }
 
-      it 'should pass additional args' do
-        expect(object).to receive(:run).with(runner, reporter, 0, :sym)
-        subject
+      it 'passes additional args' do
+        expect(object).to have_received(:run).with(runner, reporter, 0, :sym)
       end
     end
   end

data/spec/gurke/scenario_spec.rb

@@ -3,65 +3,68 @@
 require 'spec_helper'
 
 describe Gurke::Scenario do
-  let(:reporter) { Gurke::Reporters::NullReporter.new }
-  let(:runner)   { double 'runner' }
-  let(:feature)  { double 'feature' }
-  let(:backgrounds) { double('backgrounds') }
+  let(:scenario) do
+    described_class.new(feature, nil, nil, tags, nil)
+  end
+
+  let(:reporter) { instance_double Gurke::Reporters::NullReporter }
+  let(:runner)   { instance_double Gurke::Runner }
+  let(:feature)  { instance_double Gurke::Feature }
+  let(:backgrounds) { instance_double Gurke::RunList }
   let(:tags) { [] }
 
   before do
-    allow(feature).to receive(:backgrounds).and_return(backgrounds)
+    allow(reporter).to receive(:invoke)
     allow(backgrounds).to receive(:run)
+    allow(feature).to receive(:backgrounds).and_return(backgrounds)
     allow(runner).to receive(:hook) {|_, _, &block| block.call }
   end
 
-  let(:scenario) do
-    Gurke::Scenario.new(feature, nil, nil, tags, nil)
-  end
-
   describe '#run' do
-    subject { scenario.run(runner, reporter) }
+    subject(:run) { scenario.run(runner, reporter) }
 
-    it 'runs all backgrounds' do
-      expect(backgrounds).to receive(:run)
-        .with(runner, reporter, scenario, scenario.send(:world))
+    context 'when running' do
+      before { run }
 
-      subject
-    end
-
-    it 'runs hook in scenario world' do
-      expect(runner).to receive(:hook) do |scope, context, world|
-        expect(scope).to eq :scenario
-        expect(context).to eq scenario
-        expect(world).to eq scenario.send(:world)
+      it 'has run all backgrounds' do
+        expect(backgrounds).to have_received(:run)
+          .with(runner, reporter, scenario, scenario.send(:world))
       end
 
-      subject
-    end
-
-    it 'runs reporter callbacks in correct order' do
-      expect(reporter).to receive(:invoke).exactly(4).times do |*args|
-        @scopes ||= []
-        @scopes << args.first
+      it 'has hooked in the scenario world' do
+        expect(runner).to have_received(:hook) do |scope, context, world|
+          expect(scope).to eq :scenario
+          expect(context).to eq scenario
+          expect(world).to eq scenario.send(:world)
+        end
       end
 
-      subject
+      it 'has invoked reporter callbacks in correct order' do
+        scopes = []
+        expect(reporter).to have_received(:invoke).exactly(4).times do |*args|
+          scopes << args.first
+        end
 
-      expect(@scopes).to eq %i[before_scenario start_scenario
-                               end_scenario after_scenario]
+        expect(scopes).to eq %i[
+          before_scenario
+          start_scenario
+          end_scenario
+          after_scenario
+        ]
+      end
     end
 
     context 'with retries' do
-      let(:step) { double('step') }
+      let(:step) { instance_double(Gurke::Step) }
       let(:worlds) { Set.new }
 
-      before { scenario.steps << step }
-
       before do
+        scenario.steps << step
         allow(runner).to receive(:retries).with(scenario).and_return(1)
       end
 
       it 'resets the world' do
+        # rubocop:disable RSpec/MessageSpies
         expect(step).to receive(:run) do |_, _, scenario, world|
           worlds << world
           scenario.failed!
@@ -72,10 +75,12 @@ describe Gurke::Scenario do
           scenario.passed!
         end
 
-        subject
+        run
 
         # Expect to have two *different* worlds collected
         expect(worlds.size).to eq 2
+
+        # rubocop:enable RSpec/MessageSpies
       end
     end
   end

data/spec/gurke/step_definition_spec.rb

@@ -2,28 +2,28 @@
 
 require 'spec_helper'
 
-require 'spec_helper'
-
 describe Gurke::StepDefinition do
+  subject(:sd) { step_definition }
+
   let(:pattern) { nil }
   let(:step_definition) { described_class.new pattern }
-  subject { step_definition }
+  let(:m) { Gurke::StepDefinition::Match }
 
-  context '#match' do
+  describe '#match' do
     context 'with regex' do
       let(:pattern) { /dies ist (ein|zwei) regex/ }
 
-      it { expect(subject.match('dies ist ein regex')).to be_a(Gurke::StepDefinition::Match) }
-      it { expect(subject.match('dies ist zwei regex')).to be_a(Gurke::StepDefinition::Match) }
+      it { expect(sd.match('dies ist ein regex')).to be_a(m) }
+      it { expect(sd.match('dies ist zwei regex')).to be_a(m) }
     end
 
     context 'with string' do
       let(:pattern) { 'a string' }
 
-      it { expect(subject.match('a string')).to be_a(Gurke::StepDefinition::Match) }
-      it { expect(subject.match(' a string')).to be_nil }
-      it { expect(subject.match('a string ')).to be_nil }
-      it { expect(subject.match(' a string ')).to be_nil }
+      it { expect(sd.match('a string')).to be_a(m) }
+      it { expect(sd.match(' a string')).to be_nil }
+      it { expect(sd.match('a string ')).to be_nil }
+      it { expect(sd.match(' a string ')).to be_nil }
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-if ENV['CI'] || (defined?(:RUBY_ENGINE) && RUBY_ENGINE != 'rbx')
-  require 'coveralls'
-  Coveralls.wear! do
-    add_filter 'spec'
-  end
-end
+require 'rspec'
+require 'simplecov'
+SimpleCov.start
 
-require 'bundler'
-Bundler.require
+if ENV['CI']
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
 
 require 'gurke'
 
-Dir[File.expand_path('spec/support/**/*.rb')].each {|f| require f }
+Dir[File.expand_path('spec/support/**/*.rb')].sort.each {|f| require f }
 
 module Helper
   def unindent(str)
@@ -23,4 +22,8 @@ end
 RSpec.configure do |config|
   config.order = 'random'
   config.include Helper
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gurke
 version: !ruby/object:Gem::Version
-  version: 3.3.4
+  version: 3.3.5
 platform: ruby
 authors:
 - Jan Graichen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-26 00:00:00.000000000 Z
+date: 2023-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -52,23 +52,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-description: An alternative gherkin feature runner inspired by rspec and turnip.
+description: 
 email:
-- jg@altimos.de
+- jgraichen@altimos.de
 executables:
 - gurke
 extensions: []
@@ -128,7 +114,8 @@ files:
 homepage: https://github.com/jgraichen/gurke
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -137,39 +124,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.4.21
 signing_key: 
 specification_version: 4
 summary: An alternative gherkin feature runner inspired by rspec and turnip.
-test_files:
-- features/gurke.feature
-- features/gurke.rb
-- features/gurke/backtrace_filtering.feature
-- features/gurke/context_in_hooks.feature
-- features/gurke/filter_by_tags.feature
-- features/gurke/include_by_tags.feature
-- features/gurke/other_reporter.feature
-- features/gurke/pending_steps.feature
-- features/gurke/retry_flaky_scenario.feature
-- features/gurke/retry_scenario.feature
-- features/gurke/run_specific_directories.feature
-- features/gurke/run_specific_scenarios.feature
-- features/gurke/step_specific_definitions.feature
-- features/support/steps/cli_steps.rb
-- features/support/steps/file_steps.rb
-- spec/gurke/feature_list_spec.rb
-- spec/gurke/reporters/compact_reporter_spec.rb
-- spec/gurke/reporters/default_reporter_spec.rb
-- spec/gurke/reporters/team_city_reporter_spec.rb
-- spec/gurke/run_list_spec.rb
-- spec/gurke/scenario_spec.rb
-- spec/gurke/step_definition_spec.rb
-- spec/spec_helper.rb
+test_files: []