flatware-cucumber 1.2.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 265407eeff8748e873d84126d35f1341bfd0c82e153370adc64206be66400f77
-  data.tar.gz: d7838a350284cfeb715530d4ca07f60c134d0afcb4aa4b75f7138341dc7d308e
+  metadata.gz: ca4704cbed2b88a90d866db8ba7b74b3ba32214e27ab1c543a802f6fd90f11a6
+  data.tar.gz: 38d82c0121d3c9a3c67e3b129ae75f1fdbefa31c1dd6486b48c17b3793651094
 SHA512:
-  metadata.gz: 94f4cd09f4186b373d95215544decc76825afc51cbc7395be759ac19128f93c819f18d7e0726d15b8592a36e83d9a50223da1cd59d7323d38f336ee84b4ff317
-  data.tar.gz: ebed813f6ae2f7c9726cd764b53ac42bc11e39b4c18c3f36a82809e88d51bb25e373378286b2b573adf40d4b75643a7c98481d13c67ac088f290d04424f0c272
+  metadata.gz: 5a8b8f51c2c83933398e7b8f3d19ec55db65d58dfc944966a094e97fc176893af18f79b486cf101159a07d4588ff86bc75d800d032c4809e1f120c9c03ce2cba
+  data.tar.gz: 3262a5428592bd11866750ce8a019a5433471296b7b7e2f00f4316cbbfdc51536ad08c1a6c11525f1343e5ce15053648a9320b7c6cfbe058c6653b81895752b2

data/README.md

@@ -7,39 +7,6 @@
 
 Flatware parallelizes your test suite to significantly reduce test time.
 
-## Requirements
-
-* ZeroMQ > 4.0
-
-## Installation
-
-### ZeroMQ
-
-#### Linux Ubuntu
-
-```sh
-sudo apt-get install -qq libzmq3-dev
-```
-
-(Never you mind the 3. This package contains ZMQ version 4.)
-
-#### Mac OSX
-
-
-If you're on macOS 10.12, use the custom hashrocket ZMQ homebrew formula.
-
-```sh
-brew tap hashrocket/formulas
-brew install hashrocket/formulas/zeromq
-```
-
-The stock homebrew version will likely work on older versions of macOS.
-
-
-```sh
-brew install zeromq
-```
-
 ### Flatware
 
 Add the runners you need to your Gemfile:
@@ -81,8 +48,9 @@ For this to work the configuration option must be loaded before any specs are ru
 
     --require spec_helper
 
-But beware, if you're using ActiveRecord in your suite you'll need to avoid doing things that cause it to establish a database connection in `spec_helper.rb`. If ActiveRecord connects before flatware forks off workers, each will die messily. All of this will just work if you're following [the recomended pattern of splitting your helpers into `spec_helper` and `rails_helper`](https://github.com/rspec/rspec-rails/blob/v3.8.2/lib/generators/rspec/install/templates/spec/rails_helper.rb).
-
+But beware, if you're using ActiveRecord in your suite you'll need to avoid doing things that cause it to establish a database connection in `spec_helper.rb`. If ActiveRecord connects before flatware forks off workers, each will die messily. All of this will just work if you're following [the recomended pattern of splitting your helpers into `spec_helper` and `rails_helper`](https://github.com/rspec/rspec-rails/blob/v3.8.2/lib/generators/rspec/install/templates/spec/rails_helper.rb). Another option is to use [the configurable hooks](
+#faster-startup-with-activerecord
+).
 
 ### Options
 
