quarantine 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 85d2c80359510de3dfd3d4c84cea8c04efed552bc11b44eed887f87caf7cd556
+  data.tar.gz: 2b075d8cde72b8451c9decbfacc24f0f18022fe446abf13c1a835cc9abd4a39b
+SHA512:
+  metadata.gz: 57babcb9ddb17b96c48d3800f9af910998efd2a52cc68ad0b982edf7d0e84fa0f43f2918db039e59bf3ef855861602b662dd0e5beb3d9073e5f5e5247ba18c6a
+  data.tar.gz: 0ac7fa45415f46529fee23088a41746e80fd096cb5aea55d181b9147add6b70d67fe5b48407e1508390a69c310a878f96887149b7767170b66a5d97e4efa967d

data/README.md

@@ -0,0 +1,154 @@
+# Quarantine
+[![Build Status](https://travis-ci.com/flexport/quarantine.svg?branch=master)](https://travis-ci.com/flexport/quarantine)
+
+Quarantine provides a run-time solution to diagnosing and disabling flaky tests and automates the workflow around test suite maintenance.
+
+The quarantine gem supports testing frameworks:
+- [RSpec](http://rspec.info/)
+
+The quarantine gem supports CI pipelines:
+- [Buildkite](https://buildkite.com/docs/tutorials/getting-started)
+
+If you are interested in using quarantine but it does not support your CI or testing framework, feel free to reach out or create an issue and we can try to make it happen.
+
+## Purpose
+Flaky tests impact engineering velocity, reduce faith in test reliablity and give a false representation of code coverage. Managing flaky tests is a clunky process that involves constant build monitorization, difficult diagnosis and manual ticket creation. As a result, here at Flexport, we have created a Gem to automate the entire process to help improve the workflow and keep our massive test suites in pristine condition.
+
+The workflow at Flexport involves:
+
+![ideal workflow](misc/flexport_workflow.png)
+
+---
+## Installation and Setup
+
+Add these lines to your application's Gemfile:
+```
+group :test do
+  gem 'quarantine'
+  gem 'rspec-retry
+end
+```
+
+And then execute:
+```
+bundle install
+```
+
+In your `spec_helper.rb` setup quarantine and rspec-retry gem. Click [rspec-retry](https://github.com/NoRedInk/rspec-retry) to get a more detailed explaination on rspec-retry configurations and how to setup.
+```
+require 'quarantine'
+require 'rspec-retry'
+
+Quarantine.bind({database: :dynamodb, aws_region: 'us-west-1'})
+
+RSpec.configure do |config|
+
+  config.around(:each) do |ex|
+    ex.run_with_retry(retry: 3)
+  end
+
+end
+```
+
+Consider wrapping `Quarantine.bind` in if statements so local flaky tests don't pollute the list of quarantined tests
+
+```
+if ENV[CI] && ENV[BRANCH] == "master"
+  Quarantine.bind({database: :dynamodb, aws_region: 'us-west-1'})
+end
+```
+
+Setup tables in AWS DynamoDB to support pulling and uploading quarantined tests
+```
+bundle exec quarantine_dynamodb -h    # see all options
+
+bundle exec quarantine_dynamodb \     # create the tables in us-west-1 in aws dynamodb
+  --aws_region us-west-1              # with "quarantine_list" and "master_failed_tests"
+                                      # table names
+```
+
+You are all set to start quarantining tests!
+
+## Try Quarantining Tests Locally
+Add a test that will flake
+```
+require "spec_helper"
+
+describe Quarantine do
+  it "this test should flake 33% of the time" do
+    Random.rand(3).to eq(3)
+  end
+end
+```
+
+Run `rspec` on the test
+```
+CI=1 BRANCH=master rspec <filename>
+```
+
+If the test fails and passes on the test run (rspec-retry re-ran the test), the test should be quarantined and uploaded to DynamoDB. Check the `quarantine_list` table in DynamoDB.
+
+## Configuration
+
+Go to `spec/spec_helper.rb` and set configuration variables through:
+```
+RSpec.configure do |config|
+    config.VAR_NAME = VALUE
+end
+```
+- Table name for quarantined tests `:quarantine_list_table, default: "quarantine_list"`
+
+- Table name where failed test are uploaded `:quarantine_failed_tests_table, default: "master_failed_tests"`
+
+- Quarantined tests are not skipped automatically `:skip_quarantined_tests, default: true`
+
+- Recording failed tests `:quarantine_record_failed_tests, default: true`
+
+- Recording flaky tests `:quarantine_record_flaky_tests, default: true`
+
+- Outputting quarantined gem info `:quarantine_logging, default: true`
+
+---
+## Setup Jira Workflow
+
+To automatically create Jira tickets, take a look at: `examples/create_tickets.rb`
+
+To automatically unquarantine tests on Jira ticket completion, take a look at: `examples/unquarantine.rb`
+
+---
+## Contributing
+1. Create an issue regarding a bug fix or feature request
+2. Fork the repository
+3. Create your feature branch, commit changes and create a pull request
+
+## Contributors
+- [Eric Zhu](https://github.com/eric-zhu-uw)
+- [Kevin Miller](https://github.com/Gasparila)
+- [Nicholas Silva](https://github.com/flexportnes)
+- [Ankur Dahiya](https://github.com/legalosLOTR)
+---
+
+## FAQs
+
+#### Why are quarantined tests not being skipped locally?
+
+The `quarantine` gem may be configured to only run on certain environments. Make sure you pass all these `ENV` variables to `rspec` when you call it locally
+
+```
+CI="1" BRANCH="master" rspec
+```
+
+#### Why is dynamodb failing to connect?
+
+The AWS client loads credentials from the following locations:
+- `ENV['AWS_ACCESS_KEY_ID']` and `ENV['AWS_SECRET_ACCESS_KEY']`
+- `Aws.config[:credentials]`
+- The shared credentials ini file at `~/.aws/credentials`
+
+To get AWS credentials, please contact your AWS administrator to get access to dynamodb and create your credentials through IAM.
+
+More detailed information can be found: [AWS documentation](https://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Client.html)
+
+#### Why is `example.clear_exception` failing locally?
+ 
+ `example.clear_exception` is an attribute added through `rspec_retry`. Make sure `rspec-retry` has been installed and configured.

data/bin/quarantine_dynamodb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'aws-sdk'
+require 'optparse'
+
+require_relative '../lib/quarantine/cli'
+
+cli = Quarantine::CLI.new
+cli.parse
+cli.create_tables

data/lib/quarantine/cli.rb

@@ -0,0 +1,85 @@
+require 'optparse'
+require_relative 'databases/base'
+require_relative 'databases/dynamo_db'
+
+class Quarantine
+  class CLI
+    attr_accessor :options
+
+    def initialize
+      # default options
+      @options = {
+        quarantine_list_table_name: 'quarantine_list',
+        failed_test_table_name: 'master_failed_tests'
+      }
+    end
+
+    def parse
+      OptionParser.new do |parser|
+        parser.banner = 'Usage: quarantine_dynamodb [options]'
+
+        parser.on('-rREGION', '--aws_region=REGION', String, 'Specify the aws region for DynamoDB') do |aws_region|
+          options[:aws_region] = aws_region
+        end
+
+        parser.on(
+          '-qTABLE',
+          '--quarantine_table=TABLE',
+          String,
+          "Specify the table name for the quarantine list | Default: #{options[:quarantine_list_table_name]}"
+        ) do |table_name|
+          options[:quarantine_list_table_name] = table_name
+        end
+
+        parser.on(
+          '-fTABLE',
+          '--failed_table=TABLE',
+          String,
+          "Specify the table name for the failed test list | Default: #{options[:failed_test_table_name]}"
+        ) do |table_name|
+          options[:failed_test_table_name] = table_name
+        end
+
+        parser.on('-h', '--help', 'Prints help page') do
+          puts parser # rubocop:disable Rails/Output
+          exit
+        end
+      end.parse!
+
+      if options[:aws_region].nil?
+        error_msg = 'Failed to specify the required aws region with -r option'.freeze
+        warn error_msg
+        raise ArgumentError.new(error_msg)
+      end
+    end
+
+    # TODO: eventually move to a separate file & create_table by db type when my db adapters
+    def create_tables
+      dynamodb = Quarantine::Databases::DynamoDB.new(options)
+
+      attributes = [
+        { attribute_name: 'id', attribute_type: 'S', key_type: 'HASH' },
+        { attribute_name: 'build_number', attribute_type: 'S', key_type: 'RANGE' }
+      ]
+
+      additional_arguments = {
+        provisioned_throughput: {
+          read_capacity_units: 10,
+          write_capacity_units: 5
+        }
+      }
+
+      begin
+        dynamodb.create_table(options[:quarantine_list_table_name], attributes, additional_arguments)
+      rescue Quarantine::DatabaseError => e
+        warn "#{e&.cause&.class}: #{e&.cause&.message}"
+      end
+
+      begin
+        dynamodb.create_table(options[:failed_test_table_name], attributes, additional_arguments)
+      rescue Quarantine::DatabaseError => e
+        warn "#{e&.cause&.class}: #{e&.cause&.message}"
+      end
+    end
+  end
+end

data/lib/quarantine/databases/base.rb

@@ -0,0 +1,17 @@
+class Quarantine
+  module Databases
+    class Base
+      def initialize
+        raise NotImplementedError
+      end
+
+      def scan
+        raise NotImplementedError
+      end
+
+      def batch_write_item
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/quarantine/databases/dynamo_db.rb

@@ -0,0 +1,77 @@
+require 'aws-sdk'
+require 'quarantine/databases/base'
+require 'quarantine/error'
+
+class Quarantine
+  module Databases
+    class DynamoDB < Base
+      attr_accessor :dynamodb
+
+      def initialize(aws_region: 'us-west-1', **_additional_arguments)
+        @dynamodb = Aws::DynamoDB::Client.new({ region: aws_region })
+      end
+
+      def scan(table_name)
+        begin
+          result = dynamodb.scan({ table_name: table_name })
+        rescue Aws::DynamoDB::Errors::ServiceError
+          raise Quarantine::DatabaseError
+        end
+
+        result&.items
+      end
+
+      def batch_write_item(table_name, items, additional_attributes = {})
+        dynamodb.batch_write_item(
+          { request_items: {
+            table_name => items.map do |item|
+              {
+                put_request: {
+                  item: { **item.to_hash, **additional_attributes }
+                }
+              }
+            end
+          } }
+        )
+      rescue Aws::DynamoDB::Errors::ServiceError
+        raise Quarantine::DatabaseError
+      end
+
+      def delete_item(table_name, keys)
+        dynamodb.delete_item(
+          {
+            table_name: table_name,
+            key: {
+              **keys
+            }
+          }
+        )
+      rescue Aws::DynamoDB::Errors::ServiceError
+        raise Quarantine::DatabaseError
+      end
+
+      def create_table(table_name, attributes, additional_arguments = {})
+        dynamodb.create_table(
+          {
+            table_name: table_name,
+            attribute_definitions: attributes.map do |attribute|
+              {
+                attribute_name: attribute[:attribute_name],
+                attribute_type: attribute[:attribute_type]
+              }
+            end,
+            key_schema: attributes.map do |attribute|
+              {
+                attribute_name: attribute[:attribute_name],
+                key_type: attribute[:key_type]
+              }
+            end,
+            **additional_arguments
+          }
+        )
+      rescue Aws::DynamoDB::Errors::ServiceError
+        raise Quarantine::DatabaseError
+      end
+    end
+  end
+end

data/lib/quarantine/error.rb

@@ -0,0 +1,13 @@
+class Quarantine
+  class Error < StandardError; end
+
+  # Raised when a database error has occured
+  # TODO(ezhu): expand error messages to cover more specific error messages
+  class DatabaseError < Error; end
+
+  # Raised when quarantine does not know how to upload a specific test
+  class UnknownUploadError < Error; end
+
+  # Quarantine does not work with the specificed database
+  class UnsupportedDatabaseError < Error; end
+end

data/lib/quarantine/rspec_adapter.rb

@@ -0,0 +1,85 @@
+module RSpecAdapter
+  # Purpose: create an instance of Quarantine which contains information
+  #          about the test suite (ie. quarantined tests) and binds RSpec configurations
+  #          and hooks onto the global RSpec class
+  def bind(options = {})
+    quarantine = Quarantine.new(options)
+    bind_rspec_configurations
+    bind_quarantine_list(quarantine)
+    bind_quarantine_checker(quarantine)
+    bind_quarantine_record_tests(quarantine)
+    bind_logger(quarantine)
+  end
+
+  private
+
+  # Purpose: binds rspec configuration variables
+  def bind_rspec_configurations
+    ::RSpec.configure do |config|
+      config.add_setting(:quarantine_list_table, { default: 'quarantine_list' })
+      config.add_setting(:quarantine_failed_tests_table, { default: 'master_failed_tests' })
+      config.add_setting(:skip_quarantined_tests, { default: true })
+      config.add_setting(:quarantine_record_failed_tests, { default: true })
+      config.add_setting(:quarantine_record_flaky_tests, { default: true })
+      config.add_setting(:quarantine_logging, { default: true })
+    end
+  end
+
+  # Purpose: binds quarantine to fetch the quarantine_list from dynamodb in the before suite
+  def bind_quarantine_list(quarantine)
+    ::RSpec.configure do |config|
+      config.before(:suite) do
+        quarantine.fetch_quarantine_list
+      end
+    end
+  end
+
+  # Purpose: binds quarantine to skip and pass tests that have been quarantined in the after suite
+  def bind_quarantine_checker(quarantine)
+    ::RSpec.configure do |config|
+      config.after(:each) do |example|
+        if RSpec.configuration.skip_quarantined_tests && quarantine.test_quarantined?(example)
+          quarantine.pass_flaky_test(example)
+        end
+      end
+    end
+  end
+
+  # Purpose: binds quarantine to record failed and flaky tests
+  def bind_quarantine_record_tests(quarantine)
+    ::RSpec.configure do |config|
+      config.after(:each) do |example|
+        metadata = example.metadata
+
+        # will record the failed test if is not quarantined and it is on it's final retry from the rspec-retry gem
+        quarantine.record_failed_test(example) if
+          RSpec.configuration.quarantine_record_failed_tests &&
+          !quarantine.test_quarantined?(example) &&
+          metadata[:retry_attempts] + 1 == metadata[:retry] && example.exception
+
+        # will record the flaky test if is not quarantined and it failed the first run but passed a subsequent run
+        quarantine.record_flaky_test(example) if
+          RSpec.configuration.quarantine_record_flaky_tests &&
+          !quarantine.test_quarantined?(example) &&
+          metadata[:retry_attempts] > 0 && example.exception.nil?
+      end
+    end
+
+    ::RSpec.configure do |config|
+      config.after(:suite) do
+        quarantine.upload_tests(:failed) if RSpec.configuration.quarantine_record_failed_tests
+
+        quarantine.upload_tests(:flaky) if RSpec.configuration.quarantine_record_flaky_tests
+      end
+    end
+  end
+
+  # Purpose: binds quarantine logger to output test to RSpec formatter messages
+  def bind_logger(quarantine)
+    ::RSpec.configure do |config|
+      config.after(:suite) do
+        RSpec.configuration.reporter.message(quarantine.summary) if RSpec.configuration.quarantine_logging
+      end
+    end
+  end
+end

data/lib/quarantine/test.rb

@@ -0,0 +1,24 @@
+class Quarantine
+  class Test
+    attr_accessor :id
+    attr_accessor :full_description
+    attr_accessor :location
+    attr_accessor :build_number
+
+    def initialize(id, full_description, location, build_number)
+      @id = id
+      @full_description = full_description
+      @location = location
+      @build_number = build_number
+    end
+
+    def to_hash
+      {
+        id: id,
+        full_description: full_description,
+        location: location,
+        build_number: build_number
+      }
+    end
+  end
+end

data/lib/quarantine/version.rb

@@ -0,0 +1,3 @@
+class Quarantine
+  VERSION = '0.0.7'.freeze
+end

data/lib/quarantine.rb

@@ -0,0 +1,142 @@
+require 'aws-sdk'
+require 'rspec/retry'
+require 'quarantine/rspec_adapter'
+require 'quarantine/test'
+require 'quarantine/databases/base'
+require 'quarantine/databases/dynamo_db'
+
+class Quarantine
+  extend RSpecAdapter
+
+  attr_accessor :database
+  attr_reader :quarantine_map
+  attr_reader :failed_tests
+  attr_reader :flaky_tests
+  attr_reader :duplicate_tests
+  attr_reader :buildkite_build_number
+  attr_reader :summary
+
+  def initialize(options = {})
+    case options[:database]
+    # default database option is dynamodb
+    when :dynamodb, nil
+      @database = Quarantine::Databases::DynamoDB.new(options)
+    else
+      raise Quarantine::UnsupportedDatabaseError.new("Quarantine does not support #{options[:database]}")
+    end
+
+    @quarantine_map = {}
+    @failed_tests = []
+    @flaky_tests = []
+    @buildkite_build_number = ENV['BUILDKITE_BUILD_NUMBER'] || '-1'
+    @summary = { id: 'quarantine', quarantined_tests: [], flaky_tests: [], database_failures: [] }
+  end
+
+  # Scans the quarantine_list from the database and store the individual tests in quarantine_map
+  def fetch_quarantine_list
+    begin
+      quarantine_list = database.scan(RSpec.configuration.quarantine_list_table)
+    rescue Quarantine::DatabaseError => e
+      add_to_summary(:database_failures, "#{e&.cause&.class}: #{e&.cause&.message}")
+      raise Quarantine::DatabaseError.new(
+        <<~ERROR_MSG
+          Failed to pull the quarantine list from #{RSpec.configuration.quarantine_list_table}
+          because of #{e&.cause&.class}: #{e&.cause&.message}
+        ERROR_MSG
+      )
+    end
+
+    quarantine_list.each do |example|
+      # on the rare occassion there are duplicate tests ids in the quarantine_list,
+      # quarantine the most recent instance of the test (det. through build_number)
+      # and ignore the older instance of the test
+      next if
+        quarantine_map.key?(example['id']) &&
+        example['build_number'].to_i < quarantine_map[example['id']].build_number.to_i
+
+      quarantine_map.store(
+        example['id'],
+        Quarantine::Test.new(example['id'], example['full_description'], example['location'], example['build_number'])
+      )
+    end
+  end
+
+  # Based off the type, upload a list of tests to a particular database table
+  def upload_tests(type)
+    if type == :failed
+      tests = failed_tests
+      table_name = RSpec.configuration.quarantine_failed_tests_table
+    elsif type == :flaky
+      tests = flaky_tests
+      table_name = RSpec.configuration.quarantine_list_table
+    else
+      raise Quarantine::UnknownUploadError.new(
+        "Quarantine gem did not know how to handle #{type} upload of tests to dynamodb"
+      )
+    end
+
+    return unless tests.length < 10 && tests.length > 0
+
+    begin
+      timestamp = Time.now.to_i / 1000 # Truncated millisecond from timestamp for reasons specific to Flexport
+      database.batch_write_item(
+        table_name,
+        tests,
+        {
+          build_job_id: ENV['BUILDKITE_JOB_ID'] || '-1',
+          created_at: timestamp,
+          updated_at: timestamp
+        }
+      )
+    rescue Quarantine::DatabaseError => e
+      add_to_summary(:database_failures, "#{e&.cause&.class}: #{e&.cause&.message}")
+    end
+  end
+
+  # Param: RSpec::Core::Example
+  # Add the example to the internal failed tests list
+  def record_failed_test(example)
+    failed_tests << Quarantine::Test.new(
+      example.id,
+      example.full_description,
+      example.location,
+      buildkite_build_number
+    )
+  end
+
+  # Param: RSpec::Core::Example
+  # Add the example to the internal flaky tests list
+  def record_flaky_test(example)
+    flaky_test = Quarantine::Test.new(
+      example.id,
+      example.full_description,
+      example.location,
+      buildkite_build_number
+    )
+
+    flaky_tests << flaky_test
+    add_to_summary(:flaky_tests, flaky_test.id)
+  end
+
+  # Param: RSpec::Core::Example
+  # Clear exceptions on a flaky tests that has been quarantined
+  #
+  # example.clear_exception is tightly coupled with the rspec-retry gem and will only exist if
+  # the rspec-retry gem is enabled
+  def pass_flaky_test(example)
+    example.clear_exception
+    add_to_summary(:quarantined_tests, example.id)
+  end
+
+  # Param: RSpec::Core::Example
+  # Check the internal quarantine_map to see if this test should be quarantined
+  def test_quarantined?(example)
+    quarantine_map.key?(example.id)
+  end
+
+  # Param: Symbol, Any
+  # Adds the item to the specified attribute in summary
+  def add_to_summary(attribute, item)
+    summary[attribute] << item if summary.key?(attribute)
+  end
+end

data/quarantine.gemspec

@@ -0,0 +1,23 @@
+# TEAM: backend_infra
+#
+$LOAD_PATH.push(File.expand_path('lib', __dir__))
+
+# Maintain your gem's version:
+require 'quarantine/version'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name = 'quarantine'
+  s.version = Quarantine::VERSION
+  s.authors = ['Flexport Engineering, Eric Zhu']
+  s.email = ['ericzhu77@gmail.com']
+  s.summary = 'Quarantine flaky Ruby Rspec tests'
+  s.homepage = 'https://github.com/flexport/quarantine'
+  s.license = 'MIT'
+  s.files = Dir['{lib, bin}/**/*', '*.md', '*.gemspec']
+  s.executables = ['quarantine_dynamodb']
+
+  s.add_dependency('aws-sdk', '~> 2.11.41')
+  s.add_dependency('rspec', '>= 3.0')
+  s.add_dependency('rspec-retry', '>= 0.6.1')
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: quarantine
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+platform: ruby
+authors:
+- Flexport Engineering, Eric Zhu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.11.41
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.11.41
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+description: 
+email:
+- ericzhu77@gmail.com
+executables:
+- quarantine_dynamodb
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/quarantine_dynamodb
+- lib/quarantine.rb
+- lib/quarantine/cli.rb
+- lib/quarantine/databases/base.rb
+- lib/quarantine/databases/dynamo_db.rb
+- lib/quarantine/error.rb
+- lib/quarantine/rspec_adapter.rb
+- lib/quarantine/test.rb
+- lib/quarantine/version.rb
+- quarantine.gemspec
+homepage: https://github.com/flexport/quarantine
+licenses:
+- MIT
+metadata: {}
+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.0.2
+signing_key: 
+specification_version: 4
+summary: Quarantine flaky Ruby Rspec tests
+test_files: []