rspec-abq 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f99eb724ca058a63aa026b82c6d9bfda4a5aaf98df3d7fc0485025db98e46b43
+  data.tar.gz: bcfa57ca1f21298e63f4feed8e3d845a1304c9db9915360146931eb0c521105f
+SHA512:
+  metadata.gz: a95ccc0549bc1d46f79c25fbe7de2f7b3f88cd74474039333d8b72b31858bf4c903169e4b7bbb55cfb277b4844bcc7073a56eb87bc332bac82d41261de31ef6a
+  data.tar.gz: 9b497c0bd97ee1760a18077d88bfa3da9c0340393648d01a1a53d8ec4f91a95303303b5a329b933bd0212a246a83477f7912e1359aca9b5f5aac365ec9dc1cf3

data/README.md

@@ -0,0 +1,45 @@
+# Rspec::Abq
+
+This gem helps you use rspec with abq.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+group :test do
+    gem 'rspec-core'
+    ...
+    gem 'rspec-abq'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Use the included binary with abq:
+
+```
+abq test -- bundle exec rspec
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Releasing the gem
+
+use the release script, `./release_gem.rb`
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rwx-research/rspec-abq. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Code of Conduct
+
+Everyone interacting in the Rspec::Abq project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/rwx-research/rspec-abq/blob/master/CODE_OF_CONDUCT.md).

data/lib/rspec/abq/extensions.rb

@@ -0,0 +1,131 @@
+module RSpec
+  module Abq
+    # A few extensions to RSpec::Core classes to hook in abq
+    module Extensions
+      # adds our functionality to RSpec::Core::Configuration
+      # @!visibility private
+      def self.setup!
+        RSpec::Core::ExampleGroup.extend(ExampleGroup)
+        RSpec::Core::Runner.prepend(Runner)
+      end
+
+      # ExampleGroups are nodes in a tree with
+      # - a (potentially empty) list of Examples (the value of the node)
+      # - AND a (potentialy empty) list of children ExampleGroups (... the ... children ... are the children of the
+      #   node 😅)
+      # ExampleGroups are defined by `context` and `describe` in the RSpec DSL
+      # Examples are defined dby `it` RSpec DSL
+      module ExampleGroup
+        # This method
+        # - iterates over the current ExampleGroup's Examples to find the Example that is the same as
+        #   Abq.target_test_case
+        # - runs the example
+        # - and fetches example that is now the `Abq.target_test_case`a
+        #
+        # the next target_test_case is either
+        # - later in this ExampleGroup's examples
+        #   - 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
+          all_examples_succeeded = true
+          ordering_strategy.order(filtered_examples).each do |considered_example|
+            next unless Abq.target_test_case.is_example?(considered_example)
+            next if RSpec.world.wants_to_quit
+
+            instance = new(considered_example.inspect_output)
+            set_ivars(instance, before_context_ivars)
+
+            all_examples_succeeded &&= Abq.send_test_result_and_advance { |abq_reporter| considered_example.run(instance, abq_reporter) }
+
+            break unless Abq.target_test_case.directly_in_group?(self)
+          end
+          all_examples_succeeded
+        end
+
+        # same as .run but using abq
+        def run_with_abq(reporter)
+          # The next test isn't in this group or any child; we can skip
+          # over this group entirely.
+          return true unless Abq.target_test_case.in_group?(self)
+
+          reporter.example_group_started(self)
+
+          should_run_context_hooks = descendant_filtered_examples.any?
+          begin
+            RSpec.current_scope = :before_context_hook
+            run_before_context_hooks(new("before(:context) hook")) if should_run_context_hooks
+
+            # If the next example to run is on the surface of this group, scan all
+            # 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
+              else
+                true
+              end
+
+            results_for_descendants = ordering_strategy.order(children).map { |child| child.run_with_abq(reporter) }.all?
+            result_for_this_group && results_for_descendants
+          rescue RSpec::Core::Pending::SkipDeclaredInExample => ex
+            for_filtered_examples(reporter) { |example| example.skip_with_exception(reporter, ex) }
+            true
+          rescue RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue => ex
+            # If an exception reaches here, that means we must fail the entire
+            # group (otherwise we would have handled the exception locally at an
+            # example). Since we know of the examples in the same order as they'll
+            # be sent to us from ABQ, we now loop over all the examples, and mark
+            # every one that we must run in this group as a failure.
+            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) }
+            end
+
+            RSpec.world.wants_to_quit = true if reporter.fail_fast_limit_met?
+            false
+          ensure
+            RSpec.current_scope = :after_context_hook
+            run_after_context_hooks(new("after(:context) hook")) if should_run_context_hooks
+            reporter.example_group_finished(self)
+          end
+        end
+      end
+
+      # Runner is class responsbile for execution in 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
+        #   failed.
+        def run_specs(example_groups)
+          should_quit = RSpec::Abq.setup_after_specs_loaded!
+          return 0 if should_quit
+
+          examples_count = @world.example_count(example_groups)
+          examples_passed = @configuration.reporter.report(examples_count) do |reporter|
+            @configuration.with_suite_hooks do
+              if examples_count == 0 && @configuration.fail_if_no_examples
+                return @configuration.failure_exit_code
+              end
+
+              example_groups.map { |g| g.run_with_abq(reporter) }.all?
+            end
+          end
+
+          exit_code(examples_passed)
+        end
+
+        private
+
+        def persist_example_statuses
+          if RSpec.configuration.example_status_persistence_file_path
+            warn "persisting example status disabled by abq"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/abq/manifest.rb

@@ -0,0 +1,52 @@
+require "set"
+module RSpec
+  module Abq
+    # A module for abstracting ABQ Manifest
+    module Manifest
+      # writes manifest to abq socket
+      def self.write_manifest(ordered_groups, random_seed, registry)
+        Abq.protocol_write(generate(ordered_groups, random_seed, registry))
+      end
+
+      # Generates an ABQ Manifest
+      # @param ordered_groups [Array<RSpec::Core::ExampleGroup>] ordered groups to assemble into a manifest
+      def self.generate(ordered_groups, random_seed, registry)
+        {
+          manifest: {
+            init_meta: RSpec::Abq::Ordering.to_meta(random_seed, registry),
+            members: ordered_groups.map { |group| to_manifest_group(group) }.compact
+          }
+        }
+      end
+
+      # @!visibility private
+      # @param group [RSpec::Core::ExampleGroup]
+      private_class_method def self.to_manifest_group(group)
+        # NB: It's important to write examples first and then children groups,
+        # 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)
+            {
+              type: "test",
+              id: example.id,
+              tags: tags,
+              meta: metadata
+            }
+          }
+            .concat(
+              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)
+        {
+          type: "group",
+          name: group.id,
+          tags: tags,
+          meta: metadata,
+          members: members
+        }
+      end
+    end
+  end
+end

data/lib/rspec/abq/ordering.rb

@@ -0,0 +1,34 @@
+module RSpec
+  module Abq
+    # This module is responsible for recording ordering for the manifest
+    # and reading the ordering from `init_meta` to set up the current processes settings
+    module Ordering
+      # notably: we don't support custom orderings
+      SUPPORTED_ORDERINGS = [:defined, :recently_modified, :random]
+
+      # Raised when we experience an ordering that doesn't exist in SUPPORTED_ORDERINGS
+      UnsupportedOrderingError = Class.new(StandardError)
+
+      # takes a seed and a registry and produces a hash for the manifest
+      def self.to_meta(seed, registry)
+        global_ordering = registry.fetch(:global)
+        ordering_name = SUPPORTED_ORDERINGS.find { |name| registry.fetch(name) == global_ordering }
+        fail(UnsupportedOrderingError, "can't order based on unknown ordering: `#{global_ordering.class}`") unless ordering_name
+        {
+          ordering: ordering_name,
+          seed: seed
+        }
+      end
+
+      # takes the meta (prodced in .to_meta) and applies the settings to the current process
+      def self.setup!(init_meta, configuration)
+        configuration.seed = init_meta["seed"]
+        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)
+      end
+    end
+  end
+end

