rspec-abq 1.0.3 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc4f520d1b869e03a972436e4b3eeddb42ce1c3a88db2b944e7ce8d654ac6c25
-  data.tar.gz: 8608c3bc156d2789596d3b8606aa7d5a164ddbefce1d58ca1243dddf9a006bb6
+  metadata.gz: 42664ef402b6b7ca57d62eaf8be91cc58397b11204213c8a41fb5b51e40bf5ff
+  data.tar.gz: 7d4e59e293203b8a061699633518612ab07a46dd1b04e26be85d5362b87705ee
 SHA512:
-  metadata.gz: ac6d181459d36293e661b141f2c0a685ed9a40feb70a877f0fb9b645ba58e4e1d73397c7e1c264545709df3ef610ee42170cf4b1a703d05dc0f50c53f919bb33
-  data.tar.gz: fc5e6cc4d5435fd27552de89b6bfd1cf0a59a077b5f571c20c44788638dbcfb8a9e5cc449338b87a10dc9ccf5b9b8f5b25efb031e16f36d7d8c9de8e887a1203
+  metadata.gz: ecab75285b475df1976cfeb1483475c6dab5cba5bc0dbc6089a4c047f01c3335abb2c4580208e006cbc4df7759a7778c4006d3b5a589f834c58e9b67439f114d
+  data.tar.gz: cf04d645e08f734416c4804d7ccf62fb5337f6ca9cb752226786977a5f6adebe865d78a2f817234bfed34a7bfc80f5fe776102b259b8ff12ddeff2956b12122f

data/README.md

@@ -36,7 +36,40 @@ require 'rspec/abq'
 
 ## Compatibility
 
-This gem is actively tested against rubies 2.6-3.1 and rspecs 3.5-3.12
+This gem is actively tested against
+
+- rubies 2.6-3.1
+- rspecs 3.5-3.12
+
+as well as a handful of rspec plugins:
+
+- rspec-retry 0.6.2
+- capybara 3.36.0
+- selenium-webdriver 4.1.0
+- capybara-inline-screenshot 2.2.1 (see note below)
+
+### Usage with capybara-inline-screenshot (or capybara-screenshot)
+
+#### tldr
+
+1. run rspec with a compatible `--format` option:
+
+    ```sh
+    abq test -- bundle exec rspec --format documentation
+    ```
+
+2. check for screenshots in the worker output
+
+#### What's happening?
+
+By default, rspec-abq only sends rspec-output to the test process. Because of this, custom formatting (e.g. that
+done by capybara-inline-screenshot) is lost.
+
+If you want to enable custom formatting (which will show inline screenshots), enable a
+capybara-inline-screenshot compatible formatter (`progress` or `documentation`). This will output rspec results
+(including screenshots) from the worker processeses.
+
+Note: the test process output will still only have the aggregate results without screenshots.
 
 ## Development
 

data/lib/rspec/abq/extensions.rb

@@ -7,6 +7,7 @@ module RSpec
       def self.setup!
         RSpec::Core::ExampleGroup.extend(ExampleGroup)
         RSpec::Core::Runner.prepend(Runner)
+        RSpec::Core::World.prepend(World)
       end
 
       # ExampleGroups are nodes in a tree with
@@ -27,7 +28,7 @@ module RSpec
         #   - so we continue iterating until we get there
         # - or in another ExampleGroup
         #   - so we bail from this iteration and let the caller (run_with_abq) iterate to the right ExampleGroup
-        def run_examples_with_abq
+        def run_examples_with_abq(reporter)
           all_examples_succeeded = true
           ordering_strategy.order(filtered_examples).each do |considered_example|
             next unless Abq.target_test_case.is_example?(considered_example)
@@ -41,9 +42,10 @@ module RSpec
             # true &&= expression : expression will be run, fine!
             # false &&= expression: expression will NOT be run! bad!
             # we want to always run the test, even if the previous test failed.
-            result = Abq.send_test_result_and_advance { |abq_reporter| considered_example.run(instance, abq_reporter) }
-            all_examples_succeeded &&= result
+            succeeded = considered_example.run(instance, reporter)
+            all_examples_succeeded &&= succeeded
 