@@ -134,9 +102,31 @@ Now you are ready to rock:
 $ flatware rspec && flatware cucumber
 ```
 
-## Planned Features
+### Faster Startup With ActiveRecord
+
+Flatware has a couple lifecycle callbacks that you can use to avoid booting your app
+over again on every core. One way to take advantage of this via a `spec/flatware_helper.rb` file like so:
 
-* Use heuristics to run your slowest tests first
+```ruby
+Flatware.configure do |conf|
+  conf.before_fork do
+    require 'rails_helper'
+
+    ActiveRecord::Base.connection.disconnect!
+  end
+
+  conf.after_fork do |test_env_number|
+    config = ActiveRecord::Base.connection_config
+
+    ActiveRecord::Base.establish_connection(
+      config.merge(
+        database: config.fetch(:database) + test_env_number.to_s
+      )
+    )
+  end
+end
+```
+Now when I run `bundle exec flatware rspec -r ./spec/flatware_helper` My app only boots once, rather than once per core.
 
 ## Design Goals
 
@@ -167,20 +157,10 @@ directory. CD there and `flatware` will be in your path so you can tinker away.
 
 ## How it works
 
-Flatware relies on a message passing system to enable concurrency.
-The main process declares a worker for each cpu in the computer. Each
-worker forks from the main process and is then assigned a portion of the
-test suite.  As the worker runs the test suite it sends progress
-messages to the main process.  These messages are collected and when
-the last worker is finished the main process provides a report on the
-collected progress messages.
+Flatware relies on a message passing system to enable concurrency. The main process forks a worker for each cpu in the computer. These workers are each given a chunk of the tests to run. The workers report back to the main process about their progress. The main process prints those progress messages. When the last worker is finished the main process prints the results.
 
 ## Resources
 
-To learn more about the messaging system that Flatware uses, take a look at the
-[excellent ZeroMQ guide][z].
-
-[z]: http://zguide.zeromq.org/page:all
 [a]: https://github.com/cucumber/aruba
 
 ## Contributing to Flatware

data/lib/flatware/cucumber.rb

@@ -1,7 +1,6 @@
 require 'cucumber'
 require 'flatware/cucumber/formatter'
 require 'flatware/cucumber/result'
-require 'flatware/cucumber/scenario_result'
 require 'flatware/cucumber/step_result'
 require 'flatware/cucumber/formatters/console'
 require 'flatware/cucumber/cli'
@@ -10,8 +9,10 @@ module Flatware
   module Cucumber
     class Config
       attr_reader :config, :args
+
       def initialize(cucumber_config, args)
-        @config, @args = cucumber_config, args
+        @config = cucumber_config
+        @args = args
       end
 
       def feature_dir
@@ -29,9 +30,9 @@ module Flatware
       end
     end
 
-    extend self
+    module_function
 
-    def configure(args, out_stream=$stdout, error_stream=$stderr)
+    def configure(args, out_stream = $stdout, error_stream = $stderr)
       raw_args = args.dup
       cli_config = ::Cucumber::Cli::Configuration.new(out_stream, error_stream)
       cli_config.parse! args + %w[--format Flatware::Cucumber::Formatter]

data/lib/flatware/cucumber/cli.rb

@@ -1,22 +1,46 @@
+# frozen_string_literal: true
+
 require 'flatware/cli'
 
 module Flatware
+  # cucumber thor command
   class CLI
     worker_option
-    method_option 'dispatch-endpoint', type: :string, default: 'ipc://dispatch'
-    method_option 'sink-endpoint', type: :string, default: 'ipc://task'
-    desc "cucumber [FLATWARE_OPTS] [CUCUMBER_ARGS]", "parallelizes cucumber with custom arguments"
+    method_option(
+      'sink-endpoint',
+      type: :string,
+      default: 'drbunix:sink'
+    )
+    desc(
+      'cucumber [FLATWARE_OPTS] [CUCUMBER_ARGS]',
+      'parallelizes cucumber with custom arguments'
+    )
     def cucumber(*args)
       config = Cucumber.configure args
 
-      unless config.jobs.any?
-        puts "Please create some feature files in the #{config.feature_dir} directory."
-        exit 1
-      end
+      ensure_jobs(config)
 
       Flatware.verbose = options[:log]
-      Worker.spawn count: workers, runner: Cucumber, dispatch: options['dispatch-endpoint'], sink: options['sink-endpoint']
-      start_sink jobs: config.jobs, workers: workers, formatter: Flatware::Cucumber::Formatters::Console.new($stdout, $stderr)
+      sink = options['sink-endpoint']
+      Worker.spawn(count: workers, runner: Cucumber, sink: sink)
+      start_sink(
+        jobs: config.jobs,
+        workers: workers,
+        formatter: Flatware::Cucumber::Formatters::Console.new($stdout, $stderr)
+      )
+    end
+
+    private
+
+    def ensure_jobs(config)
+      return if config.jobs.any?
+
+      abort(
+        format(
+          'Please create some feature files in the %<dir>s directory.',
+          dir: config.feature_dir
+        )
+      )
     end
   end
 end

data/lib/flatware/cucumber/formatter.rb

@@ -6,7 +6,7 @@ module Flatware
     class Formatter
       Checkpoint = Struct.new :steps, :scenarios do
         def failures?
-          scenarios.any? &:failed?
+          scenarios.any?(&:failed?)
         end
       end
 
@@ -21,6 +21,7 @@ module Flatware
       end
 
       def initialize(config)
+        # FIXME: can we sneak the sink in through the config?
         config.on_event :test_case_finished, &method(:on_test_case_finished)
         config.on_event :test_step_finished, &method(:on_test_step_finished)
         config.on_event :test_run_finished,  &method(:on_test_run_finished)
@@ -39,7 +40,11 @@ module Flatware
       attr_reader :steps, :scenarios, :matched_steps
 
       def on_test_case_finished(event)
-        scenarios << Scenario.new(event.test_case.name, event.test_case.location.to_s, event.result.to_sym)
+        scenarios << Scenario.new(
+          event.test_case.name,
+          event.test_case.location.to_s,
+          event.result.to_sym
+        )
       end
 
       def on_step_activated(event)
@@ -47,14 +52,18 @@ module Flatware
       end
 
       def on_test_step_finished(event)
-        if really_a_step?(event.test_step) or event.result.undefined?
-          steps << StepResult.new(event.result.to_sym, event.result.failed? && event.result.exception)
-          Sink::client.progress Result.new event.result.to_sym
-        end
+        result = event.result
+        return unless really_a_step?(event.test_step) || result.undefined?
+
+        steps << StepResult.new(
+          result.to_sym,
+          result.failed? && result.exception
+        )
+        Sink.client.progress Result.new result.to_sym
       end
 
       def on_test_run_finished(*)
-        Sink::client.checkpoint Checkpoint.new steps, scenarios
+        Sink.client.checkpoint Checkpoint.new steps, scenarios
         reset
       end
 

data/lib/flatware/cucumber/formatters/console.rb

@@ -1,48 +1,56 @@
+# frozen_string_literal: true
+
 require 'flatware/cucumber/formatters/console/summary'
 require 'cucumber/formatter/console'
 
-module Flatware::Cucumber::Formatters
-  class Console
-    #for format_string
-    include ::Cucumber::Formatter::Console
-
-    FORMATS = {
-      passed:    '.',
-      failed:    'F',
-      undefined: 'U',
-      pending:   'P',
-      skipped:   '-'
-    }
-
-    STATUSES = FORMATS.keys
-
-    attr_reader :out, :err
-
-    def initialize(stdout, stderr)
-      @out, @err = stdout, stderr
-    end
-
-    def progress(result)
-      out.print format result.progress
-    end
-
-    def summarize(checkpoints)
-      steps = checkpoints.flat_map(&:steps)
-      scenarios = checkpoints.flat_map(&:scenarios)
-      Summary.new(steps, scenarios, out).summarize
-    end
-
-    def summarize_remaining(remaining_jobs)
-      out.puts
-      out.puts "The following features have not been run:"
-      for job in remaining_jobs
-        out.puts job.id
+module Flatware
+  module Cucumber
+    module Formatters
+      class Console
+        # for format_string
+        include ::Cucumber::Formatter::Console
+
+        FORMATS = {
+          passed: '.',
+          failed: 'F',
+          undefined: 'U',
+          pending: 'P',
+          skipped: '-'
+        }.freeze
+
+        STATUSES = FORMATS.keys
+
+        attr_reader :out, :err
+
+        def initialize(stdout, stderr)
+          @out = stdout
+          @err = stderr
+        end
+
+        def progress(result)
+          out.print format result.progress
+        end
+
+        def summarize(checkpoints)
+          steps = checkpoints.flat_map(&:steps)
+          scenarios = checkpoints.flat_map(&:scenarios)
+          Summary.new(steps, scenarios, out).summarize
+        end
+
+        def summarize_remaining(remaining_jobs)
+          out.puts
+          out.puts 'The following features have not been run:'
+          remaining_jobs.each do |job|
+            out.puts job.id
+          end
+        end
+
+        private
+
+        def format(status)
+          format_string FORMATS[status], status
+        end
       end
     end
-
-    private
-    def format(status)
-      format_string FORMATS[status], status
-    end
   end
 end

data/lib/flatware/cucumber/formatters/console/summary.rb

@@ -1,64 +1,82 @@
 require 'cucumber/formatter/console'
 require 'flatware/cucumber/formatters/console'
 
-module Flatware::Cucumber::Formatters
-  class Console
-    class Summary
-      include ::Cucumber::Formatter::Console
-      attr_reader :io, :steps, :scenarios
+module Flatware
+  module Cucumber
+    module Formatters
+      class Console
+        class Summary
+          include ::Cucumber::Formatter::Console
+          attr_reader :io, :steps, :scenarios
 
-      def initialize(steps, scenarios=[], io=StringIO.new)
-        @io = io
-        @steps = steps
-        @scenarios = scenarios
-      end
+          def initialize(steps, scenarios = [], io = StringIO.new)
+            @io = io
+            @steps = steps
+            @scenarios = scenarios
+          end
 
-      def summarize
-        2.times { io.puts }
-        print_failures(steps, 'step')
-        print_failures(scenarios.select(&:failed_outside_step?), 'scenario')
-        print_failed_scenarios scenarios
-        print_counts 'scenario', scenarios
-        print_counts 'step', steps
-      end
+          def summarize
+            2.times { io.puts }
+            print_failures(steps, 'step')
+            print_failures(scenarios.select(&:failed_outside_step?), 'scenario')
+            print_failed_scenarios scenarios
+            print_counts 'scenario', scenarios
+            print_counts 'step', steps
+          end
 
-      private
+          private
 
-      def print_failed_scenarios(scenarios)
-        return unless scenarios.any? &with_status(:failed)
+          def print_failed_scenarios(scenarios)
+            failed_scenarios = scenarios.select(&with_status(:failed))
+            return if failed_scenarios.empty?
 
-        io.puts format_string "Failing Scenarios:", :failed
-        scenarios.select(&with_status(:failed)).sort_by(&:file_colon_line).each do |scenario|
-          io.puts format_string(scenario.file_colon_line, :failed) + format_string(" # Scenario: " + scenario.name, :comment)
-        end
-        io.puts
-      end
+            io.puts format_string 'Failing Scenarios:', :failed
+            failed_scenarios
+              .sort_by(&:file_colon_line)
+              .map(&method(:to_failed_scenario_line))
+              .each(&io.method(:puts))
+            io.puts
+          end
 
-      def print_failures(collection, label)
-        failures = collection.select(&with_status(:failed))
-        print_elements failures, :failed, pluralize(label, failures.size)
-      end
+          def to_failed_scenario_line(scenario)
+            [
+              [scenario.file_colon_line, :failed],
+              ["# Scenario: #{scenario.name}", :comment]
+            ].map do |string, format|
+              format_string string, format
+            end.join(' ')
+          end
 
-      def print_counts(label, collection)
-        io.puts pluralize(label, collection.size) + count_summary(collection)
-      end
+          def print_failures(collection, label)
+            failures = collection.select(&with_status(:failed))
+            print_elements failures, :failed, pluralize(label, failures.size)
+          end
 
-      def pluralize(word, number)
-        "#{number} #{number == 1 ? word : word + 's'}"
-      end
+          def print_counts(label, collection)
+            io.puts(
+              pluralize(label, collection.size) + count_summary(collection)
+            )
+          end
 
-      def with_status(status)
-        proc {|r| r.status == status}
-      end
+          def pluralize(word, number)
+            "#{number} #{number == 1 ? word : "#{word}s"}"
+          end
+
+          def with_status(status)
+            proc { |r| r.status == status }
+          end
 
-      def count_summary(results)
-        return "" unless results.any?
-        status_counts = STATUSES.map do |status|
-          count = results.select(&with_status(status)).size
-          format_string "#{count} #{status}", status if count > 0
-        end.compact.join ", "
+          def count_summary(results)
+            return '' unless results.any?
 
-        " (#{status_counts})"
+            status_counts = STATUSES.map do |status|
+              count = results.select(&with_status(status)).size
+              format_string "#{count} #{status}", status if count.positive?
+            end.compact.join ', '
+
+            " (#{status_counts})"
+          end
+        end
       end
     end
   end

data/lib/flatware/cucumber/result.rb

@@ -5,12 +5,12 @@ module Flatware
 
       def initialize(progress)
         @progress = progress
-        @worker   = ENV['TEST_ENV_NUMBER'].to_i
+        @worker   = ENV.fetch('TEST_ENV_NUMBER', 0).to_i
       end
 
       class << self
         def step(*args)
-          step = StepResult.new *args
+          step = StepResult.new(*args)
           new step.progress, [step]
         end
 

data/lib/flatware/cucumber/runtime.rb

@@ -3,13 +3,12 @@ require 'cucumber'
 module Flatware
   module Cucumber
     class Runtime < ::Cucumber::Runtime
-
       attr_accessor :configuration, :loader
-      attr_reader :out, :err
-      attr_reader :visitor
+      attr_reader :out, :err, :visitor
 
-      def initialize(out=StringIO.new, err=out)
-        @out, @err = out, err
+      def initialize(out = StringIO.new, err = out)
+        @out = out
+        @err = err
         super(default_configuration)
         load_step_definitions
         @results = Results.new(configuration)
@@ -21,9 +20,13 @@ module Flatware
         config
       end
 
-      def run(feature_files=[], options=[])
+      def run(feature_files = [], options = [])
         @loader = nil
-        options = Array(feature_files) + %w[--format Flatware::Cucumber::Formatter] + options
+        options = [
+          Array(feature_files),
+          %w[--format Flatware::Cucumber::Formatter],
+          options
+        ].reduce(:+)
 
         configure(::Cucumber::Cli::Main.new(options, out, err).configuration)
 

data/lib/flatware/cucumber/step_result.rb

@@ -5,7 +5,8 @@ module Flatware
       attr_reader :status, :exception
 
       def initialize(status, exception)
-        @status, @exception = status, (serialized(exception) if exception)
+        @status = status
+        @exception = (serialized(exception) if exception)
       end
 
       def passed?
@@ -21,9 +22,10 @@ module Flatware
       end
 
       private
-      def serialized(e)
-        e.backtrace and e.backtrace.unshift e.backtrace.shift.sub(Dir.pwd, '.')
-        SerializedException.new(e.class, e.message, e.backtrace)
+
+      def serialized(err)
+        err.backtrace&.unshift(err.backtrace.shift.sub(Dir.pwd, '.'))
+        SerializedException.new(err.class, err.message, err.backtrace)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flatware-cucumber
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Brian Dunn
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-23 00:00:00.000000000 Z
+date: 2021-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 2.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 2.0.0.rc1
 description: A distributed cucumber runner
 email: brian@hashrocket.com
 executables: []
@@ -56,29 +56,31 @@ files:
 - lib/flatware/cucumber/formatters/console/summary.rb
 - lib/flatware/cucumber/result.rb
 - lib/flatware/cucumber/runtime.rb
-- lib/flatware/cucumber/scenario_result.rb
 - lib/flatware/cucumber/step_result.rb
 homepage: http://github.com/briandunn/flatware
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+  - - "<"
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A distributed cucumber runner
 test_files: []

data/lib/flatware/cucumber/scenario_result.rb

@@ -1,38 +0,0 @@
-require 'flatware/serialized_exception'
-module Flatware
-  module Cucumber
-    class ScenarioResult
-      attr_reader :status, :file_colon_line, :name
-      def initialize(status, file_colon_line, name, e)
-        @status = status
-        @file_colon_line = file_colon_line
-        @name = name
-        @exception = SerializedException.new(e.class, e.message, e.backtrace) if e
-        @failed_outside_step = false
-      end
-
-      def passed?
-        status == :passed
-      end
-
-      def failed?
-        status == :failed
-      end
-
-      def failed_outside_step!(file_colon_line)
-        @failed_outside_step = file_colon_line
-      end
-
-      def failed_outside_step?
-        !!@failed_outside_step
-      end
-
-      def exception
-        @exception.tap do |e|
-          e.backtrace = e.backtrace.grep(Regexp.new(Dir.pwd)).map { |line| line[Dir.pwd.size..-1] }
-          e.backtrace = e.backtrace + [@failed_outside_step] if failed_outside_step?
-        end
-      end
-    end
-  end
-end