raider_reporter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b1e069eeb6569206c085d042b6b3e26f0e35bbb2459b60dccfecf6d744aaef86
+  data.tar.gz: f117594302d75a2d97edfba870beb04e69d477acbb6f80ab276689e55d3c531a
+SHA512:
+  metadata.gz: ad5162cad62d6efed699f663f977540ef84f1dc640845d112c8f594bac34767aec0224a341e55e4ebb354b5a59b57bc13c5b4deacd071b8ade6bbade90b85366
+  data.tar.gz: 6b68c2e3ab889e30a2ff1e9c6cb075f7e3e8556d92557e60f36360daf232e9f9ed72d8041592f8766c8496bc5d303700222e2b96f1df685b8813ece4627c1375

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0 — 2026-10-11
+
+- RSpec formatter writing Raider schema v1 to `raider-results/run.json`
+- Screenshot and video attachments via `RaiderReporter.attach`, copied when attached (5 MB limit per file)
+- Optional fail-open upload to a Raider server (`RAIDER_TOKEN`, `RAIDER_ENDPOINT`), capped at 45 MB / 1000 attachment files per upload
+- GitHub Actions CI and git metadata detection

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Augustin Gottlieb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# raider_reporter
+
+Raider-schema test reporting for RSpec. `raider_reporter` is an RSpec formatter that records every example's result, failure details, screenshots and videos, writes them to a local `run.json` (schema v1), and can optionally upload the run to a Raider server. It replaces Allure for Ruby Raider projects.
+
+It has no runtime dependencies and requires Ruby 3.2 or newer.
+
+## Install
+
+```ruby
+# Gemfile
+gem "raider_reporter"
+```
+
+## Setup
+
+Require the RSpec integration in `spec/spec_helper.rb`:
+
+```ruby
+require "raider_reporter/rspec"
+```
+
+Enable the formatter in `.rspec`:
+
+```
+--format progress
+--format RaiderReporter::RSpec::Formatter
+```
+
+Run `bundle exec rspec` as usual. Results land in `raider-results/run.json`. A dry run (`rspec --dry-run`) writes and uploads nothing.
+
+## Attaching screenshots and videos
+
+Call `RaiderReporter.attach` while an example is running, for example from an `after` hook:
+
+```ruby
+RSpec.configure do |config|
+  config.after do |example|
+    next unless example.exception
+
+    FileUtils.mkdir_p("tmp/screenshots")
+    path = "tmp/screenshots/#{example.id.gsub(/\W/, '_')}.png"
+    driver.save_screenshot(path)
+    RaiderReporter.attach("screenshot", path, type: :png)
+  end
+end
+```
+
+`attach` copies the file right away, so the attachment keeps the bytes the file had at that moment even if the same path is overwritten by a later example. Using a path per example (as above) still makes the files on disk easier to find.
+
+`attach` returns `true` on success. It returns `false` and prints a `[raider_reporter]` warning, never raising, if it is called outside a running example (for instance when the formatter is not loaded), if the file does not exist, or if the file is larger than 5 MB.
+
+## Configuration
+
+```ruby
+RaiderReporter.configure do |c|
+  c.output_dir = "raider-results"
+  c.environment = { "browser" => "chrome", "suite" => "smoke", "headless" => true }
+end
+```
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `token` | `ENV["RAIDER_TOKEN"]` | API token used for uploads. |
+| `endpoint` | `ENV["RAIDER_ENDPOINT"]` | Base URL of the Raider server to upload to. |
+| `output_dir` | `"raider-results"` | Directory for local output. |
+| `clean_output_dir` | `true` | Remove the previous `run.json` and `attachments/` directory inside `output_dir` before writing. Nothing else in `output_dir` is touched. |
+| `environment` | `{}` | Free-form key/values stored with the run (browser, suite name, and so on). Values are JSON values: strings, booleans or numbers. |
+
+## Local output
+
+```
+raider-results/
+  run.json          # the run in schema v1
+  attachments/      # copies of attached screenshots and videos
+```
+
+Add `raider-results/` to your `.gitignore`.
+
+## Uploading to Raider
+
+If both a token and an endpoint are set, the run (plus attachments) is uploaded when the suite finishes:
+
+```
+RAIDER_TOKEN=... RAIDER_ENDPOINT=https://your-raider-server bundle exec rspec
+```
+
+On success the formatter prints `Raider report: <url>` (or `Raider report uploaded (run <id>)` if the server's response has no URL). If either value is missing, nothing is uploaded and the local files are still written.
+
+An upload carries at most 45 MB of attachments and at most 1000 attachment files. Attachments past that budget are left out of the upload (in order, with one warning) but stay in the local `raider-results/`.
+
+Reporting is fail-open: no error inside the gem, network failure, timeout or non-2xx response will raise or change RSpec's exit status. Each connect/write/read step of the upload times out after 30 seconds. Problems are printed as warnings prefixed with `[raider_reporter]`. An endpoint without `http://` or `https://` (for example `localhost:3000`) produces a warning and nothing is uploaded; a trailing slash is fine.
+
+The hosted Raider service is not public yet; uploads go to a Raider server whose address you provide in `RAIDER_ENDPOINT`.
+
+## Examples
+
+- `examples/rspec_basic` is a runnable RSpec project with a passing, a failing (with an attachment) and a skipped example. Run it with `cd examples/rspec_basic && bundle install && bundle exec rspec`; the failure is deliberate.
+- `examples/github_actions.yml` shows the workflow steps for CI.
+
+## Schema
+
+`run.json` follows schema v1, documented in [docs/schema-v1.md](docs/schema-v1.md). Statuses are exactly `passed`, `failed`, `pending` and `skipped`.
+
+## Contributing
+
+Bug reports and pull requests are welcome at https://github.com/RaiderHQ/raider_reporter. Run `bundle install && bundle exec rake` to run the specs.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/lib/raider_reporter/ci_detector.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RaiderReporter
+  class CiDetector
+    def initialize(env: ENV, git: method(:git_command))
+      @env = env
+      @git = git
+    end
+
+    def ci
+      return nil unless @env["GITHUB_ACTIONS"] == "true"
+
+      run_id = @env["GITHUB_RUN_ID"]
+      build_url = if @env["GITHUB_SERVER_URL"] && @env["GITHUB_REPOSITORY"] && run_id
+                    "#{@env['GITHUB_SERVER_URL']}/#{@env['GITHUB_REPOSITORY']}/actions/runs/#{run_id}"
+                  end
+      { "provider" => "github_actions", "build_url" => build_url, "build_id" => run_id }.compact
+    end
+
+    def git
+      info = { "branch" => branch, "commit_sha" => sha, "commit_message" => @git.call("log", "-1", "--pretty=%s") }
+      info = info.compact
+      info.empty? ? nil : info
+    end
+
+    private
+
+    def branch
+      head_ref = @env["GITHUB_HEAD_REF"].to_s
+      return head_ref unless head_ref.empty?
+
+      return @env["GITHUB_REF_NAME"] if @env["GITHUB_REF_NAME"]
+
+      local = @git.call("rev-parse", "--abbrev-ref", "HEAD")
+      local == "HEAD" ? nil : local # "HEAD" means detached, not a branch name
+    end
+
+    def sha
+      @env["GITHUB_SHA"] || @git.call("rev-parse", "HEAD")
+    end
+
+    def git_command(*args)
+      out, _err, status = Open3.capture3("git", *args)
+      status.success? ? out.strip : nil
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/raider_reporter/collector.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "tmpdir"
+require "fileutils"
+
+module RaiderReporter
+  # Accumulates one suite run. Framework formatters call it; writers read the Run it returns.
+  class Collector
+    def initialize(max_attachment_bytes:, warn:, clock: -> { Time.now.utc }, uuid: -> { SecureRandom.uuid })
+      @max_attachment_bytes = max_attachment_bytes
+      @warn = warn
+      @clock = clock
+      @uuid = uuid
+      @results = []
+      @pending_attachments = nil
+      @staged = 0
+    end
+
+    def start_run
+      @started_at = @clock.call
+      @results = []
+    end
+
+    def start_test
+      @pending_attachments = []
+    end
+
+    def in_test?
+      !@pending_attachments.nil?
+    end
+
+    def attach(attachment)
+      return false unless in_test?
+
+      @pending_attachments << attachment
+      true
+    end
+
+    # Copies a file into a collector-owned staging dir so later writes to the
+    # same path (a reused screenshot name) cannot change what this example sent.
+    def stage(path)
+      @staging_dir ||= Dir.mktmpdir("raider_reporter")
+      dir = File.join(@staging_dir, @staged.to_s)
+      @staged += 1
+      FileUtils.mkdir_p(dir)
+      copy = File.join(dir, File.basename(path))
+      FileUtils.cp(path, copy)
+      copy
+    end
+
+    def cleanup
+      FileUtils.rm_rf(@staging_dir) if @staging_dir
+      @staging_dir = nil
+    end
+
+    def finish_test(**fields)
+      result = TestResult.new(**fields, attachments: @pending_attachments || [])
+      @pending_attachments = nil
+      @results << result
+      result
+    end
+
+    def finish_run(ci:, git:, environment:)
+      Run.new(
+        client_run_id: @uuid.call, started_at: @started_at, finished_at: @clock.call,
+        ci: ci, git: git, environment: environment,
+        results: @results.map { |r| r.with(attachments: r.attachments.select { |a| keep?(a) }) }
+      )
+    end
+
+    private
+
+    def keep?(attachment)
+      path = attachment.source_path
+      unless File.file?(path)
+        @warn.call("attachment #{path} no longer exists; skipped")
+        return false
+      end
+      if File.size(path) > @max_attachment_bytes
+        @warn.call("attachment #{path} is larger than #{@max_attachment_bytes} bytes; skipped")
+        return false
+      end
+      true
+    end
+  end
+end

data/lib/raider_reporter/configuration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RaiderReporter
+  class Configuration
+    attr_accessor :token, :endpoint, :output_dir, :clean_output_dir, :environment, :max_attachment_bytes
+
+    def initialize(env = ENV)
+      @token = env["RAIDER_TOKEN"]
+      @endpoint = env["RAIDER_ENDPOINT"]
+      @output_dir = "raider-results"
+      @clean_output_dir = true
+      @environment = {}
+      @max_attachment_bytes = 5 * 1024 * 1024
+    end
+
+    def upload?
+      present?(token) && present?(endpoint)
+    end
+
+    private
+
+    def present?(value)
+      !value.nil? && !value.to_s.strip.empty?
+    end
+  end
+end

data/lib/raider_reporter/content_types.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RaiderReporter
+  module ContentTypes
+    BY_EXTENSION = {
+      ".png" => "image/png", ".jpg" => "image/jpeg", ".jpeg" => "image/jpeg", ".gif" => "image/gif",
+      ".webp" => "image/webp", ".mp4" => "video/mp4", ".webm" => "video/webm", ".mov" => "video/quicktime",
+      ".txt" => "text/plain", ".log" => "text/plain", ".html" => "text/html", ".json" => "application/json"
+    }.freeze
+    BY_SYMBOL = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", mp4: "video/mp4",
+                  webm: "video/webm", text: "text/plain", html: "text/html", json: "application/json" }.freeze
+
+    MIME = %r{\A[\w.+-]+/[\w.+-]+\z}
+
+    module_function
+
+    def resolve(type, path)
+      if type.is_a?(String)
+        return type if type.match?(MIME)
+
+        type = nil
+      end
+      return BY_SYMBOL.fetch(type) if BY_SYMBOL.key?(type)
+
+      from_ext = BY_EXTENSION[File.extname(path.to_s).downcase]
+      return from_ext if from_ext && (type.nil? || from_ext.start_with?("#{type}/"))
+      return "video/mp4" if type == :video
+      return "image/png" if type == :image
+
+      "application/octet-stream"
+    end
+  end
+end