+            Abq.fetch_next_example
             break unless Abq.target_test_case.directly_in_group?(self)
           end
           all_examples_succeeded
@@ -68,7 +70,7 @@ module RSpec
             # the examples; otherwise, we just need to check the children groups.
             result_for_this_group =
               if Abq.target_test_case.directly_in_group?(self)
-                run_examples_with_abq
+                run_examples_with_abq(reporter)
               else
                 true
               end
@@ -87,10 +89,9 @@ module RSpec
             for_filtered_examples(reporter) do |example|
               next unless Abq.target_test_case.is_example?(example)
 
-              Abq.send_test_result_and_advance { |abq_reporter| example.fail_with_exception(abq_reporter, ex) }
+              example.fail_with_exception(abq_reporter, ex)
             end
 
-            RSpec.world.wants_to_quit = true if reporter.fail_fast_limit_met?
             false
           ensure
             if Gem::Version.new(RSpec::Core::Version::STRING) >= Gem::Version.new("3.11.0")
@@ -106,14 +107,26 @@ module RSpec
       module Runner
         # Runs the provided example groups.
         #
-        # @param example_groups [Array<RSpec::Core::ExampleGroup>] groups to run
-        # @return [Fixnum] exit status code. 0 if all specs passed,
-        #   or the configured failure exit code (1 by default) if specs
+        # @param example_groups [Array<RSpec::Core::ExampleGroup>] groups to run.
+        #   Ignored in favor of @world.ordered_example_groups
+        # @return [Fixnum] exit status code. 0 if all specs passed or if rspec-abq wants to quit early,
+        #   or the configured failure exit status (1 by default) if specs
         #   failed.
         def run_specs(example_groups)
-          should_quit = RSpec::Abq.setup_after_specs_loaded!
-          return 0 if should_quit
+          if !!ENV[ABQ_GENERATE_MANIFEST]
+            # before abq can start workers, it asks for a manifest
+            RSpec::Abq::Manifest.write_manifest(example_groups, RSpec.configuration.seed, RSpec.configuration.ordering_registry)
+            # gracefully quit after manifest generation. The worker will launch another instance of rspec with an init_message
+            return 0
+          end
+
+          return 0 if Abq.fast_exit?
+
+          # if not quitting early, ensure we have an initial test
+          Abq.fetch_next_example
 
+          # Note: this is all examples, not the examples run by ABQ. Because of that, the numbers in the worker
+          # summary will likely be wrong.
           examples_count = @world.example_count(example_groups)
           examples_passed = @configuration.reporter.report(examples_count) do |reporter|
             @configuration.with_suite_hooks do
@@ -127,13 +140,13 @@ module RSpec
 
           if Abq.target_test_case != Abq::TestCase.end_marker
             warn "Hit end of test run without being on end marker. Target test case is #{Abq.target_test_case.inspect}"
-            example_passed = false
+            examples_passed = false
           end
 
           if Gem::Version.new(RSpec::Core::Version::STRING) >= Gem::Version.new("3.10.0")
             exit_code(examples_passed)
           else
-            example_passed ? 0 : @configuration.failure_exit_code
+            examples_passed ? 0 : @configuration.failure_exit_code
           end
         end
 
@@ -145,6 +158,19 @@ module RSpec
           end
         end
       end
+
+      # RSpec uses this for global data that's not configuration
+      module World
+        # we call configure_rspec in #ordered_example_groups because it is called
+        # 1. AFTER all specs are loaded.
+        #     We need to call it after all specs are loaded because we want to potentially overwrite config set in the specs
+        # 2. BEFORE any specs are run.
+        #     We want to call it before any specs are run because the config we set may affect spec ordering.
+        def ordered_example_groups
+          RSpec::Abq.configure_rspec!
+          super
+        end
+      end
     end
   end
 end

data/lib/rspec/abq/formatter.rb

