gurke 3.3.4 → 3.3.5

data/lib/gurke/version.rb

@@ -4,9 +4,9 @@ module Gurke
   module VERSION
     MAJOR = 3
     MINOR = 3
-    PATCH = 4
+    PATCH = 5
     STAGE = nil
-    STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.').freeze
+    STRING = [MAJOR, MINOR, PATCH, STAGE].compact.join('.').freeze
 
     def self.to_s
       STRING

data/lib/gurke.rb

@@ -61,9 +61,9 @@ module Gurke
 
     # @api private
     def world
-      @world ||= const_set('World', Module.new)
+      @world ||= const_set(:World, Module.new)
     end
   end
 end
 
-::Module.send :include, Gurke::DSL
+Module.include Gurke::DSL

data/spec/gurke/feature_list_spec.rb

@@ -3,49 +3,46 @@
 require 'spec_helper'
 
 describe Gurke::FeatureList do
-  let(:reporter) { Gurke::Reporters::NullReporter.new }
-  let(:runner)   { double 'runner' }
-  let(:feature)  { double 'feature' }
+  let(:reporter) { instance_double Gurke::Reporters::NullReporter }
+  let(:runner)   { instance_double Gurke::Runner }
+  let(:feature)  { instance_double Gurke::Feature }
+  let(:features) { described_class.new }
 
   before do
     features << feature
 
-    allow(runner).to receive(:hook) {|_, _, &block| block.call }
-    allow(feature).to receive(:failed?).and_return false
-    allow(feature).to receive(:pending?).and_return false
+    allow(feature).to receive_messages(failed?: false, pending?: false)
     allow(feature).to receive(:run)
+    allow(reporter).to receive(:invoke)
+    allow(runner).to receive(:hook) {|_, _, &block| block.call }
   end
 
-  let(:features) { Gurke::FeatureList.new }
-
   describe '#run' do
-    subject { features.run runner, reporter }
+    before { features.run runner, reporter }
 
-    it 'should run all features' do
-      expect(feature).to receive(:run).with(runner, reporter)
-
-      subject
+    it 'runs all features' do
+      expect(feature).to have_received(:run).with(runner, reporter)
     end
 
-    it 'should run hooks' do
-      expect(runner).to receive(:hook) do |scope, world|
+    it 'runs hooks' do
+      expect(runner).to have_received(:hook) do |scope, world|
         expect(scope).to eq :features
-        expect(world).to eq nil
+        expect(world).to be_nil
       end
-
-      subject
     end
 
-    it 'should run reporter callbacks in correct order' do
-      expect(reporter).to receive(:invoke).exactly(4).times do |*args|
-        @scopes ||= []
-        @scopes << args.first
+    it 'runs reporter callbacks in correct order' do
+      scopes = []
+      expect(reporter).to have_received(:invoke).exactly(4).times do |*args|
+        scopes << args.first
       end
 
-      subject
-
-      expect(@scopes).to eq %i[before_features start_features
-                               end_features after_features]
+      expect(scopes).to eq %i[
+        before_features
+        start_features
+        end_features
+        after_features
+      ]
     end
   end
 end

data/spec/gurke/reporters/compact_reporter_spec.rb

@@ -1,52 +1,48 @@
 # frozen_string_literal: true
 
-# rubocop:disable MissingCopEnableDirective
-# rubocop:disable Style/Semicolon
+# rubocop:disable Lint/MissingCopEnableDirective
 
 require 'spec_helper'
 
 RSpec.describe Gurke::Reporters::CompactReporter do
-  let(:output) { StringIO.new }
-  let(:reporter) { described_class.new(output) }
-  subject { output.string }
+  subject(:out) do
+    reporter = described_class.new(StringIO.new)
+    reporter.send(*action)
+    reporter.io.string
+  end
 
-  describe '#before_feature' do
-    let(:feature) { double('feature') }
+  let(:feature) { instance_double(Gurke::Feature) }
+  let(:scenario) { instance_double(Gurke::Scenario) }
+  let(:step) { instance_double(Gurke::Step) }
 
-    subject { reporter.before_feature(feature); super() }
+  describe '#before_feature' do
+    let(:action) { [:before_feature, feature] }
 
     it { is_expected.to eq '' }
   end
 
   describe '#start_background' do
-    let(:feature) { double('feature') }
-
-    subject { reporter.start_background(feature); super() }
+    let(:action) { [:start_background, feature] }
 
     it { is_expected.to eq '' }
   end
 
   describe '#before_scenario' do