data/lib/raider_reporter/models.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RaiderReporter
+  SCHEMA_VERSION = 1
+  STATUSES = %w[passed failed pending skipped].freeze
+
+  Failure = Data.define(:message, :exception_class, :backtrace)
+  Attachment = Data.define(:name, :source_path, :content_type)
+  TestResult = Data.define(
+    :identifier, :full_name, :file_path, :line_number, :status,
+    :duration_ms, :attempts, :tags, :failure, :attachments
+  )
+  Run = Data.define(:client_run_id, :started_at, :finished_at, :ci, :git, :environment, :results)
+end

data/lib/raider_reporter/payload.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RaiderReporter
+  # Serializes a Run into schema v1. Local mode points attachments at copied
+  # files; upload mode points them at multipart part names.
+  class Payload
+    MODES = %i[local upload].freeze
+
+    attr_reader :run
+
+    def initialize(run)
+      @run = run
+    end
+
+    def to_h(mode:)
+      raise ArgumentError, "unknown mode #{mode.inspect}" unless MODES.include?(mode)
+
+      entries = attachment_entries.each
+      {
+        "schema_version" => SCHEMA_VERSION,
+        "client_run_id" => @run.client_run_id,
+        "run" => run_hash,
+        "results" => @run.results.map do |result|
+          result_hash(result).merge(
+            "attachments" => result.attachments.map { attachment_hash(entries.next, mode) }
+          )
+        end
+      }
+    end
+
+    def attachment_entries
+      @attachment_entries ||= @run.results.flat_map(&:attachments).each_with_index.map do |attachment, index|
+        {
+          attachment: attachment,
+          part: "att_#{index}",
+          path: "attachments/#{index}-#{File.basename(attachment.source_path)}"
+        }
+      end
+    end
+
+    private
+
+    def run_hash
+      {
+        "started_at" => @run.started_at&.utc&.iso8601,
+        "finished_at" => @run.finished_at&.utc&.iso8601,
+        "ci" => @run.ci,
+        "git" => @run.git,
+        "environment" => @run.environment
+      }.compact
+    end
+
+    def result_hash(result)
+      hash = {
+        "identifier" => result.identifier,
+        "full_name" => result.full_name,
+        "file_path" => result.file_path,
+        "line_number" => result.line_number,
+        "status" => result.status,
+        "duration_ms" => result.duration_ms,
+        "attempts" => result.attempts,
+        "tags" => result.tags
+      }
+      hash["failure"] = failure_hash(result.failure) if result.failure
+      hash
+    end
+
+    def failure_hash(failure)
+      {
+        "message" => failure.message,
+        "exception_class" => failure.exception_class,
+        "backtrace" => failure.backtrace
+      }
+    end
+
+    def attachment_hash(entry, mode)
+      ref = mode == :local ? { "path" => entry[:path] } : { "part" => entry[:part] }
+      { "name" => entry[:attachment].name, "content_type" => entry[:attachment].content_type }.merge(ref)
+    end
+  end
+end