@@ -0,0 +1,87 @@
+require "time"
+
+if Gem::Version.new(RSpec::Core::Version::STRING) < Gem::Version.new("3.6.0")
+  # addresses this issue https://github.com/rspec/rspec-core/issues/2471
+  require "rspec/core/formatters/console_codes"
+end
+
+module RSpec
+  module Abq
+    # Formatters are used to format RSpec test results. In our case, we're using it to
+    # report test results to the abq socket.
+    class Formatter
+      RSpec::Core::Formatters.register self, :example_passed, :example_pending, :example_failed
+
+      # we don't use the output IO for this formatter (we report everything via the socket)
+      def initialize(_output) # rubocop:disable Lint/RedundantInitialize
+      end
+
+      # called when an example is completed (this method is aliased to example_pending and example_failed)
+      def example_passed(notification)
+        Abq.protocol_write(Formatter.abq_result(notification.example))
+      end
+
+      alias_method :example_pending, :example_passed
+      alias_method :example_failed, :example_passed
+
+      # takes a completed example and creates a abq-compatible test result
+      def self.abq_result(example)
+        execution_result = example.execution_result
+        tags, meta = Manifest.extract_metadata_and_tags(example.metadata)
+        {
+          test_result: {
+            status: status(example),
+            id: example.id,
+            display_name: example.metadata[:full_description],
+            output: if execution_result.exception
+                      RSpec::Core::Formatters::ExceptionPresenter
+                        .new(execution_result.exception, example)
+                        .fully_formatted(1)
+                    end,
+            runtime: (execution_result.run_time * 1_000_000_000).round,
+            tags: tags,
+            meta: meta,
+            location: {
+              file: example.metadata[:file_path],
+              line: example.metadata[:line_number]
+            },
+            started_at: execution_result.started_at.utc.iso8601,
+            finished_at: execution_result.finished_at.utc.iso8601,
+            lineage: RSpec::Core::Metadata.ascend(example.metadata).map { |meta| meta[:description] }.reverse
+          }
+        }
+      end
+
+      private_class_method def self.status(example)
+        execution_result = example.execution_result
+        exception = execution_result.exception
+        case execution_result.status
+        when :passed
+          {type: :success}
+        when :failed
+          {
+            type:
+              if exception.is_a?(RSpec::Expectations::ExpectationNotMetError)
+                :failure
+              else
+                :error
+              end,
+            exception:
+             if exception.class.name.to_s == ""
+               "(anonymous error class)"
+             else
+               exception.class.name.to_s
+             end,
+            backtrace: RSpec::Core::Formatters::ExceptionPresenter.new(exception, example).formatted_backtrace
+          }
+        when :pending
+          if execution_result.example_skipped?
+            {type: :skipped}
+          else
+            {type: :pending}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/abq/manifest.rb

@@ -12,13 +12,26 @@ module RSpec
       # @param ordered_groups [Array<RSpec::Core::ExampleGroup>] ordered groups to assemble into a manifest
       def self.generate(ordered_groups, random_seed, registry)
         {
+          type: "manifest_success",
           manifest: {
             init_meta: RSpec::Abq::Ordering.to_meta(random_seed, registry),
             members: ordered_groups.map { |group| to_manifest_group(group) }.compact
-          }
+          },
+          other_errors: nil
         }
       end
 
+      # Takes group or example metadata and returns a two-element array:
+      # a tag is any piece of metadata that has a value of true
+      # @return [Array<Array<Symbol>, Hash<Symbol, Object>>] tags and metadata
+      # @!visibility private
+      def self.extract_metadata_and_tags(metadata)
+        # we use `.dup.reject! because `.reject` raises a warning (because it doesn't dup procs)`
+        user_metadata = metadata.dup.reject! { |k, _v| RESERVED_METADATA_KEYS.include?(k) }
+        tags_array, metadata_array = user_metadata.partition { |_k, v| v == true }
+        [tags_array.map(&:first), metadata_array.to_h]
+      end
+
       # @!visibility private
       # @param group [RSpec::Core::ExampleGroup]
       private_class_method def self.to_manifest_group(group)
