ci_runner 0.1.0

data/lib/ci_runner/runners/rspec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module CIRunner
+  module Runners
+    class RSpec < Base
+      SEED_REGEX = /Randomized with seed[[:blank:]]*(\d+)/
+      BUFFER_STARTS = /(Finished in|Failed examples)/
+
+      # @param ci_log [String] The CI log output
+      #
+      # @return [Boolean] Whether this runner detects (and therefore can handle) Minitest from the log output.
+      def self.match?(log)
+        command = /bundle exec rspec/
+        summary = /Failed examples:/
+
+        Regexp.union(command, summary, /rspec/i).match?(log)
+      end
+
+      # @return [String] See Runners::Base#report
+      def name
+        "RSpec"
+      end
+
+      def start!
+        super
+
+        flags = failures.map { |failure| "--example '#{failure.test_name}'" }.join(" ")
+        flags << " --seed #{seed}" if seed
+
+        code = <<~EOM
+          require 'rspec/core/rake_task'
+
+          RSpec::Core::RakeTask.new('__ci_runner_test') do |task|
+            task.pattern = #{failures.map(&:path)}
+            task.rspec_opts = "#{flags}"
+            task.verbose = false
+          end
+
+          Rake::Task[:__ci_runner_test].invoke
+        EOM
+
+        dir = Dir.mktmpdir
+        rakefile_path = File.expand_path("Rakefile", dir)
+
+        File.write(rakefile_path, code)
+
+        env = {}
+        env["RUBY"] = ruby_path.to_s if ruby_path&.exist?
+        env["BUNDLE_GEMFILE"] = gemfile_path.to_s if gemfile_path&.exist?
+
+        execute_within_frame(env, "bundle exec ruby #{rakefile_path}")
+      end
+
+      private
+
+      def process_buffer
+        failure_regex = /rspec[[:blank:]]*(?<file_path>.*?):\d+[[:blank:]]*#[[:blank:]]*(?<test_name>.*)/
+
+        @buffer.each_line do |line|
+          line.match(failure_regex) do |match_data|
+            @failures << TestFailure.new(nil, match_data[:test_name].rstrip, match_data[:file_path])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ci_runner/test_failure.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "drb/drb"
+
+module CIRunner
+  # A container object to gather test failures as we parse the CI log output.
+  class TestFailure
+    # @see minitest/ci_runner_plugin.rb to understand why we need DRb.
+    include DRbUndumped
+
+    # @return [String] The name of the class that included the failing test.
+    #
+    # @example Given a output log: "TestReloading#test_reload_recovers_from_name_errors__w__on_unload_callbacks".
+    #  puts klass # => TestReloading
+    attr_reader :klass
+
+    # @return [String] The name of the test that failed.
+    #
+    # @example Given a output log: "TestReloading#test_reload_recovers_from_name_errors__w__on_unload_callbacks".
+    #  puts test_name # => test_reload_recovers_from_name_errors__w__on_unload_callbacks
+    attr_reader :test_name
+
+    # @return [String] The file location where this +klass+ lives.
+    attr_reader :path
+
+    # @param klass (See #klass)
+    # @param test_name (See #test_name)
+    # @param path (See #path)
+    def initialize(klass, test_name, path)
+      @klass = klass
+      @test_name = test_name
+      @path = absolute_path(Pathname(path))
+    end
+
+    private
+
+    # Transform the path parsed from the log to make it absolute. CI Runner will run the tests from a temporary
+    # folder on the user's machine, a relative path wouldn't work.
+    #
+    # Note: This method does another thing which is hacky and try to use the equivalent of `File.relative_path_from`.
+    # See the example below.
+    #
+    # @param path [String] A absolute or relative path.
+    #
+    # @return [String] An absolute path based on where the user ran the `ci_runner` command.
+    #
+    # @example Trying to hack relative_path_from
+    #   Given a log output from CI: "BlablaTest#test_abc [/home/runner/work/project/project/test/blabla.rb:7]:"
+    #   Minitest outputs absolute path, we need to detect what portion is the home of the CI from the rest.
+    #   For now using `test/` as that's usually where the Minitest tests are stored but it's likely that it would fail.
+    def absolute_path(path)
+      if path.relative?
+        return File.expand_path(path, Dir.pwd)
+      end
+
+      regex = %r{.*/?(test/.*?)\Z}
+      unless path.to_s.match?(regex)
+        raise "Can't create a relative path."
+      end
+
+      File.expand_path(path.to_s.sub(regex, '\1'), Dir.pwd)
+    end
+  end
+end