data/lib/raider_reporter/rspec/formatter.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "raider_reporter"
+
+module RaiderReporter
+  module RSpec
+    # Translates RSpec notifications into Collector calls. Every hook is guarded:
+    # a reporting bug must never fail or crash the user's suite.
+    class Formatter
+      ::RSpec::Core::Formatters.register self,
+                                         :start, :example_started, :example_passed,
+                                         :example_failed, :example_pending, :close
+
+      NON_TAG_KEYS = %i[pending skip].freeze
+      MAX_MESSAGE = 10_000
+      MAX_BACKTRACE = 50
+
+      def initialize(output)
+        @output = output
+        @collector = RaiderReporter.start_collector!
+      end
+
+      def start(_notification)
+        guard { @collector.start_run }
+      end
+
+      def example_started(_notification)
+        guard { @collector.start_test }
+      end
+
+      def example_passed(notification)
+        guard { record(notification.example, "passed") }
+      end
+
+      def example_failed(notification)
+        guard { record(notification.example, "failed") }
+      end
+
+      def example_pending(notification)
+        guard do
+          example = notification.example
+          record(example, example.metadata[:skip] ? "skipped" : "pending")
+        end
+      end
+
+      def close(_notification)
+        guard { RaiderReporter.finish!(@output) }
+      end
+
+      private
+
+      def record(example, status)
+        metadata = example.metadata
+        execution = example.execution_result
+        @collector.finish_test(
+          identifier: example.id,
+          full_name: utf8(example.full_description),
+          file_path: metadata[:file_path].to_s.delete_prefix("./"),
+          line_number: metadata[:line_number],
+          status: status,
+          duration_ms: ((execution.run_time || 0) * 1000).round,
+          attempts: metadata.fetch(:retry_attempts, 0).to_i + 1,
+          tags: metadata.select { |key, value| value == true && !NON_TAG_KEYS.include?(key) }.keys.map(&:to_s).sort,
+          failure: status == "failed" ? failure_for(execution.exception) : nil
+        )
+      end
+
+      def failure_for(exception)
+        return nil unless exception
+
+        backtrace = ::RSpec.configuration.backtrace_formatter.format_backtrace(exception.backtrace || [])
+        Failure.new(
+          message: utf8(exception.message)[0, MAX_MESSAGE],
+          exception_class: utf8(exception.class.name),
+          backtrace: backtrace.first(MAX_BACKTRACE).map { |line| utf8(line) }
+        )
+      end
+
+      # JSON generation raises on invalid UTF-8, which would lose the whole run.
+      def utf8(value)
+        str = value.to_s
+        if [Encoding::UTF_8, Encoding::BINARY, Encoding::US_ASCII].include?(str.encoding)
+          str.dup.force_encoding(Encoding::UTF_8).scrub("?")
+        else
+          str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+        end
+      end
+
+      def guard
+        yield
+      rescue StandardError => e
+        RaiderReporter.warn("#{e.class}: #{e.message}")
+      end
+    end
+  end
+end