data/lib/rspec/abq/reporter.rb

@@ -0,0 +1,85 @@
+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

data/lib/rspec/abq/test_case.rb

@@ -0,0 +1,73 @@
+module RSpec
+  module Abq
+    # ABQ's representation of a test case
+    class TestCase
+      def initialize(id, tags, meta)
+        @id = id
+        @tags = tags
+        @meta = meta
+        @rerun_file_path, scoped_id = RSpec::Core::Example.parse_id @id
+        @scope = self.class.parse_scope(scoped_id || "")
+      end
+
+      attr_reader :id
+      attr_reader :tags
+      attr_reader :meta
+      attr_reader :rerun_file_path
+      attr_reader :scoped_id
+
+      # Parses a scope n:m:q:r into [n, m, q, r]
+      # Invariant of RSpec is that a scope n:m:q:r is contained in a scope n:m:q
+      def self.parse_scope(scope)
+        scope.split(":")
+      end
+
+      # `scope_contains outer inner` is true iff the inner scope is deeper
+      # than the outer scope.
+      #
+      # @param outer [Array<String>] parsed scope
+      # @param inner [Array<String>] parsed scope
+      def self.scope_contains(outer, inner)
+        inner.take(outer.length) == outer
+      end
+
+      # `scope_leftover outer inner` returns the partial scopes of `inner`
+      # that are deeper than `outer`.
+      #
+      # @param outer [Array<String>] parsed scope
+      # @param inner [Array<String>] parsed scope
+      def self.scope_leftover(outer, inner)
+        inner[outer.length..-1] || []
+      end
+
+      # @param group [RSpec::Core::ExampleGroup]
+      def in_group?(group)
+        return false if group.metadata[:rerun_file_path] != @rerun_file_path
+
+        group_scope = self.class.parse_scope(group.metadata[:scoped_id])
+        self.class.scope_contains(group_scope, @scope)
+      end
+
+      # @param group [RSpec::Core::ExampleGroup]
+      def directly_in_group?(group)
+        return false unless in_group?(group)
+
+        group_scope = self.class.parse_scope(group.metadata[:scoped_id])
+        additional_scoping = self.class.scope_leftover(group_scope, @scope)
+        raise "#{@id} not inside #{group_scope}, but we thought it was" if additional_scoping.empty?
+        additional_scoping.length == 1
+      end
+
+      # @param example [RSpec::Core::Example]
+      def is_example?(example)
+        example.metadata[:rerun_file_path] == @rerun_file_path && self.class.parse_scope(example.metadata[:scoped_id]) == @scope
+      end
+
+      # Faux test case to mark end of all tests. Will never match any group or
+      # test ID, since the scoped_id is empty.
+      def self.end_marker
+        @end_marker ||= TestCase.new("[]", [], {})
+      end
+    end
+  end
+end