data/lib/ci_runner/test_run_finder.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module CIRunner
+  module TestRunFinder
+    extend self
+
+    # Makes a request to GitHub to retrieve the checks for a commit. Display a nice UI with
+    # a spinner while the user wait.
+    #
+    # @param repository [String] The full repository name, including the owner (i.e. rails/rails)
+    # @param commit [String] The Git commit that has been pushed to GitHub and for which we'll retrieve the CI checks.
+    # @param block [Proc, Lambda] A proc that will be called in case we can't retrieve the CI Checks.
+    #   This allows the CLI to prematurely exit and let the CLI::UI closes its frame.
+    #
+    # @return [Hash] See GitHub documentation
+    #
+    # @see https://docs.github.com/en/rest/checks/runs#list-check-runs-for-a-git-reference
+    def fetch_ci_checks(repository, commit, &block)
+      github_client = GithubClient.new(Configuration::User.instance.github_token)
+      ci_checks = {}
+      error = nil
+
+      title = "Fetching failed CI checks from GitHub for commit {{info:#{commit[..12]}}}"
+      ::CLI::UI.spinner(title, auto_debrief: false) do
+        ci_checks = github_client.check_runs(repository, commit)
+      rescue GithubClient::Error => e
+        error = e
+
+        ::CLI::UI::Spinner::TASK_FAILED
+      end
+
+      block.call(error) if error
+
+      ci_checks
+    end
+
+    # Find the CI check the user requested from the list of upstream checks.
+    # This method is useful only when the user passes the `--run-name` flag to `ci-runner`. This makes
+    # sure the CI check actually exists.
+    #
+    # @param ci_checks [Hash] The response from the previous +fetch_ci_checks+ request.
+    # @param run_name [String] The name of the CI run that the user would like to retry on its machine.
+    #
+    # @return [Hash] A single check run from the list of +ci_checks+
+    #
+    # @raise [Error] If no CI checks with the given +run_name+ could be found.
+    # @raise [Error] If the CI check was successfull. No point to continue as there should be no tests to rerun.
+    def find(ci_checks, run_name)
+      check_run = ci_checks["check_runs"].find { |check_run| check_run["name"] == run_name }
+      raise(Error, no_check_message(ci_checks, run_name)) if check_run.nil?
+      raise(Error, check_succeed(run_name)) if check_run["conclusion"] == "success"
+
+      check_run
+    end
+
+    # Try to guess which runner (Minitest, RSpec) was responsible for this log output.
+    #
+    # The runner is the most important part of CI Runner. It's what determine the failures for a CI log,
+    # as well as how to rerun those only.
+    #
+    # @param ci_log [String] The log output from CI.
+    #
+    # @return [Runners::MinitestRunner, Runners::RSpec]
+    #
+    # @raise [Error] In case none of the runners could detect the log output.
+    def detect_runner(ci_log)
+      raise_if_not_found = lambda { raise(Error, "Couldn't detect the test runner") }
+
+      runner = [Runners::MinitestRunner, Runners::RSpec].find(raise_if_not_found) do |runner|
+        runner.match?(ci_log)
+      end
+
+      runner.new(ci_log)
+    end
+
+    private
+
+    # @param [String] run_name The name of the CI check input or chosen by the user.
+    #
+    # @return [String] A error message to display.
+    def check_succeed(run_name)
+      "The CI check '#{run_name}' was successfull. There should be no failing tests to rerun."
+    end
+
+    # @param [Hash] ci_checks The list of CI checks previously by the +fetch_ci_checks+ method.
+    # @param [String] run_name The name of the CI check input or chosen by the user.
+    #
+    # @return [String] A error message letting the user know why CI Runner couldn't continue.
+    def no_check_message(ci_checks, run_name)
+      possible_checks = ci_checks["check_runs"].map do |check_run|
+        if check_run["conclusion"] == "success"
+          "#{::CLI::UI::Glyph.lookup("v")} #{check_run["name"]}"
+        else
+          "#{::CLI::UI::Glyph.lookup("x")} #{check_run["name"]}"
+        end
+      end
+
+      if possible_checks.any?
+        <<~EOM
+          Couldn't find a CI check called '#{run_name}'.
+          CI checks on this commit are:
+
+          #{possible_checks.join("\n")}
+        EOM
+      else
+        <<~EOM
+          Couldn't find a CI check called '#{run_name}'.
+
+          There are no CI checks on this commit.
+        EOM
+      end
+    end
+  end
+end