data/lib/raider_reporter/rspec.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "raider_reporter"
+require "raider_reporter/rspec/formatter"

data/lib/raider_reporter/version.rb

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

data/lib/raider_reporter/writers/local.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module RaiderReporter
+  module Writers
+    class Local
+      def initialize(config)
+        @config = config
+      end
+
+      def write(payload)
+        dir = File.expand_path(@config.output_dir)
+        clean(dir) if @config.clean_output_dir
+        FileUtils.mkdir_p(File.join(dir, "attachments"))
+        payload.attachment_entries.each do |entry|
+          FileUtils.cp(entry[:attachment].source_path, File.join(dir, entry[:path]))
+        end
+        run_json = File.join(dir, "run.json")
+        File.write(run_json, JSON.pretty_generate(payload.to_h(mode: :local)))
+        run_json
+      end
+
+      private
+
+      # Remove only what this writer creates, so output_dir "." or "spec" is safe.
+      def clean(dir)
+        FileUtils.rm_f(File.join(dir, "run.json"))
+        FileUtils.rm_rf(File.join(dir, "attachments"))
+      end
+    end
+  end
+end

data/lib/raider_reporter/writers/uploader.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "securerandom"
+
+module RaiderReporter
+  module Writers
+    class Uploader
+      Result = Data.define(:ok, :url, :run_id, :error)
+      # Keeps uploads under the server's 50 MB request limit and multipart part limit.
+      MAX_UPLOAD_ATTACHMENT_BYTES = 45 * 1024 * 1024
+      MAX_UPLOAD_ATTACHMENTS = 1000
+
+      def initialize(config, timeout: 30, warn: RaiderReporter.method(:warn))
+        @config = config
+        @timeout = timeout
+        @warn = warn
+      end
+
+      def upload(payload)
+        uri = runs_uri
+        payload = within_budget(payload)
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = "Bearer #{@config.token}"
+        request["User-Agent"] = "raider_reporter/#{VERSION}"
+        boundary = "----raider#{SecureRandom.hex(12)}"
+        body = "".b
+        add_field(body, boundary, "payload", JSON.generate(payload.to_h(mode: :upload)))
+        payload.attachment_entries.each do |entry|
+          add_file(body, boundary, entry[:part], entry[:attachment])
+        end
+        body << "--#{boundary}--\r\n".b
+        request.body = body
+        request["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                                       open_timeout: @timeout, read_timeout: @timeout,
+                                                       write_timeout: @timeout) do |http|
+          http.request(request)
+        end
+        to_result(response)
+      rescue StandardError => e
+        Result.new(ok: false, url: nil, run_id: nil, error: "#{e.class}: #{e.message}")
+      end
+
+      private
+
+      # Keeps the leading attachments that fit the byte and count budget and
+      # rebuilds the payload without the rest, so part names stay contiguous.
+      # The local run.json is written from the original payload and keeps all.
+      def within_budget(payload)
+        entries = payload.attachment_entries
+        bytes = 0
+        keep = entries.index do |entry|
+          bytes += File.size?(entry[:attachment].source_path).to_i
+          bytes > MAX_UPLOAD_ATTACHMENT_BYTES
+        end || entries.size
+        keep = [keep, MAX_UPLOAD_ATTACHMENTS].min
+        return payload if keep == entries.size
+
+        dropped = entries.size - keep
+        @warn.call("not uploading #{dropped} #{dropped == 1 ? 'attachment' : 'attachments'}: over the upload " \
+                   "budget of #{MAX_UPLOAD_ATTACHMENT_BYTES / (1024 * 1024)} MB / " \
+                   "#{MAX_UPLOAD_ATTACHMENTS} files; they remain in #{@config.output_dir}")
+        seen = 0
+        run = payload.run
+        Payload.new(run.with(results: run.results.map do |result|
+          result.with(attachments: result.attachments.select { (seen += 1) <= keep })
+        end))
+      end
+
+      def add_field(body, boundary, name, value)
+        body << "--#{boundary}\r\nContent-Disposition: form-data; name=\"#{name}\"\r\n\r\n".b
+        body << value.to_s.b << "\r\n".b
+      end
+
+      def add_file(body, boundary, name, attachment)
+        filename = File.basename(attachment.source_path).gsub(/[^\w.\-]/, "_")
+        body << ("--#{boundary}\r\nContent-Disposition: form-data; name=\"#{name}\"; filename=\"#{filename}\"\r\n" \
+                 "Content-Type: #{attachment.content_type}\r\n\r\n").b
+        body << File.binread(attachment.source_path) << "\r\n".b
+      end
+
+      def runs_uri
+        uri = URI.parse(@config.endpoint.to_s.strip.chomp("/") + "/api/v1/runs")
+        raise ArgumentError, "RAIDER_ENDPOINT must start with http:// or https://" unless uri.is_a?(URI::HTTP)
+
+        uri
+      end
+
+      def to_result(response)
+        if response.is_a?(Net::HTTPSuccess)
+          body = parse_body(response.body)
+          Result.new(ok: true, url: present(body["url"]), run_id: present(body["run_id"]), error: nil)
+        else
+          Result.new(ok: false, url: nil, run_id: nil, error: "HTTP #{response.code}: #{response.body.to_s[0, 200]}")
+        end
+      end
+
+      def parse_body(text)
+        parsed = JSON.parse(text.to_s)
+        parsed.is_a?(Hash) ? parsed : {}
+      rescue JSON::ParserError
+        {}
+      end
+
+      def present(value)
+        value.nil? || value.to_s.strip.empty? ? nil : value
+      end
+    end
+  end
+end