@@ -26,7 +39,7 @@ module RSpec
         # because that's how the runner will execute them.
         members =
           group.ordering_strategy.order(group.filtered_examples).map { |example|
-            tags, metadata = Abq.extract_metadata_and_tags(example.metadata)
+            tags, metadata = extract_metadata_and_tags(example.metadata)
             {
               type: "test",
               id: example.id,
@@ -38,7 +51,7 @@ module RSpec
               group.ordering_strategy.order(group.children).map { |child_group| to_manifest_group(child_group) }.compact
             )
         return nil if members.empty?
-        tags, metadata = Abq.extract_metadata_and_tags(group.metadata)
+        tags, metadata = extract_metadata_and_tags(group.metadata)
         {
           type: "group",
           name: group.id,

data/lib/rspec/abq/ordering.rb

@@ -26,13 +26,25 @@ module RSpec
       end
 
       # takes the meta (prodced in .to_meta) and applies the settings to the current process
+      # @!visibility private
+      # @return [Boolean] returns true if setup! changed anything
       def self.setup!(init_meta, configuration)
-        configuration.seed = init_meta["seed"]
+        changed = false
+        if configuration.seed != init_meta["seed"]
+          configuration.seed = init_meta["seed"]
+          changed = true
+        end
+
         registry = configuration.ordering_registry
         ordering_from_manifest = registry.fetch(init_meta["ordering"].to_sym) do
           fail(UnsupportedOrderingError, "can't order based on unknown ordering: `#{init_meta["ordering"]}`")
         end
-        registry.register(:global, ordering_from_manifest)
+
+        if registry.fetch(:global) != ordering_from_manifest
+          registry.register(:global, ordering_from_manifest)
+          changed = true
+        end
+        changed
       end
     end
   end

data/lib/rspec/abq/version.rb

@@ -1,6 +1,6 @@
 module RSpec
   module Abq
     # current version!
-    VERSION = "1.0.3"
+    VERSION = "1.0.5"
   end
 end

data/lib/rspec/abq.rb

@@ -2,14 +2,70 @@ require "set"
 require "rspec/core"
 require "socket"
 require "json"
-require_relative "abq/extensions"
-require_relative "abq/manifest"
-require_relative "abq/ordering"
-require_relative "abq/reporter"
-require_relative "abq/test_case"
-require_relative "abq/version"
-
-# We nest our patch into RSpec's module -- why not?
+require "rspec/abq/extensions"
+require "rspec/abq/manifest"
+require "rspec/abq/ordering"
+require "rspec/abq/formatter"
+require "rspec/abq/test_case"
+require "rspec/abq/version"
+
+# How does ABQ & its protocol work?
+# ======================================
+# This is a reframing of some of https://www.notion.so/rwx/Native-Runner-Protocol-0-2-d992ef3b4fde4289b02244c1b89a8cc7
+# With pointers to where it is implemented in this codebase.
+#
+# One or more abq workers each launch a "native runner" (in this case, rspec).
+# one of the native runners is designated the one to produce a manifest (via an environmental variable).
+#
+# Each native runner is passed a socket address as an environmental variable to communicate with its worker.
+# The first message sent over the socket is the NATIVE_RUNNER_SPAWNED_MESSAGE, sent from the native runner to the worker.
+# (see: `Abq.socket`)
+#
+# The Manifest
+# ------------
+# The manifest is used by the abq supervisor to coordinate workers.
+# The manifest contains
+# - a list of all the tests to run. Each worker will receive a slice of these tests.
+# - native-runner specific information for configuring workers. In RSPec's case -- we send ordering information to ensure
+#   each instance of rspec orders its specs consistently
+#
+# The manifest is written in the monkey-patched RSpec::Core::Runner#run_specs method (see `RSpec::Abq::Extensions::Runner`)
+#
+# After the manifest has been generated and sent to the worker, that native runner quits and is relaunched fresh as as a
+# non-manifest-generating worker.
+#
+# "Normal" Native Runners
+# -----------------------
+# Non-manifest-generating native runners first perform an initialization handshake, fetching init message from the worker,
+# which either has config information or instructions for abq to quit early.
+# (see: `Abq.configure_rspec`)
+#
+# After that, native runners fetch test cases from the worker, and send back test results.
+# RSpec will iterate over all tests, but running only those that the worker tells it to run and skipping the rest.
+# It will quit when all tests have been iterated over.
+#
+# Loading rspec-abq
+# ========================
+# The gem itself is usually loaded when `require spec_helper.rb` is called (either explicitly via `require rspec/abq` or
+# implicitly via the Gemfile).
+# The spec_helper is usually loaded in one of two ways:
+# - via a `--require spec_helper` in the .rspec file, which means the gem is loaded BEFORE specs are loaded
+# - or via a `require spec_helper.rb` in the spec itself, which means the gem is loaded WHILE specs are actively being loaded.
+#
+# In either case: the manifest cannot be written until AFTER specs are loaded, so all that loading the gem does is
+# - check if rspec is being run via an abq worker
+# - and if so, monkey patch rspec to hook in rspec-abq functionality
+#
+# Once rspec is patched ...
+#
+# First run manifest generation against the native runner on a single worker:
+# - configure hard-coded rspec settings (Abq.configure_rspec) called from RSpec::Abq::Extensions::World#ordered_example_groups
+# - generate the manifest via RSpec::Abq::Extensions::Runner#run_specs
+# (the native runner quits)
+#
+# Then run the native runner again on one or more workers:
+# - configure static rspec settings, plus settings fetched from the init_message in the manifest.
+# - then fetch and test cases from the worker and send back test results until there are no tests left
 module RSpec
   # An abq adapter for RSpec!
   module Abq
@@ -33,7 +89,7 @@ module RSpec
     PROTOCOL_VERSION = {
       type: "abq_protocol_version",
       major: 0,
-      minor: 1
+      minor: 2
     }
 
     # The [rspec-abq specification](https://www.notion.so/rwx/ABQ-Worker-Native-Test-Runner-IPC-Interface-0959f5a9144741d798ac122566a3d887#8587ee4fd01e41ec880dcbe212562172).
@@ -67,8 +123,13 @@ module RSpec
     # Whether this rspec process is running in ABQ mode.
     # @return [Boolean]
     def self.enabled?(env = ENV)
-      env.key?(ABQ_SOCKET) && # this is the basic check for rspec being called from an abq worker
-        (!env.key?(ABQ_RSPEC_PID) || env[ABQ_RSPEC_PID] == Process.pid.to_s) # and this check ensures that any _nested_ processes do not communicate with the worker.
+      if env.key?(ABQ_SOCKET) # is rspec being called from abq?
+        env[ABQ_RSPEC_PID] ||= Process.pid.to_s # set the pid of the native runner
+        env[ABQ_RSPEC_PID] == Process.pid.to_s # and ensure the pid is this process
+        # we check the pid to guard against nested rspec calls thinking they're being called from abq
+      else
+        false
+      end
     end
 
     # Disables tests so we can compare runtime of rspec core vs parallelized version. Additionally, disables tests
@@ -79,60 +140,78 @@ module RSpec
         ENV.key?("ABQ_DISABLE_TESTS")
     end
 
-    # This is the main entry point for abq-rspec, and it's called when the gem is loaded
+    # This is the main entry point for abq-rspec, and it's called when the gem is loaded.
     # @!visibility private
     # @return [void]
-    def self.setup!
+    def self.setup_extensions_if_enabled!
       return unless enabled?
       Extensions.setup!
     end
 
-    # raised if we try to load rspec-abq twice
-    # perhaps RSpec or a plugin has changed behavior to break assumptions we've made with rspec-abq
-    AbqLoadedTwiceError = Class.new(StandardError)
+    # raised when check_configuration fails
+    UnsupportedConfigurationError = Class.new(StandardError)
 
-    # @!visibility private
-    # @return [Boolean]
-    def self.setup_after_specs_loaded!
-      fail AbqLoadedTwiceError, "tried to setup abq-rspec twice" if ENV[ABQ_RSPEC_PID]
-      ENV[ABQ_RSPEC_PID] ||= Process.pid.to_s
+    # raises if RSpec is configured in a way that's incompatible with rspec-abq
+    def self.check_configuration!(config)
+      if config.fail_fast
+        warn("ERROR:\trspec-abq doesn't presently support running with fail-fast enabled.\n" \
+                   "\tplease disable fail-fast and try again.")
+        fail UnsupportedConfigurationError, "unsupported fail-fast detected."
+      end
+    end
+
+    # This is called from World#ordered_example_group
+    # and is used to configure rspec based on
+    # 1. rspec-abq expected defaults
+    # 2. ordering information sent from the worker (e.g. if the test supervisor has random seed 3, we want this runner to also have the same random seed)
+    def self.configure_rspec!
+      return if @rspec_configured
+      @rspec_configured = true
 
+      check_configuration!(RSpec.configuration)
       # ABQ doesn't support writing example status to disk yet.
-      # in its simple implementation, status persistance write the status of all tests which ends up hanging with under
-      # abq because we haven't run most of the tests in this worker. (maybe it's running the tests?). In any case:
-      # it's disabled.
+      # in its simple implementation, status persistance write the status of all tests which ends up hanging under
+      # abq because we haven't run most of the tests in @example_group. (maybe the hanging is rspec trying to execute the tests?).
+      # In any case: it's disabled.
+      # we set this even if the manifest is being generated
       RSpec.configuration.example_status_persistence_file_path = nil
 
-      # before abq can start workers, it asks for a manifest
-      if !!ENV[ABQ_GENERATE_MANIFEST] # the abq worker will set this env var if it needs a manifest
-        RSpec::Abq::Manifest.write_manifest(RSpec.world.ordered_example_groups, RSpec.configuration.seed, RSpec.configuration.ordering_registry)
-        return true
-      end
+      # if we're generating a manifest, we don't want to do any other setup
+      return if !!ENV[ABQ_GENERATE_MANIFEST]
 
       # after the manfiest has been sent to the worker, the rspec process will quit and the workers will each start a
       # new rspec process
 
       # enabling colors allows us to pass through nicer error messages
-
       if Gem::Version.new(RSpec::Core::Version::STRING) >= Gem::Version.new("3.6.0")
         RSpec.configuration.color_mode = :on
       else
         RSpec.configuration.color = true
       end
 
+      RSpec.configuration.add_formatter(RSpec::Abq::Formatter)
+
       # the first message is the init_meta block of the manifest. This is used to share runtime configuration
       # information amongst worker processes. In RSpec, it is used to ensure that random ordering between workers
-      # shares the same seed, so can be deterministic.
+      # shares the same seed.
       init_message = protocol_read
       protocol_write(INIT_SUCCESS_MESSAGE)
-      # TODO: delete the check for empty init_meta when https://github.com/rwx-research/abq/pull/216 is merged
-      return true if init_message["fast_exit"]
+
+      if init_message["fast_exit"]
+        @fast_exit = true
+        return
+      end
 
       Ordering.setup!(init_message["init_meta"], RSpec.configuration)
-      fetch_next_example
       nil
     end
 
+    # @!visibility private
+    # @return [Boolean]
+    def self.fast_exit?
+      @fast_exit ||= false
+    end
+
     # Creates the socket to communicate with the worker and sends the worker the protocol
     # @!visibility private
     def self.socket
@@ -149,17 +228,6 @@ module RSpec
     # @!visibility private
     RESERVED_METADATA_KEYS = Set.new(RSpec::Core::Metadata::RESERVED_KEYS + [:if, :unless])
 
-    # Takes group or example metadata and returns a two-element array:
-    # a tag is any piece of metadata that has a value of true
-    # @return [Array<Array<Symbol>, Hash<Symbol, Object>>] tags and metadata
-    # @!visibility private
-    def self.extract_metadata_and_tags(metadata)
-      # we use `.dup.reject! because `.reject` raises a warning (because it doesn't dup procs)`
-      user_metadata = metadata.dup.reject! { |k, _v| RESERVED_METADATA_KEYS.include?(k) }
-      tags_array, metadata_array = user_metadata.partition { |_k, v| v == true }
-      [tags_array.map(&:first), metadata_array.to_h]
-    end
-
     class << self
       # the target_test_case is the test case the abq worker wants results for
       # @!visibility private
@@ -210,18 +278,7 @@ module RSpec
       return :abq_done if json_msg.nil?
       JSON.parse json_msg
     end
-
-    # sends test results to ABQ and advances by one
-    # @!visibility private
-    def self.send_test_result_and_advance(&block)
-      reporter = Reporter.new
-      test_succeeded = block.call(reporter)
-      protocol_write(reporter.abq_result)
-      fetch_next_example
-      # return whether the test succeeded or not
-      test_succeeded
-    end
   end
 end
 
-RSpec::Abq.setup!
+RSpec::Abq.setup_extensions_if_enabled!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-abq
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.5
 platform: ruby
 authors:
 - Ayaz Hafiz
@@ -45,6 +45,104 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.14.1
+- !ruby/object:Gem::Dependency
+  name: rspec-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.36.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.36.0
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: webdrivers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.5
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.6.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.6.5
+- !ruby/object:Gem::Dependency
+  name: capybara-inline-screenshot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
 description: RSpec::Abq is an rspec plugin that replaces its ordering with one that
   is controlled by abq. It allows for parallelization of rspec on a single machine
   or across multiple workers.
@@ -59,9 +157,9 @@ files:
 - README.md
 - lib/rspec/abq.rb
 - lib/rspec/abq/extensions.rb
+- lib/rspec/abq/formatter.rb
 - lib/rspec/abq/manifest.rb
 - lib/rspec/abq/ordering.rb
-- lib/rspec/abq/reporter.rb
 - lib/rspec/abq/test_case.rb
 - lib/rspec/abq/version.rb
 homepage: https://github.com/rwx-research/rspec-abq

data/lib/rspec/abq/reporter.rb

@@ -1,85 +0,0 @@
-module RSpec
-  module Abq
-    # Realistically we should instead extend [RSpec::Core::Reporter], but
-    # there's some indirection there I don't yet understand, so instead just
-    # build it up from scratch for now.
-    class Reporter
-      attr_reader :status
-      attr_reader :id
-      attr_reader :display_name
-      attr_reader :tags
-      attr_reader :meta
-
-      # @param example [RSpec::Core::Example]
-      def example_started(example)
-        @id = example.id
-        @example = example
-        @display_name = example.metadata[:full_description]
-        @tags, @meta = Abq.extract_metadata_and_tags(example.metadata)
-      end
-
-      # @param example [RSpec::Core::Example]
-      def example_finished(example)
-        @execution_result = example.metadata[:execution_result]
-      end
-
-      # @param example [RSpec::Core::Example]
-      def example_failed(example)
-        @status =
-          if example.execution_result.exception.is_a? RSpec::Expectations::ExpectationNotMetError
-            :failure
-          else
-            :error
-          end
-      end
-
-      # @param _example [RSpec::Core::Example]
-      def example_passed(_example)
-        @status = :success
-      end
-
-      # @param example [RSpec::Core::Example]
-      def example_pending(example)
-        @status =
-          if example.execution_result.example_skipped?
-            :skipped
-          else
-            :pending
-          end
-      end
-
-      # @return [String, nil]
-      def output
-        if @execution_result.exception
-          presenter = RSpec::Core::Formatters::ExceptionPresenter.new @execution_result.exception, @example
-          return presenter.fully_formatted 1
-        end
-        nil
-      end
-
-      # @return Int
-      def runtime_ms
-        @execution_result.run_time * 1000
-      end
-
-      # does nothing, just here to fulfill reporter api
-      def example_group_finished(_)
-      end
-
-      # creates a hash that fits the abq worker result protocol
-      def abq_result
-        {
-          test_result: {
-            status: status,
-            id: id,
-            display_name: display_name,
-            output: output,
-            runtime: runtime_ms,
-            tags: tags,
-            meta: meta
-          }
-        }
-      end
-    end
-  end
-end