data/lib/rspec/abq/version.rb

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

data/lib/rspec/abq.rb

@@ -0,0 +1,202 @@
+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?
+module RSpec
+  # An abq adapter for RSpec!
+  module Abq
+    # the socket used to communicate to the abq worker
+    # looks like "ip.address.3.4:port" e.g. "0.0.0.0:1234"
+    # @!visibility private
+    ABQ_SOCKET = "ABQ_SOCKET"
+
+    # the abq worker will set this environmental variable if it needs this process to generate a manifest
+    # @!visibility private
+    ABQ_GENERATE_MANIFEST = "ABQ_GENERATE_MANIFEST"
+
+    # this is set by the outer-most rspec runner to ensure nested rspecs aren't ABQ aware.
+    # if we ever want nested ABQ rspec, we'll need to change this.
+    # this env var is unrelated to the abq worker!
+    # @!visibility private
+    ABQ_RSPEC_PID = "ABQ_RSPEC_PID"
+
+    # The [ABQ protocol version message](https://www.notion.so/rwx/ABQ-Worker-Native-Test-Runner-IPC-Interface-0959f5a9144741d798ac122566a3d887#8587ee4fd01e41ec880dcbe212562172).
+    # Must be sent to ABQ_SOCKET on startup.
+    # @!visibility private
+    PROTOCOL_VERSION_MESSAGE = {
+      type: "abq_protocol_version",
+      major: 0,
+      minor: 1
+    }
+
+    # The [ABQ initialization success
+    # message](https://www.notion.so/rwx/ABQ-Worker-Native-Test-Runner-IPC-Interface-0959f5a9144741d798ac122566a3d887#538582a3049f4934a5cb563d815c1247)
+    # Must be sent after receiving the ABQ initialization message.
+    # @!visibility private
+    INIT_SUCCESS_MESSAGE = {}
+
+    # 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.
+    end
+
+    # Disables tests so we can compare runtime of rspec core vs parallelized version. Additionally, disables tests
+    # if forced via ABQ_DISABLE_TESTS env var.
+    # @return [Boolean]
+    def self.disable_tests_when_run_by_abq?
+      enabled? ||
+        ENV.key?("ABQ_DISABLE_TESTS")
+    end
+
+    # 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!
+      return unless enabled?
+      Extensions.setup!
+    end
+
+    # @!visibility private
+    # @return [Boolean]
+    def self.setup_after_specs_loaded!
+      ENV[ABQ_RSPEC_PID] = Process.pid.to_s
+      # 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.
+      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)
+        # ... Maybe it's fine to just exit(0)
+        RSpec.world.wants_to_quit = true # ask rspec to exit
+        RSpec.configuration.error_exit_code = 0 # exit without error
+        RSpec.world.non_example_failure = true # exit has nothing to do with tests
+        return true
+      end
+
+      # 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
+      RSpec.configuration.color_mode = :on
+
+      # 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.
+      message = protocol_read
+      init_message = message["init_meta"]
+      if init_message
+        protocol_write(INIT_SUCCESS_MESSAGE)
+        # todo: get rid of this unless init_message.empty? as soon as the bug is fixed in abq
+        Ordering.setup!(init_message, RSpec.configuration) unless init_message.empty?
+        fetch_next_example
+      else
+        # to support the old protocol, we don't depend on the initialization method, however we don't support random
+        # ordering via config, only via a shared command line seed. `abq test -- rspec --seed 4` will pass the
+        # deterministic seed to all workers.
+        fetch_next_example(message)
+      end
+      nil
+    end
+
+    # Creates the socket to communicate with the worker and sends the worker the protocol
+    # @!visibility private
+    def self.socket
+      @socket ||= TCPSocket.new(*ENV[ABQ_SOCKET].split(":")).tap do |socket|
+        protocol_write(PROTOCOL_VERSION_MESSAGE, socket)
+      end
+    end
+
+    # These are the metadata keys that rspec uses internally on examples and groups
+    # When we want to report custom tags that rspec-users write, we need to remove these from the example metadata
+    # @!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
+      attr_reader :target_test_case
+    end
+
+    # pulls next example from the abq worker and sets it to #target_test_case
+    # @!visibility private
+    def self.fetch_next_example(message = protocol_read)
+      @target_test_case =
+        if message == :abq_done
+          TestCase.end_marker
+        else
+          TestCase.new(*message["test_case"].values_at("id", "tags", "meta"))
+        end
+    end
+
+    # Communication between abq sockets follows the following protocol:
+    #   - The first 4 bytes an unsigned 32-bit integer (big-endian) representing
+    #     the size of the rest of the message.
+    #   - The rest of the message is a JSON-encoded payload.
+    class AbqConnBroken < StandardError
+    end
+
+    # Writes a message to an Abq socket using the 4-byte header protocol.
+    #
+    # @param socket [TCPSocket]
+    # @param msg
+    def self.protocol_write(msg, socket = Abq.socket)
+      json_msg = JSON.dump msg
+      begin
+        socket.write [json_msg.bytesize].pack("N")
+        socket.write json_msg
+      rescue
+        raise AbqConnBroken
+      end
+    end
+
+    # Writes a message to an Abq socket using the 4-byte header protocol.
+    #
+    # @param socket [TCPSocket]
+    # @return msg
+    def self.protocol_read(socket = Abq.socket)
+      len_bytes = socket.read 4
+      return :abq_done if len_bytes.nil?
+      len = len_bytes.unpack1("N")
+      json_msg = socket.read len
+      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!

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: rspec-abq
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ayaz Hafiz
+- Michael Glass
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+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.
+email:
+- ayaz@rwx.com
+- me@rwx.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rspec/abq.rb
+- lib/rspec/abq/extensions.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
+licenses: []
+metadata:
+  homepage_uri: https://github.com/rwx-research/rspec-abq
+  bug_tracker_uri: https://github.com/rwx-research/rspec-abq/issues
+  changelog_uri: https://github.com/rwx-research/rspec-abq/releases
+  documentation_uri: https://rwx-research.github.io/rspec-abq/
+  source_code_uri: https://github.com/rwx-research/rspec-abq
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.26
+signing_key:
+specification_version: 4
+summary: RSpec::Abq allows for parallel rspec runs using abq
+test_files: []