-    let(:scenario) { double('scenario') }
-
-    subject { reporter.before_scenario(scenario); super() }
+    let(:action) { [:before_scenario, scenario] }
 
     it { is_expected.to eq '' }
   end
 
   describe '#before_step' do
-    let(:step) { double('step') }
-
-    subject { reporter.before_step(step); super() }
+    let(:action) { [:before_step, step] }
 
     it { is_expected.to eq '' }
   end
 
   describe '#after_step' do
-    let(:feature) { double('feature') }
-    let(:scenario) { double('scenario') }
-    let(:step) { double('step') }
-    let(:result) { double('result') }
+    let(:action) { [:after_step, result, scenario] }
+
+    let(:result) { instance_double(Gurke::Step::StepResult) }
     let(:backgrounds) { [] }
     let(:exception) { nil }
 
@@ -55,40 +51,43 @@ RSpec.describe Gurke::Reporters::CompactReporter do
     end
 
     before do
-      allow(result).to receive(:step).and_return(step)
-      allow(result).to receive(:scenario).and_return(scenario)
-      allow(result).to receive(:state).and_return(state)
-      allow(result).to receive(:exception).and_return(exception)
+      allow(result).to receive_messages(
+        step: step,
+        scenario: scenario,
+        state: state,
+        exception: exception,
+      )
     end
 
     before do
-      allow(step).to receive(:name).and_return 'the scenario is passing'
-      allow(step).to receive(:keyword).and_return 'Given'
+      allow(step).to receive_messages(
+        name: 'the scenario is passing',
+        keyword: 'Given',
+      )
     end
 
     before do
-      allow(scenario).to receive(:feature).and_return(feature)
-      allow(scenario).to receive(:steps).and_return(steps)
-
-      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(
+        feature: feature,
+        steps: steps,
+        name: 'Running the scenario',
+        file: File.join(Dir.getwd, 'features', 'file.feature'),
+        line: 5,
+      )
     end
 
     before do
-      allow(feature).to receive(:backgrounds).and_return(backgrounds)
-
-      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(
+        backgrounds: backgrounds,
+        name: 'Demo feature',
+        file: File.join(Dir.getwd, 'features', 'file.feature'),
+        line: 1,
+        description: "As a developer\n" \
+                     "I would like have this spec passed\n" \
+                     'In order to work on',
+      )
     end
 
-    subject { reporter.after_step(result, scenario); super() }
-
     context 'with step passing' do
       let(:state) { :passed }
 
@@ -101,7 +100,7 @@ RSpec.describe Gurke::Reporters::CompactReporter do
       it { is_expected.to eq '' }
     end
 
-    context 'with step pending' do
+    context 'with step nil' do
       let(:state) { nil }
 
       it { is_expected.to eq '' }
@@ -111,30 +110,24 @@ RSpec.describe Gurke::Reporters::CompactReporter do
       let(:state) { :failed }
 
       before do
-        e = double 'exception'
-        c = double 'exception'
-
-        allow(e).to receive(:class).and_return(RuntimeError)
-        allow(e).to receive(:message).and_return('An error occurred')
-        allow(e).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(e).to receive(:cause).and_return(c)
-
-        allow(c).to receive(:class).and_return(IOError)
-        allow(c).to receive(:message).and_return('Socket closed')
-        allow(c).to receive(:backtrace).and_return([
-                                                     'script.rb:5:in `a\'',
-                                                     'script.rb:10:in `b\''
-                                                   ])
-
-        expect(result).to receive(:exception).and_return e
+        error = instance_double RuntimeError
+        cause = instance_double IOError
+
+        allow(error).to receive_messages(class: RuntimeError, message: 'An error occurred', backtrace: [
+          '/path/to/file.rb:5:in `block (4 levels) in <top (required)>\'',
+          '/path/to/file.rb:24:in in `fail_with\'',
+        ], cause: cause,)
+
+        allow(cause).to receive_messages(class: IOError, message: 'Socket closed', backtrace: [
+          'script.rb:5:in `a\'',
+          'script.rb:10:in `b\'',
+        ],)
+
+        allow(result).to receive(:exception).and_return error
       end
 
       it do
-        is_expected.to eq unindent <<~TEXT
+        expect(out).to eq unindent <<~TEXT
           .E
           .Feature: Demo feature   # features/file.feature:1
           .  Scenario: Running the scenario   # features/file.feature:5