data/lib/ci_runner/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CIRunner
+  VERSION = "0.1.0"
+end

data/lib/ci_runner.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "cli/ui"
+require_relative "ci_runner/version"
+
+module CIRunner
+  Error = Class.new(StandardError)
+
+  autoload :CLI,            "ci_runner/cli"
+  autoload :GithubClient,   "ci_runner/github_client"
+  autoload :GitHelper,      "ci_runner/git_helper"
+  autoload :TestRunFinder,  "ci_runner/test_run_finder"
+  autoload :LogDownloader,  "ci_runner/log_downloader"
+  autoload :TestFailure,    "ci_runner/test_failure"
+
+  module Configuration
+    autoload :User, "ci_runner/configuration/user"
+    autoload :Project, "ci_runner/configuration/project"
+  end
+
+  module Runners
+    autoload :MinitestRunner, "ci_runner/runners/minitest_runner"
+    autoload :RSpec,          "ci_runner/runners/rspec"
+  end
+end

data/lib/minitest/ci_runner_plugin.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "drb/drb"
+
+module Minitest
+  extend self
+
+  def plugin_ci_runner_options(opts, options)
+    opts.on("--ci-runner=URI", "The UNIX socket CI Runner needs to connect to") do |value|
+      options[:ci_runner] = value
+    end
+  end
+
+  def plugin_ci_runner_init(options)
+    return unless options[:ci_runner]
+
+    options[:args].gsub!(/\s*--ci-runner=#{options[:ci_runner]}\s*/, "")
+
+    DRb.start_service
+    failures = DRbObject.new_with_uri(options[:ci_runner])
+
+    filter = Struct.new(:failures) do
+      def ===(runnable)
+        failures.any? do |failure|
+          "#{failure.klass}##{failure.test_name}" == runnable
+        end
+      end
+    end
+
+    options[:filter] = filter.new(failures)
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: ci_runner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Edouard Chin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cli-ui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.14'
+description: |
+  Tired of copying the test suites names from a failed CI?
+
+  This gem will automate this tedious workflow. CI Runner will download the log from your CI
+  provider, parse it, detect failures and rerun exactly the same failing tests on your machine.
+
+  CI Runner can also detect the Ruby version used on your CI as well as which Gemfile and reuse
+  those when starting the run locally.
+email:
+- chin.edouard@gmail.com
+executables:
+- ci_runner
+extensions: []
+extra_rdoc_files: []
+files:
+- ci_runner.gemspec
+- exe/ci_runner
+- lib/ci_runner.rb
+- lib/ci_runner/cli.rb
+- lib/ci_runner/configuration/project.rb
+- lib/ci_runner/configuration/user.rb
+- lib/ci_runner/git_helper.rb
+- lib/ci_runner/github_client.rb
+- lib/ci_runner/log_downloader.rb
+- lib/ci_runner/runners/base.rb
+- lib/ci_runner/runners/minitest_runner.rb
+- lib/ci_runner/runners/rspec.rb
+- lib/ci_runner/test_failure.rb
+- lib/ci_runner/test_run_finder.rb
+- lib/ci_runner/version.rb
+- lib/minitest/ci_runner_plugin.rb
+homepage: https://github.com/Edouard-chin/ci_runner
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Edouard-chin/ci_runner
+  source_code_uri: https://github.com/Edouard-chin/ci_runner
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Re-run failing tests from CI on your local machine without copy/pasting.
+test_files: []