data/lib/raider_reporter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "time"
+require "rbconfig"
+require_relative "raider_reporter/version"
+require_relative "raider_reporter/models"
+require_relative "raider_reporter/payload"
+require_relative "raider_reporter/configuration"
+require_relative "raider_reporter/content_types"
+require_relative "raider_reporter/collector"
+require_relative "raider_reporter/writers/local"
+require_relative "raider_reporter/ci_detector"
+require_relative "raider_reporter/writers/uploader"
+
+module RaiderReporter
+  class << self
+    attr_reader :collector
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reset!
+      @collector&.cleanup
+      @configuration = nil
+      @collector = nil
+    end
+
+    def start_collector!
+      @collector = Collector.new(
+        max_attachment_bytes: configuration.max_attachment_bytes,
+        warn: ->(message) { warn(message) }
+      )
+    end
+
+    def attach(name, path, type: nil)
+      unless collector&.in_test?
+        warn("attach(#{name.inspect}) called outside a running example; ignored")
+        return false
+      end
+      unless File.file?(path.to_s)
+        warn("attach(#{name.inspect}): file #{path} not found; ignored")
+        return false
+      end
+
+      limit = configuration.max_attachment_bytes
+      if File.size(path.to_s) > limit
+        warn("attach(#{name.inspect}): file #{path} is larger than #{limit} bytes; ignored")
+        return false
+      end
+
+      collector.attach(Attachment.new(name: name.to_s, source_path: collector.stage(path.to_s),
+                                      content_type: ContentTypes.resolve(type, path)))
+    rescue StandardError => e
+      warn("attach(#{name.inspect}) failed: #{e.class}: #{e.message}")
+      false
+    end
+
+    def warn(message)
+      # $stderr.puts, not Kernel.warn: -W0 must not silence reporting problems.
+      $stderr.puts("[raider_reporter] #{message}")
+    end
+
+    def finish!(output = $stdout)
+      return nil if dry_run?
+
+      detector = CiDetector.new
+      run = collector.finish_run(ci: detector.ci, git: detector.git, environment: default_environment)
+      payload = Payload.new(run)
+      begin
+        Writers::Local.new(configuration).write(payload)
+      rescue StandardError => e
+        warn("could not write #{configuration.output_dir}: #{e.class}: #{e.message}")
+      end
+      return nil unless configuration.upload?
+
+      result = Writers::Uploader.new(configuration).upload(payload)
+      if result.ok
+        output.puts(success_line(result))
+      else
+        warn("upload failed: #{result.error}")
+      end
+      nil
+    ensure
+      collector&.cleanup
+    end
+
+    private
+
+    def success_line(result)
+      return "Raider report: #{result.url}" if result.url
+      return "Raider report uploaded (run #{result.run_id})" if result.run_id
+
+      "Raider report uploaded"
+    end
+
+    # `rspec --dry-run` reports every example as passed without running it.
+    def dry_run?
+      defined?(::RSpec.configuration) && ::RSpec.configuration.respond_to?(:dry_run?) &&
+        ::RSpec.configuration.dry_run?
+    end
+
+    def default_environment
+      { "ruby" => RUBY_VERSION, "os" => RbConfig::CONFIG["host_os"] }
+        .merge((configuration.environment || {}).transform_keys(&:to_s))
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: raider_reporter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Augustin Gottlieb
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: RSpec formatter that records results, screenshots and videos in the Raider
+  schema, writes them locally, and optionally uploads them to a Raider server.
+email:
+- 33221555+aguspe@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/raider_reporter.rb
+- lib/raider_reporter/ci_detector.rb
+- lib/raider_reporter/collector.rb
+- lib/raider_reporter/configuration.rb
+- lib/raider_reporter/content_types.rb
+- lib/raider_reporter/models.rb
+- lib/raider_reporter/payload.rb
+- lib/raider_reporter/rspec.rb
+- lib/raider_reporter/rspec/formatter.rb
+- lib/raider_reporter/version.rb
+- lib/raider_reporter/writers/local.rb
+- lib/raider_reporter/writers/uploader.rb
+homepage: https://github.com/RaiderHQ/raider_reporter
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/RaiderHQ/raider_reporter
+  changelog_uri: https://github.com/RaiderHQ/raider_reporter/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: 'Test reporting for Ruby Raider: local run.json and Raider uploads'
+test_files: []