@@ -153,22 +146,16 @@ RSpec.describe Gurke::Reporters::CompactReporter do
   end
 
   describe '#retry_scenario' do
-    let(:scenario) { double('scenario') }
-
-    subject { reporter.retry_scenario(scenario); super() }
+    let(:action) { [:retry_scenario, scenario] }
 
     it { is_expected.to eq '' }
   end
 
   describe '#after_scenario' do
-    let(:scenario) { double('scenario') }
-
-    subject { reporter.after_scenario(scenario); super() }
+    let(:action) { [:after_scenario, scenario] }
 
     before do
-      allow(scenario).to receive(:failed?).and_return(false)
-      allow(scenario).to receive(:passed?).and_return(true)
-      allow(scenario).to receive(:pending?).and_return(false)
+      allow(scenario).to receive_messages(failed?: false, passed?: true, pending?: false)
     end
 
     it { is_expected.to eq '.' }
@@ -191,20 +178,16 @@ RSpec.describe Gurke::Reporters::CompactReporter do
   end
 
   describe '#after_feature' do
-    let(:feature) { double('feature') }
-
-    subject { reporter.after_feature(feature); super() }
+    let(:action) { [:after_feature, feature] }
 
     it { is_expected.to eq '' }
   end
 
   describe '#after_features' do
-    let(:features) { [] }
-
-    subject { reporter.after_features(features); super() }
+    let(:action) { [:after_features, []] }
 
     it do
-      is_expected.to eq unindent <<~TEXT
+      expect(out).to eq unindent <<~TEXT
         .
         .
         .0 scenarios: 0 passed, 0 failing, 0 pending

data/spec/gurke/reporters/default_reporter_spec.rb

@@ -1,31 +1,34 @@
 # frozen_string_literal: true
 
-# rubocop:disable MissingCopEnableDirective
-# rubocop:disable Style/Semicolon
+# rubocop:disable Lint/MissingCopEnableDirective
 
 require 'spec_helper'
 
 RSpec.describe Gurke::Reporters::DefaultReporter do
-  let(:output) { StringIO.new }
-  let(:reporter) { described_class.new(output) }
-  subject { output.string }
+  subject(:out) do
+    reporter = described_class.new(StringIO.new)
+    reporter.send(*action)
+    reporter.io.string
+  end
+
+  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
-      expect(feature).to receive(:name).and_return 'Demo feature'
-      expect(feature).to receive(:file).and_return \
-        File.join(Dir.getwd, 'features', 'file.feature')
-      expect(feature).to receive(:line).and_return 1
-      expect(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 do
-      is_expected.to eq unindent <<~TEXT
+      expect(out).to eq unindent <<~TEXT
         Feature: Demo feature   # features/file.feature:1
           As a developer
           I would like have this spec passed
@@ -37,12 +40,10 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
   end
 
   describe '#start_background' do
-    let(:feature) { double('feature') }
-
-    subject { reporter.start_background(feature); super() }
+    let(:action) { [:start_background, feature] }
 
     it do
-      is_expected.to eq unindent <<~TEXT
+      expect(out).to eq unindent <<~TEXT
         .    Background:
         .
       TEXT
@@ -50,19 +51,15 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
   end
 
   describe '#before_scenario' do
-    let(:scenario) { double('scenario') }
+    let(:action) { [:before_scenario, scenario] }
 
     before do
-      expect(scenario).to receive(:name).and_return 'Running the scenario'
-      expect(scenario).to receive(:file).and_return \
-        File.join(Dir.getwd, 'features', 'file.feature')
-      expect(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 unindent <<~TEXT
+      expect(out).to eq unindent <<~TEXT
         .  Scenario: Running the scenario   # features/file.feature:5
         .
       TEXT
@@ -70,36 +67,32 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
   end
 
   describe '#before_step' do
-    let(:step) { double('step') }
+    let(:action) { [:before_step, step] }
 
     before do
-      expect(step).to receive(:name).and_return 'the scenario is passing'
-      expect(step).to receive(:keyword).and_return 'Given'
+      allow(step).to receive_messages(name: 'the scenario is passing', keyword: 'Given')
     end
 
-    subject { reporter.before_step(step); super() }
-
     it do
-      is_expected.to eq unindent <<~TEXT
+      expect(out).to eq unindent <<~TEXT
         .    Given the scenario is passing
       TEXT
     end
   end
 
   describe '#after_step' do
-    let(:step) { double('step') }
+    let(:action) { [:after_step, result, scenario] }
+    let(:result) { instance_double(Gurke::Step::StepResult) }
 
     before do
-      expect(step).to receive(:state).and_return state
+      allow(result).to receive(:state).and_return state
     end
 
-    subject { reporter.after_step(step); super() }
-
     context 'with step passing' do
       let(:state) { :passed }
 
       it do
-        is_expected.to eq unindent <<~TEXT
+        expect(out).to eq unindent <<~TEXT
           . (passed)
           .
         TEXT
@@ -110,18 +103,18 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
       let(:state) { :pending }
 
       it do
-        is_expected.to eq unindent <<~TEXT
+        expect(out).to eq unindent <<~TEXT
           . (pending)
           .
         TEXT
       end
     end
 
-    context 'with step pending' do
+    context 'with step nil' do
       let(:state) { nil }
 
       it do
-        is_expected.to eq unindent <<~TEXT
+        expect(out).to eq unindent <<~TEXT
           . (skipped)
           .
         TEXT
@@ -132,30 +125,24 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
       let(:state) { :failed }
 
       before do
-        e = double 'exception'
-        c = double 'exception'
-
-        allow(e).to receive(:class).and_return(RuntimeError)
-        allow(e).to receive(:message).and_return('An error occurred')
-        allow(e).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(e).to receive(:cause).and_return(c)
-
-        allow(c).to receive(:class).and_return(IOError)
-        allow(c).to receive(:message).and_return('Socket closed')
-        allow(c).to receive(:backtrace).and_return([
-                                                     'script.rb:5:in `a\'',
-                                                     'script.rb:10:in `b\''
-                                                   ])
-
-        expect(step).to receive(:exception).and_return e
+        error = instance_double RuntimeError
+        cause = instance_double IOError
+
+        allow(error).to receive_messages(class: RuntimeError, message: 'An error occurred', backtrace: [
+          '/path/to/file.rb:5:in `block (4 levels) in <top (required)>\'',
+          '/path/to/file.rb:24:in in `fail_with\'',
+        ], cause: cause,)
+
+        allow(cause).to receive_messages(class: IOError, message: 'Socket closed', backtrace: [
+          'script.rb:5:in `a\'',
+          'script.rb:10:in `b\'',
+        ],)
+
+        allow(result).to receive(:exception).and_return error
       end
 
       it do
-        is_expected.to eq unindent <<~TEXT
+        expect(out).to eq unindent <<~TEXT
           . (failure)
           .        RuntimeError: An error occurred
           .          /path/to/file.rb:5:in `block (4 levels) in <top (required)>'
@@ -171,9 +158,7 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
   end
 
   describe '#retry_scenario' do
-    let(:scenario) { double('scenario') }
-
-    subject { reporter.retry_scenario(scenario); super() }
+    let(:action) { [:retry_scenario, scenario] }
 
     context 'with normal scenario' do
       before do
@@ -181,7 +166,7 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
       end
 
       it do
-        is_expected.to eq unindent <<~TEXT
+        expect(out).to eq unindent <<~TEXT
           .
           .  Retry scenario due to previous failure:
           .
@@ -196,7 +181,7 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
       end
 
       it do
-        is_expected.to eq unindent <<~TEXT
+        expect(out).to eq unindent <<~TEXT
           .
           .  Retry flaky scenario due to previous failure:
           .
@@ -207,12 +192,10 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
   end
 
   describe '#after_scenario' do
-    let(:scenario) { double('scenario') }
-
-    subject { reporter.after_scenario(scenario); super() }
+    let(:action) { [:after_scenario, scenario] }
 
     it do
-      is_expected.to eq unindent <<~TEXT
+      expect(out).to eq unindent <<~TEXT
         .
         .
       TEXT
@@ -220,12 +203,10 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
   end
 
   describe '#after_feature' do
-    let(:feature) { double('feature') }
-
-    subject { reporter.after_feature(feature); super() }
+    let(:action) { [:after_feature, feature] }
 
     it do
-      is_expected.to eq unindent <<~TEXT
+      expect(out).to eq unindent <<~TEXT
         .
         .
       TEXT
@@ -233,12 +214,10 @@ RSpec.describe Gurke::Reporters::DefaultReporter do
   end
 
   describe '#after_features' do
-    let(:features) { [] }
-
-    subject { reporter.after_features(features); super() }
+    let(:action) { [:after_features, []] }
 
     it do
-      is_expected.to eq unindent <<~TEXT
+      expect(out).to eq unindent <<~TEXT
         .0 scenarios: 0 failing, 0 pending
         .
         .