raider_reporter 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4d38649c7323d93145079d6de1aac3a00f4724a0d906a2f004ddf331e201b77
-  data.tar.gz: 8f5ad9717d74c2c626ba0ab7507e2ebc413f9f80337d0ecfd02343c69bc52051
+  metadata.gz: bcf65fcd172398a1040a5b15c3bff03150bde91ea1c80ddb9cb1a2ca731f1496
+  data.tar.gz: bfdaf38608619f2831d108b0a170a0da7aa8aa7eb65a1cf8d0b42703e44c58ad
 SHA512:
-  metadata.gz: d43a79f1ff81eff80f4fa8a9afbff388df98671e65920013b88cdb8cdd24ab3313266646e27e72bbebfbad4213231855c6d7470c28177ba601d0db1ddb1aea76
-  data.tar.gz: 61cd6025ab3d9c713fb075d5288eec3ce46c219eb317995129a6bc41fa139ecccf4026eca160cafeeeae0f25f8d4da290c9e661429cb1f21e8ad8520da007c94
+  metadata.gz: c635eb065857b147b25758e304e9a2efdf9e5885bfc1767beac062b3b9ea1dd6e344ca3463265f70f78ebb2ae3aca3f1388f8ed6f27bf425b8692e9eb846ed34
+  data.tar.gz: 8851d8bf5aa69eda7d96f42f6b8a72c893ba306fd82906b66dda19ab21dba0d8c122de1be2df94106454db4e27b1fbef06e6d8a8d4a659509763c2b4b53bee72

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.5.0 — 2026-10-12
+
+- Add Azure Pipelines support: detect the build (`provider: azure_pipelines`, build URL, attempt, job, branch, commit), report Azure Repos pull requests in `run.git.pr`, and derive a stable id-based build key. `strategy: parallel` jobs are detected as shards of one build
+- `raider-reporter comment` now works on Azure Pipelines: it creates or updates one tagged comment thread on the pull request (closed when the build passed) and sets a `raider/tests` PR status. Uses `System.AccessToken` with the PR statuses API version 7.1; the build service needs "Contribute to pull requests" on the repository. GitHub-hosted repositories built by Azure Pipelines are skipped with a notice
+- Schema v1, additive: optional `run.git.pr.url` (set by GitHub Actions and Azure Pipelines)
+- Unexpanded Azure macros such as `$(RAIDER_TOKEN)` or `$(System.AccessToken)` are treated as missing instead of being sent as a token
+- Fix: redact the token before truncating error bodies in the GitHub and Azure clients, so a token straddling the 200-character cut can no longer leak partially
+- Notices: the missing-permission notice uses `<project>` when the project name is unknown, and the success notice prints `PR #<n>` when the PR URL is unknown
+- `raider-reporter comment` now runs only on GitHub Actions (`GITHUB_ACTIONS=true`) or Azure Pipelines; elsewhere it prints `skipped: unsupported CI` and exits 0
+- No breaking changes
+
+## 0.4.0 — 2026-10-11
+
+- Add a Cucumber reporter (Cucumber >= 9, < 12; not a gem dependency). `require "raider_reporter/cucumber"` from `features/support/` registers it in plugin mode (recommended, works with any `--format` and no `--out`); `--format RaiderReporter::Cucumber::Formatter --out <file>` also works. Using both registers one listener
+- Identity: `file_path` is project-relative (`features/login.feature`), `full_name` is `"<Feature>: <Scenario>"` (outline rows add `(<Examples name>, row <n>)`; when several Examples tables share a label, each is numbered: `(Examples 1, row 1)`, `(Examples 2, row 1)`), `identifier` is `<file>:<line>`
+- Report the failing step (or Before/After hook) with its location in the failure message; ambiguous maps to failed, undefined to pending
+- Retries: only the final attempt is kept, with `attempts` set and earlier attachments dropped
+- Attachments: `RaiderReporter.attach` and Cucumber's `attach(path, media_type)` with an existing file path are captured; inline data and `log` messages are ignored
+- Dry runs (`cucumber --dry-run`) write and upload nothing; `parallel_tests` shards write `run-<n>.json`
+- No breaking changes: RSpec behaviour is unchanged
+
 ## 0.3.0 — 2026-10-11
 
 - Report pull request identity: `run.ci.repository`, `run.git.default_branch` and `run.git.pr` (number, base/head branch, head SHA) on `pull_request` and `pull_request_target` events. Requires a Raider server that accepts `git.pr`

data/README.md

@@ -1,6 +1,6 @@
 # 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.
+Raider-schema test reporting for RSpec and Cucumber. `raider_reporter` is an RSpec formatter and a Cucumber reporter 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.
 
@@ -26,7 +26,80 @@ Enable the formatter in `.rspec`:
 --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.
+Run `bundle exec rspec` as usual. (For Cucumber, see [Cucumber](#cucumber).) Results land in `raider-results/run.json`. A dry run (`rspec --dry-run`) writes and uploads nothing.
+
+## Cucumber
+
+Requirements: Cucumber 9, 10 or 11 in your own Gemfile (`gem "cucumber"`). It is not a dependency of this gem; requiring `raider_reporter/cucumber` without Cucumber raises a `LoadError` that says so. Cucumber 9.2.1 on Ruby 4 also needs `gem "logger"` in your Gemfile, because Cucumber requires it without declaring it.
+
+### Plugin mode (recommended)
+
+Require the reporter from a file under `features/support/`, for example `features/support/raider.rb`:
+
+```ruby
+require "raider_reporter/cucumber"
+```
+
+Then run Cucumber with any normal formatter and no `--out`:
+
+```
+# cucumber.yml
+default: --format pretty
+```
+
+The require registers one listener on Cucumber's event bus, so it sits next to `pretty`, `progress` or any other formatter. Results land in `raider-results/run.json`, and a dry run (`cucumber --dry-run`) writes and uploads nothing. Plugin mode registers once per Ruby process, because `require` is cached: a second in-process `Cucumber::Cli::Main` run in the same process does not register again.
+
+### Formatter mode
+
+You can also name the formatter explicitly:
+
+```
+cucumber --format pretty --format RaiderReporter::Cucumber::Formatter --out raider-results/cucumber.log
+```
+
+`--out` is required here. Cucumber rejects a second formatter on the same output stream ("All but one formatter must use --out", also in 9.2.1), and this formatter writes nothing to its stream, so give it any file path (it is never created). If both modes are active, only one listener is registered.
+
+### How tests are identified
+
+- `file_path` is relative to the project root (`features/login.feature`), even when Cucumber is given `./features/login.feature` or an absolute path.
+- `full_name` is `"<Feature name>: <Scenario name>"`. Scenario Outline rows are `"<Feature name>: <Scenario name> (<Examples name or 'Examples'>, row <n>)"`, where `n` is the 1-based data row of that Examples table. When two or more Examples tables of one outline share a label (for example two unnamed ones), every table with that label is numbered by its position among them, `(Examples 1, row 1)`, `(Examples 2, row 1)`, so each row keeps a distinct name; tables with a unique label are unchanged.
+- `identifier` is `"<file_path>:<line>"`: the scenario line, or the Examples row line for outline rows.
+- `tags` are the feature, scenario and Examples tags, merged, sorted, unique, without `@`.
+
+Statuses: passed, failed and ambiguous (reported as failed), pending and undefined (reported as pending), skipped.
+
+### Failures
+
+A failed test reports the step that failed, not the whole scenario:
+
+```
+When I fail on purpose (features/login.feature:9)
+
+expected 5, got 4
+```
+
+A failing `Before` or `After` hook is named `Before hook` or `After hook` in place of the step, so an `After` hook that raises after every step passed is still a failed test. Messages are capped at 10,000 characters and backtraces at 50 lines.
+
+### Retries
+
+With `--retry n`, only the final attempt of each scenario is reported, and `attempts` is the number of attempts. Each attempt starts with fresh attachments; attachments from earlier attempts are dropped.
+
+### Attachments
+
+Both of these are captured while a scenario runs:
+
+```ruby
+After do |scenario|
+  attach(path, "image/png") if scenario.failed?        # Cucumber's own attach, with an existing file path (a Pathname works too)
+  RaiderReporter.attach("screenshot", path, type: :png) # or the Raider helper, as in RSpec
+end
+```
+
+Cucumber's `attach` is captured only when given the path of an existing file. Inline data (`attach("some text", "text/plain")`) and `log` messages are ignored.
+
+### Parallel runs with Cucumber
+
+`parallel_tests` works with no configuration for Cucumber too: each process writes `run-<n>.json`. See [Parallel runs](#parallel-runs).
 
 ## Attaching screenshots and videos
 
@@ -122,6 +195,49 @@ On pull requests, `raider-reporter comment` posts one comment with the build's r
 - The command never fails your CI: it always exits 0 and prints notices to stderr, prefixed `[raider_reporter]`. It needs `GITHUB_TOKEN`, `GITHUB_REPOSITORY`, `GITHUB_EVENT_PATH`, `RAIDER_TOKEN` and `RAIDER_ENDPOINT`; if one is missing, or the event is not a pull request, it does nothing.
 - It requires a Raider server that supports the summary endpoint and the `git.pr` field. Upgrade the server before using it.
 
+## Azure Pipelines
+
+The gem detects Azure Pipelines when `TF_BUILD` is `true`. It reports the build (`provider: azure_pipelines`, build URL, attempt, job), the branch and commit, the pull request and a build key, so shards of one build group together. On a pull request from Azure Repos, `raider-reporter comment` posts one comment thread with the results and sets a `raider/tests` status on the PR.
+
+```yaml
+jobs:
+  - job: tests
+    steps:
+      - task: UseRubyVersion@0
+        inputs: { versionSpec: '3.4' }
+      - script: bundle install
+        displayName: Install gems
+      - script: bundle exec rspec spec/ --format documentation
+        displayName: Run tests
+        env:
+          RAIDER_TOKEN: $(RAIDER_TOKEN)
+          RAIDER_ENDPOINT: $(RAIDER_ENDPOINT)
+      - task: PublishPipelineArtifact@1
+        condition: always()
+        inputs: { targetPath: raider-results, artifact: raider-results }
+  - job: raider_comment
+    dependsOn: tests
+    condition: and(always(), eq(variables['Build.Reason'], 'PullRequest'))
+    steps:
+      - task: UseRubyVersion@0
+        inputs: { versionSpec: '3.4' }
+      - script: bundle install
+      - script: bundle exec raider-reporter comment
+        displayName: Comment Raider results on the pull request
+        env:
+          RAIDER_TOKEN: $(RAIDER_TOKEN)
+          RAIDER_ENDPOINT: $(RAIDER_ENDPOINT)
+          SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+```
+
+- **One-time grant:** give "Contribute to pull requests" to `<Project> Build Service (<org>)` on the repository (Project settings > Repositories > Security). Without it the command prints a notice naming the exact identity and exits 0.
+- **Map secrets explicitly:** Azure does not expose secret variables to scripts automatically. Map `RAIDER_TOKEN` and `System.AccessToken` with `env:` as shown. If a mapped variable is undefined, Azure passes the literal `$(...)`; the gem treats it as missing: results are still written locally but not uploaded, and `raider-reporter comment` prints a skip notice.
+- **Pull request builds:** for Azure Repos, YAML `pr:` triggers are ignored. PR builds (and therefore the comment job) run only when the pipeline is added as a **Build validation** branch policy on the target branch.
+- **Same stage:** keep the comment job in the same stage as the test jobs; the build key includes `System.StageAttempt`.
+- **Azure Repos only:** the PR comment works for repositories hosted in Azure Repos. A GitHub-hosted repository built by Azure Pipelines still uploads results, but `comment` prints `skipped: not an Azure Repos pull request`.
+- **Parallel jobs:** `strategy: parallel: N` shards are detected automatically and grouped into one build, like GitHub matrix jobs.
+- The command never fails your pipeline: it always exits 0 and prints notices to stderr, prefixed `[raider_reporter]`. It needs `SYSTEM_ACCESSTOKEN`, `RAIDER_TOKEN` and `RAIDER_ENDPOINT`, and requires a Raider server that supports the summary endpoint.
+
 ## Parallel runs
 
 When a suite is split across several processes or CI jobs, each one uploads its own run. Raider groups runs of the same CI build, so the shards show up together as one build. Each run records its shard (`index`, `total` and a `label`) and, on GitHub Actions, a build key made from the repository, run id and run attempt. A re-run attempt of a workflow is a separate build.
@@ -183,6 +299,7 @@ Tip: run `rm -rf raider-results` before a parallel run. Each process only cleans
 ## 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/cucumber_basic` is the same for Cucumber (plugin mode): a passing scenario, a failing one with an attachment, and an outline. Run it with `cd examples/cucumber_basic && bundle install && bundle exec cucumber`; the failure is deliberate.
 - `examples/github_actions.yml` shows the workflow steps for CI.
 
 ## Schema
@@ -191,7 +308,7 @@ Tip: run `rm -rf raider-results` before a parallel run. Each process only cleans
 
 ## 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.
+Bug reports and pull requests are welcome at https://github.com/RaiderHQ/raider_reporter. Run `bundle install && bundle exec rake` to run the specs. To test against another Cucumber, set `CUCUMBER_VERSION` (for example `CUCUMBER_VERSION="~> 9.0" bundle update cucumber && bundle exec rspec`).
 
 ## License
 

data/lib/raider_reporter/azure_env.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RaiderReporter
+  # Reads Azure Pipelines variables. An undefined macro is left literal by Azure
+  # ("$(System.AccessToken)"), so such values count as missing.
+  module AzureEnv
+    MACRO = /\A\$\(.+\)\z/
+
+    module_function
+
+    def value(env, name)
+      raw = env[name].to_s.strip
+      raw.empty? || raw.match?(MACRO) ? nil : raw
+    end
+
+    def azure?(env)
+      env["GITHUB_ACTIONS"] != "true" && value(env, "TF_BUILD")&.casecmp?("true") == true
+    end
+
+    def collection_base(env)
+      uri = value(env, "SYSTEM_COLLECTIONURI")
+      uri && "#{uri.sub(%r{/+\z}, '')}/"
+    end
+
+    def azure_repos_pr?(env)
+      value(env, "BUILD_REASON") == "PullRequest" && value(env, "BUILD_REPOSITORY_PROVIDER") == "TfsGit"
+    end
+
+    def strip_heads(ref)
+      return nil if ref.nil?
+      return ref.delete_prefix("refs/heads/") if ref.start_with?("refs/heads/")
+
+      ref.start_with?("refs/") ? nil : ref
+    end
+  end
+end

data/lib/raider_reporter/ci_detector.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "erb"
 require "open3"
+require "raider_reporter/azure_env"
 require "raider_reporter/github_event"
 
 module RaiderReporter
@@ -14,6 +16,7 @@ module RaiderReporter
     end
 
     def ci
+      return azure_ci if AzureEnv.azure?(@env)
       return nil unless @env["GITHUB_ACTIONS"] == "true"
 
       run_id = @env["GITHUB_RUN_ID"]
@@ -38,6 +41,40 @@ module RaiderReporter
 
     private
 
+    def azure_ci
+      v = ->(name) { AzureEnv.value(@env, name) }
+      base = AzureEnv.collection_base(@env)
+      project = v.("SYSTEM_TEAMPROJECT")
+      build_id = v.("BUILD_BUILDID")
+      attempt = v.("SYSTEM_STAGEATTEMPT") || "1"
+      build_url = ("#{base}#{ERB::Util.url_encode(project)}/_build/results?buildId=#{build_id}" if base && project && build_id)
+      ids = [base&.sub(%r{\Ahttps?://}i, "")&.chomp("/"), v.("SYSTEM_TEAMPROJECTID"), v.("BUILD_REPOSITORY_ID")]
+      build_key = ("azure_pipelines:#{ids.join('/')}:#{build_id}:#{attempt}" if ids.all? && build_id)
+      repo = v.("BUILD_REPOSITORY_NAME")
+      { "provider" => "azure_pipelines", "build_url" => build_url, "build_id" => build_id, "attempt" => attempt,
+        "job" => v.("SYSTEM_JOBDISPLAYNAME"), "build_key" => build_key,
+        "repository" => (project && repo ? "#{project}/#{repo}" : nil) }.compact
+    end
+
+    def azure_pull_request
+      return nil unless AzureEnv.azure_repos_pr?(@env)
+
+      v = ->(name) { AzureEnv.value(@env, name) }
+      number = Integer(v.("SYSTEM_PULLREQUEST_PULLREQUESTID").to_s, exception: false)
+      base = AzureEnv.strip_heads(v.("SYSTEM_PULLREQUEST_TARGETBRANCH"))
+      head = AzureEnv.strip_heads(v.("SYSTEM_PULLREQUEST_SOURCEBRANCH"))
+      sha = v.("SYSTEM_PULLREQUEST_SOURCECOMMITID")
+      return nil unless number&.positive? && [base, head, sha].all? { |s| s.is_a?(String) && !s.empty? }
+
+      collection = AzureEnv.collection_base(@env)
+      project = v.("SYSTEM_TEAMPROJECT")
+      repo = v.("BUILD_REPOSITORY_NAME")
+      url = if collection && project && repo
+              "#{collection}#{ERB::Util.url_encode(project)}/_git/#{ERB::Util.url_encode(repo)}/pullrequest/#{number}"
+            end
+      { "number" => number, "base_branch" => base, "head_branch" => head, "head_sha" => sha, "url" => url }.compact
+    end
+
     def event
       return @event if defined?(@event)
 
@@ -57,6 +94,7 @@ module RaiderReporter
     end
 
     def pull_request
+      return azure_pull_request if AzureEnv.azure?(@env)
       return nil unless event && PR_EVENTS.include?(@env["GITHUB_EVENT_NAME"])
 
       pr = event["pull_request"]
@@ -69,7 +107,10 @@ module RaiderReporter
       return nil unless number.is_a?(Integer) && number >= 1
       return nil unless [base, head, sha].all? { |v| v.is_a?(String) && !v.empty? }
 
-      { "number" => number, "base_branch" => base, "head_branch" => head, "head_sha" => sha }
+      server = @env["GITHUB_SERVER_URL"].to_s
+      repo = @env["GITHUB_REPOSITORY"].to_s
+      url = ("#{server}/#{repo}/pull/#{number}" unless server.empty? || repo.empty?)
+      { "number" => number, "base_branch" => base, "head_branch" => head, "head_sha" => sha, "url" => url }.compact
     rescue StandardError
       nil
     end
@@ -88,6 +129,8 @@ module RaiderReporter
     end
 
     def branch
+      return azure_branch if AzureEnv.azure?(@env)
+
       head_ref = @env["GITHUB_HEAD_REF"].to_s
       return head_ref unless head_ref.empty?
 
@@ -97,7 +140,18 @@ module RaiderReporter
       local == "HEAD" ? nil : local # "HEAD" means detached, not a branch name
     end
 
+    def azure_branch
+      pr = pull_request
+      name = pr ? pr["head_branch"] : AzureEnv.strip_heads(AzureEnv.value(@env, "BUILD_SOURCEBRANCH"))
+      return name if name
+
+      local = @git.call("rev-parse", "--abbrev-ref", "HEAD")
+      local == "HEAD" ? nil : local
+    end
+
     def sha
+      return AzureEnv.value(@env, "BUILD_SOURCEVERSION") || @git.call("rev-parse", "HEAD") if AzureEnv.azure?(@env)
+
       @env["GITHUB_SHA"] || @git.call("rev-parse", "HEAD")
     end
 

data/lib/raider_reporter/cli.rb

@@ -8,7 +8,13 @@ module RaiderReporter
   class CLI
     MARKER = "<!-- raider-reporter:build-comment -->"
     CONTEXT = "raider/tests"
-    REQUIRED_ENV = %w[GITHUB_TOKEN GITHUB_REPOSITORY GITHUB_EVENT_PATH RAIDER_TOKEN RAIDER_ENDPOINT].freeze
+    GITHUB_REQUIRED_ENV = %w[GITHUB_TOKEN GITHUB_REPOSITORY GITHUB_EVENT_PATH RAIDER_TOKEN RAIDER_ENDPOINT].freeze
+    REQUIRED_ENV = GITHUB_REQUIRED_ENV
+    AZURE_REQUIRED_ENV = %w[SYSTEM_ACCESSTOKEN SYSTEM_COLLECTIONURI SYSTEM_TEAMPROJECTID BUILD_REPOSITORY_ID
+                            RAIDER_TOKEN RAIDER_ENDPOINT].freeze
+    THREAD_STATUS = { "passed" => "closed" }.freeze
+    AZURE_STATES = { "passed" => "succeeded", "failed" => "failed", "incomplete" => "pending" }.freeze
+    TOKEN_HINT = "map it with env: SYSTEM_ACCESSTOKEN: $(System.AccessToken)"
     STATUS_STATES = { "passed" => "success", "failed" => "failure", "incomplete" => "pending" }.freeze
     FALLBACK_DESCRIPTIONS = {
       "passed" => "Raider: tests passed",
@@ -19,10 +25,14 @@ module RaiderReporter
     USAGE = <<~TEXT
       Usage: raider-reporter comment
 
-      Posts (or updates) the Raider build summary as a comment on the current pull request
-      and sets the "#{CONTEXT}" commit status. Intended for GitHub Actions; always exits 0.
+      Posts (or updates) the Raider build summary on the current pull request and sets a status.
+      Intended for GitHub Actions and Azure Pipelines (Azure Repos); always exits 0.
 
-      Environment: #{REQUIRED_ENV.join(', ')} (GITHUB_API_URL optional).
+      GitHub Actions: comment + "#{CONTEXT}" commit status.
+        Environment: #{GITHUB_REQUIRED_ENV.join(', ')} (GITHUB_API_URL optional).
+      Azure Pipelines: one PR thread updated in place + a "raider/tests" PR status.
+        Environment: #{AZURE_REQUIRED_ENV.join(', ')}.
+        Map the token in the pipeline: env: SYSTEM_ACCESSTOKEN: $(System.AccessToken)
     TEXT
 
     def initialize(argv, env: ENV, out: $stdout, err: $stderr)
@@ -48,7 +58,17 @@ module RaiderReporter
     private
 
     def comment
-      missing = REQUIRED_ENV.select { |name| @env[name].to_s.strip.empty? }
+      if @env["GITHUB_ACTIONS"] == "true"
+        github_comment
+      elsif AzureEnv.azure?(@env)
+        azure_comment
+      else
+        notice("skipped: unsupported CI")
+      end
+    end
+
+    def github_comment
+      missing = GITHUB_REQUIRED_ENV.select { |name| @env[name].to_s.strip.empty? }
       return notice("skipped: missing #{missing.join(', ')}") unless missing.empty?
 
       event = GithubEvent.load(@env)
@@ -66,6 +86,61 @@ module RaiderReporter
       notice("comment failed: #{e.class}: #{e.message}")
     end
 
+    def azure_comment
+      missing = AZURE_REQUIRED_ENV.select { |name| AzureEnv.value(@env, name).nil? }
+      return notice(azure_missing_message(missing)) unless missing.empty?
+
+      detector = CiDetector.new(env: @env, git: ->(*) {})
+      pr = detector.git&.dig("pr")
+      return notice("skipped: not an Azure Repos pull request") unless pr
+
+      build_key = detector.ci&.dig("build_key")
+      return notice("skipped: could not determine the build key") unless build_key
+
+      publish_azure(pr, build_key)
+    rescue Comment::AzureClient::Forbidden
+      notice(azure_forbidden_message)
+    rescue StandardError => e
+      notice("comment failed: #{e.class}: #{e.message}")
+    end
+
+    def azure_missing_message(missing)
+      message = "skipped: missing #{missing.join(', ')}"
+      message += "; #{TOKEN_HINT}" if missing.include?("SYSTEM_ACCESSTOKEN")
+      message
+    end
+
+    def publish_azure(pr, build_key)
+      summaries = Comment::SummaryClient.new(endpoint: AzureEnv.value(@env, "RAIDER_ENDPOINT"),
+                                             token: AzureEnv.value(@env, "RAIDER_TOKEN"))
+      summary = summaries.fetch(build_key)
+      return notice("summary unavailable: #{summaries.last_error}") unless summary
+
+      azure = Comment::AzureClient.new(token: AzureEnv.value(@env, "SYSTEM_ACCESSTOKEN"), base_url: azure_pr_url(pr))
+      result = azure.upsert_thread(summary.markdown, MARKER, status: THREAD_STATUS.fetch(summary.state, "active"))
+      azure.set_status(state: AZURE_STATES.fetch(summary.state, "pending"), description: description(summary),
+                       target_url: summary.url)
+      notice("PR thread #{result}: #{pr['url'] || "PR ##{pr['number']}"}")
+    end
+
+    def azure_pr_url(pr)
+      "#{AzureEnv.collection_base(@env)}#{AzureEnv.value(@env, 'SYSTEM_TEAMPROJECTID')}/_apis/git/repositories/" \
+        "#{AzureEnv.value(@env, 'BUILD_REPOSITORY_ID')}/pullRequests/#{pr['number']}"
+    end
+
+    def azure_forbidden_message
+      project = AzureEnv.value(@env, "SYSTEM_TEAMPROJECT") || "<project>"
+      "skipped: the build service cannot write to this PR — grant \"Contribute to pull requests\" to " \
+        "\"#{project} Build Service (#{azure_org})\""
+    end
+
+    def azure_org
+      uri = URI.parse(AzureEnv.collection_base(@env).to_s)
+      uri.host.to_s.end_with?("visualstudio.com") ? uri.host.split(".").first : uri.path.split("/").reject(&:empty?).first
+    rescue URI::InvalidURIError
+      nil
+    end
+
     def publish(pr, build_key)
       summaries = Comment::SummaryClient.new(endpoint: @env["RAIDER_ENDPOINT"], token: @env["RAIDER_TOKEN"])
       summary = summaries.fetch(build_key)

data/lib/raider_reporter/collector.rb

@@ -55,8 +55,18 @@ module RaiderReporter
     end
 
     def finish_test(**fields)
+      add_result(build_test(**fields))
+    end
+
+    # Closes the current test and returns its result without recording it, so a
+    # framework that retries can hold one result per test and replace it per attempt.
+    def build_test(**fields)
       result = TestResult.new(**fields, attachments: @pending_attachments || [])
       @pending_attachments = nil
+      result
+    end
+
+    def add_result(result)
       @results << result
       result
     end

data/lib/raider_reporter/comment/azure_client.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module RaiderReporter
+  module Comment
+    # Minimal Azure DevOps REST client: one Raider thread per pull request, plus a PR status.
+    class AzureClient
+      class Error < StandardError; end
+      # 401/403/404: the build service identity cannot write to this PR.
+      class Forbidden < Error; end
+
+      API_VERSION = "7.1"
+      STATUS_API_VERSION = "7.1" # confirmed in the 7.1 Pull Request Statuses doc; see spec header
+      PROPERTY = "Raider.BuildComment"
+      DESCRIPTION_LIMIT = 140
+
+      def initialize(token:, base_url:, timeout: 30)
+        @token = token
+        @base_url = base_url.to_s.sub(%r{/+\z}, "")
+        @timeout = timeout
+      end
+
+      def upsert_thread(markdown, marker, status:)
+        thread = find_thread(marker)
+        if thread
+          comment_id = thread["comments"].first["id"]
+          request(:patch, "/threads/#{thread['id']}/comments/#{comment_id}", { content: markdown })
+          request(:patch, "/threads/#{thread['id']}", { status: status })
+          :updated
+        else
+          request(:post, "/threads", { comments: [{ parentCommentId: 0, content: markdown, commentType: 1 }],
+                                       status: status,
+                                       properties: { PROPERTY => { "$type" => "System.Int32", "$value" => 1 } } })
+          :created
+        end
+      end
+
+      def set_status(state:, description:, target_url:)
+        request(:post, "/statuses", { state: state, description: description.to_s[0, DESCRIPTION_LIMIT],
+                                      targetUrl: target_url, context: { genre: "raider", name: "tests" } },
+                version: STATUS_API_VERSION)
+        nil
+      end
+
+      private
+
+      def find_thread(marker)
+        list = request(:get, "/threads")
+        threads = list.is_a?(Hash) ? list["value"] : nil
+        raise Error, "unexpected threads response" unless threads.is_a?(Array)
+
+        threads.find { |t| ours?(t, marker) }
+      end
+
+      # Only a property-tagged thread whose live first comment starts with the marker is ours.
+      def ours?(thread, marker)
+        return false unless thread.is_a?(Hash) && thread["properties"].is_a?(Hash) && thread["properties"].key?(PROPERTY)
+        return false unless thread["comments"].is_a?(Array)
+
+        first = thread["comments"].first
+        first.is_a?(Hash) && !first["isDeleted"] && first["content"].to_s.start_with?(marker)
+      end
+
+      def redact(text)
+        @token.to_s.empty? ? text.to_s : text.to_s.gsub(@token.to_s, "[REDACTED]")
+      end
+
+      def request(verb, path, payload = nil, version: nil)
+        uri = URI.parse("#{@base_url}#{path}?api-version=#{version || API_VERSION}")
+        raise Error, "Azure DevOps URL must start with http:// or https://" unless uri.is_a?(URI::HTTP)
+
+        req = build_request(verb, uri, payload)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                                       open_timeout: @timeout, read_timeout: @timeout,
+                                                       write_timeout: @timeout) { |http| http.request(req) }
+        handle(response)
+      rescue Error
+        raise
+      rescue StandardError => e
+        raise Error, redact("#{e.class}: #{e.message}")
+      end
+
+      def build_request(verb, uri, json)
+        klass = { get: Net::HTTP::Get, post: Net::HTTP::Post, patch: Net::HTTP::Patch }.fetch(verb)
+        req = klass.new(uri)
+        req["Authorization"] = "Bearer #{@token}"
+        req["Accept"] = "application/json"
+        req["User-Agent"] = "raider_reporter/#{VERSION}"
+        if json
+          req["Content-Type"] = "application/json"
+          req.body = JSON.generate(json)
+        end
+        req
+      end
+
+      def handle(response)
+        code = response.code.to_i
+        raise Forbidden, "HTTP #{code}" if [401, 403, 404].include?(code)
+        raise Error, "HTTP #{code}: #{redact(response.body.to_s)[0, 200]}" unless (200..299).cover?(code)
+
+        JSON.parse(response.body.to_s)
+      rescue JSON::ParserError
+        raise Error, "Azure DevOps returned invalid JSON"
+      end
+    end
+  end
+end

data/lib/raider_reporter/comment/github_client.rb

@@ -101,7 +101,7 @@ module RaiderReporter
       def handle(response)
         code = response.code.to_i
         raise Forbidden, "HTTP #{code}" if [403, 404].include?(code)
-        raise Error, redact("HTTP #{code}: #{response.body.to_s[0, 200]}") unless (200..299).cover?(code)
+        raise Error, "HTTP #{code}: #{redact(response.body.to_s)[0, 200]}" unless (200..299).cover?(code)
 
         JSON.parse(response.body.to_s)
       rescue JSON::ParserError

data/lib/raider_reporter/configuration.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require "raider_reporter/azure_env"
+
 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"]
+      @token = AzureEnv.value(env, "RAIDER_TOKEN")
+      @endpoint = AzureEnv.value(env, "RAIDER_ENDPOINT")
       @output_dir = "raider-results"
       @clean_output_dir = true
       @environment = {}

data/lib/raider_reporter/cucumber/formatter.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "cucumber"
+require "cucumber/formatter/ast_lookup"
+require "raider_reporter"
+require "raider_reporter/text"
+
+module RaiderReporter
+  module Cucumber
+    # Translates Cucumber events into Collector calls. Every handler is guarded:
+    # a reporting bug must never fail or crash the user's run. The formatter
+    # writes nothing to its IO; the report goes to RaiderReporter's own writers.
+    #
+    # Inside this namespace `Cucumber` means RaiderReporter::Cucumber, so the
+    # gem's constants are always written ::Cucumber.
+    class Formatter
+      STATUSES = {
+        passed: "passed", failed: "failed", ambiguous: "failed",
+        pending: "pending", undefined: "pending", skipped: "skipped"
+      }.freeze
+
+      # Passed to the World's `attach`; reports an existing file as an attachment.
+      module AttachCapture
+        # Takes whatever Cucumber passes (file, media_type, filename, and any
+        # argument a later release adds) and forwards it untouched.
+        ruby2_keywords def attach(*args, &block)
+          result = super
+          Formatter.record_attachment(args[0], args[1])
+          result
+        end
+      end
+
+      @claimed = []
+
+      class << self
+        # One listener per run, whether it arrives as a --format or as a plugin.
+        # Cucumber copies the configuration for --out, but the event bus is shared.
+        def claim(config)
+          bus = config.event_bus
+          return false if @claimed.any? { |claimed| claimed.equal?(bus) }
+
+          @claimed << bus
+          true
+        end
+
+        # Inline text, IO objects and missing paths are ignored: only a file that
+        # exists can be copied. Never raises into the user's step.
+        def record_attachment(file, media_type)
+          # `log` is attach with this media type; a logged message is not a file.
+          return if media_type.to_s.start_with?("text/x.cucumber.log")
+
+          file = file.to_path if file.respond_to?(:to_path)
+          return unless file.is_a?(String) && RaiderReporter.collector&.in_test? && File.file?(file)
+
+          RaiderReporter.attach(File.basename(file), file, type: media_type)
+        rescue StandardError => e
+          RaiderReporter.warn("#{e.class}: #{e.message}")
+        end
+
+        # Called when the run ends, so the list does not outlive the run.
+        def release(config)
+          bus = config.event_bus
+          @claimed.reject! { |claimed| claimed.equal?(bus) }
+          RaiderReporter.dry_run = false
+        end
+
+        # Cucumber hands steps a World, not the formatter, so `attach` is observed
+        # by prepending to ProtoWorld. Installed once, at the first formatter.
+        # Event-bus alternatives were checked in cucumber 9.2.1, 10.2.0 and 11.1.1:
+        # there is no :attach_called event before 11, and even there (and in the
+        # :envelope attachment message) a file path has already been read into
+        # bytes with no name, so the basename the report needs is only available
+        # in ProtoWorld#attach, which exists unchanged in all three versions.
+        def capture_attach
+          return if @capturing
+
+          ::Cucumber::Glue::ProtoWorld.prepend(AttachCapture)
+          @capturing = true
+        end
+      end
+
+      def initialize(config)
+        @buffer = {}
+        @attempts = Hash.new(0)
+        @attempt = nil
+        guard { setup(config) if self.class.claim(config) }
+      end
+
+      private
+
+      def setup(config)
+        @config = config
+        @ast = ::Cucumber::Formatter::AstLookup.new(config)
+        @collector = RaiderReporter.start_collector!
+        RaiderReporter.dry_run = config.dry_run?
+        config.on_event(:test_run_started) { |_event| guard { @collector.start_run } }
+        config.on_event(:test_case_started) { |event| guard { case_started(event.test_case) } }
+        config.on_event(:test_step_finished) { |event| guard { step_finished(event.test_step, event.result) } }
+        config.on_event(:test_case_finished) { |event| guard { case_finished(event.test_case, event.result) } }
+        config.on_event(:test_run_finished) { |_event| guard { run_finished } }
+        # Last, and on its own: a broken attach hook may only lose attachments.
+        safely(nil) { self.class.capture_attach }
+      end
+
+      # Every attempt starts with an empty attachment list.
+      def case_started(test_case)
+        @collector.start_test
+        @attempt = { test_case: test_case }
+      end
+
+      # The first non-passed step explains why the scenario did not pass.
+      def step_finished(test_step, result)
+        return unless @attempt
+        return if @attempt[:problem] || result.passed?
+
+        @attempt[:problem] = { step: test_step, result: result }
+      end
+
+      def case_finished(test_case, result)
+        problem = @attempt && @attempt[:problem]
+        @attempt = nil
+        status = STATUSES.fetch(result.to_sym, "pending")
+        # Always buffer: a lookup problem may lose detail, never the scenario.
+        failure = status == "failed" ? safely(nil) { failure_for(problem, result, test_case) } : nil
+        fields = identity_for(test_case)
+        key = "#{test_case.location}|#{test_case.name}"
+        @attempts[key] += 1
+        # The newest attempt replaces the older one, taking its attachments with it.
+        @buffer[key] = @collector.build_test(
+          **fields, status: status, duration_ms: duration_ms(result), attempts: @attempts[key], failure: failure
+        )
+      end
+
+      def run_finished
+        @buffer.each_value { |result| @collector.add_result(result) }
+        @buffer.clear
+        RaiderReporter.finish!($stderr)
+      ensure
+        self.class.release(@config)
+      end
+
+      def identity_for(test_case)
+        file_path = relative_path(test_case.location.file)
+        line_number = test_case.location.lines.max
+        {
+          file_path: file_path,
+          line_number: line_number,
+          full_name: Text.utf8(full_name(test_case)),
+          identifier: "#{file_path}:#{line_number}",
+          tags: test_case.tags.map { |tag| tag.name.to_s.delete_prefix("@") }.uniq.sort
+        }
+      end
+
+      def full_name(test_case)
+        safely(test_case.name) do
+          feature = @ast.gherkin_document(test_case.location.file)&.feature
+          name = scenario_name(@ast.scenario_source(test_case))
+          next test_case.name unless name
+
+          feature ? "#{feature.name}: #{name}" : name
+        end
+      end
+
+      # nil when the scenario cannot be located in the AST.
+      def scenario_name(source)
+        case source&.type
+        when :ScenarioOutline
+          examples = source.examples
+          row = examples.table_body.index { |candidate| candidate.location.line == source.row.location.line }
+          row && "#{source.scenario_outline.name} (#{examples_label(source)}, row #{row + 1})"
+        when :Scenario
+          source.scenario.name
+        end
+      end
+
+      # "Examples" or the table's name. When several tables of one outline share a
+      # label (two unnamed ones, say), each gets its 1-based position among them,
+      # so rows of different tables never collide on full_name.
+      def examples_label(source)
+        tables = source.scenario_outline.examples
+        label = examples_name(source.examples)
+        same = tables.select { |table| examples_name(table) == label }
+        return label if same.size < 2
+
+        "#{label} #{same.index { |table| table.equal?(source.examples) || table.location.line == source.examples.location.line } + 1}"
+      end
+
+      def examples_name(table)
+        table.name.to_s.strip.empty? ? "Examples" : table.name.strip
+      end
+
+      # step_info is { step:, result: } for the first non-passed step, if any.
+      def failure_for(step_info, result, test_case)
+        exception = result.respond_to?(:exception) ? result.exception : nil
+        exception ||= step_info && step_info[:result].respond_to?(:exception) ? step_info[:result].exception : nil
+        return nil unless exception
+
+        Failure.new(
+          message: Text.utf8("#{step_label(step_info, test_case)}\n\n#{exception.message}")[0, Text::MAX_MESSAGE],
+          exception_class: Text.utf8(exception.class.name),
+          backtrace: (exception.backtrace || []).first(Text::MAX_BACKTRACE).map { |line| Text.utf8(line) }
+        )
+      end
+
+      def step_label(step_info, test_case)
+        return "Step" unless step_info
+
+        test_step = step_info[:step]
+        location = "(#{relative_path(test_step.location.file)}:#{test_step.location.lines.min})"
+        if test_step.hook?
+          "#{hook_kind(test_step, test_case)} hook #{location}"
+        else
+          "#{step_keyword(test_step)}#{test_step.text} #{location}"
+        end
+      end
+
+      def step_keyword(test_step)
+        safely("") { @ast.step_source(test_step).step.keyword.to_s }
+      end
+
+      # A hook with a real step before it runs after the scenario started.
+      def hook_kind(test_step, test_case)
+        steps = test_case.test_steps
+        index = steps.index { |candidate| candidate.equal?(test_step) }
+        index && steps.first(index).any? { |candidate| !candidate.hook? } ? "After" : "Before"
+      end
+
+      def duration_ms(result)
+        (result.duration.nanoseconds / 1_000_000.0).round
+      rescue StandardError
+        0
+      end
+
+      def relative_path(path)
+        absolute = Pathname.new(File.expand_path(path.to_s, Dir.pwd))
+        relative = absolute.relative_path_from(Pathname.new(Dir.pwd)).to_s
+        relative.start_with?("..") ? path.to_s.delete_prefix("./") : relative
+      rescue ArgumentError
+        # Windows: a path on another drive has no relative form.
+        path.to_s.delete_prefix("./")
+      end
+
+      def safely(fallback)
+        yield
+      rescue StandardError => e
+        RaiderReporter.warn("#{e.class}: #{e.message}")
+        fallback
+      end
+
+      def guard
+        yield
+      rescue StandardError => e
+        RaiderReporter.warn("#{e.class}: #{e.message}")
+      end
+    end
+  end
+end

data/lib/raider_reporter/cucumber.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+begin
+  require "cucumber"
+rescue LoadError => e
+  raise unless e.path == "cucumber"
+
+  raise LoadError, "raider_reporter/cucumber needs the cucumber gem (>= 9, < 12) in your Gemfile"
+end
+require "raider_reporter"
+require_relative "cucumber/formatter"
+
+module RaiderReporter
+  module Cucumber
+    # Plugin mode: requiring this file from features/support registers the
+    # listener through Cucumber's InstallPlugin hook, so no --format is needed
+    # (and none of the "one formatter per stream" juggling). Outside a Cucumber
+    # run there is no step-definition registry and this is a no-op.
+    def self.install_plugin
+      # Cucumber's public InstallPlugin DSL method, called on a throwaway object
+      # (it is only an instance method of Dsl; main is extended with it).
+      Object.new.extend(::Cucumber::Glue::Dsl).InstallPlugin(name: "raider_reporter") do |config, *|
+        RaiderReporter::Cucumber::Formatter.new(config)
+      end
+      true
+    rescue StandardError => e
+      # Outside a run there is no registry (Dsl has no rb_language) and nothing to
+      # report. Inside one, losing the listener must not be silent.
+      RaiderReporter.warn("could not register the Cucumber plugin: #{e.class}: #{e.message}") if run_active?
+      false
+    end
+
+    def self.run_active?
+      !::Cucumber::Glue::Dsl.instance_variable_get(:@rb_language).nil?
+    end
+    private_class_method :run_active?
+  end
+end
+
+RaiderReporter::Cucumber.install_plugin

data/lib/raider_reporter/rspec/formatter.rb

@@ -2,6 +2,7 @@
 
 require "rspec/core"
 require "raider_reporter"
+require "raider_reporter/text"
 
 module RaiderReporter
   module RSpec
@@ -13,8 +14,8 @@ module RaiderReporter
                                          :example_failed, :example_pending, :close
 
       NON_TAG_KEYS = %i[pending skip].freeze
-      MAX_MESSAGE = 10_000
-      MAX_BACKTRACE = 50
+      MAX_MESSAGE = Text::MAX_MESSAGE
+      MAX_BACKTRACE = Text::MAX_BACKTRACE
 
       def initialize(output)
         @output = output
@@ -77,14 +78,8 @@ module RaiderReporter
         )
       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
+        Text.utf8(value)
       end
 
       def guard

data/lib/raider_reporter/shard_detector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "raider_reporter/azure_env"
+
 module RaiderReporter
   # Identifies which slice of a parallel suite this process is.
   class ShardDetector
@@ -9,7 +11,7 @@ module RaiderReporter
     end
 
     def shard
-      index, total, suffix = composed || explicit || parallel_tests
+      index, total, suffix = composed || outer || parallel_tests
       return nil unless index
 
       { "index" => index, "total" => total, "label" => "#{@job || "local"}##{suffix || index}" }
@@ -19,7 +21,7 @@ module RaiderReporter
 
     # A matrix leg that also runs parallel_tests: every process gets a unique index.
     def composed
-      explicit_index, explicit_total = explicit
+      explicit_index, explicit_total = outer
       parallel_index, = parallel_tests
       groups = positive(@env["PARALLEL_TEST_GROUPS"])
       return nil unless explicit_index && parallel_index && groups
@@ -29,6 +31,18 @@ module RaiderReporter
        "#{explicit_index}.#{parallel_index}"]
     end
 
+    def outer
+      explicit || azure_parallel
+    end
+
+    def azure_parallel
+      return nil unless AzureEnv.azure?(@env)
+
+      total = positive(AzureEnv.value(@env, "SYSTEM_TOTALJOBSINPHASE"))
+      index = positive(AzureEnv.value(@env, "SYSTEM_JOBPOSITIONINPHASE"))
+      [index, total] if index && total && total > 1
+    end
+
     def explicit
       index = positive(@env["RAIDER_SHARD_INDEX"])
       [index, positive(@env["RAIDER_SHARD_TOTAL"])] if index

data/lib/raider_reporter/text.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RaiderReporter
+  # Text limits and cleaning shared by the framework formatters.
+  module Text
+    MAX_MESSAGE = 10_000
+    MAX_BACKTRACE = 50
+
+    # JSON generation raises on invalid UTF-8, which would lose the whole run.
+    def self.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
+  end
+end

data/lib/raider_reporter/version.rb

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

data/lib/raider_reporter.rb

@@ -3,6 +3,7 @@
 require "time"
 require "rbconfig"
 require_relative "raider_reporter/version"
+require_relative "raider_reporter/text"
 require_relative "raider_reporter/models"
 require_relative "raider_reporter/payload"
 require_relative "raider_reporter/configuration"
@@ -14,6 +15,7 @@ require_relative "raider_reporter/shard_detector"
 require_relative "raider_reporter/writers/uploader"
 require_relative "raider_reporter/comment/summary_client"
 require_relative "raider_reporter/comment/github_client"
+require_relative "raider_reporter/comment/azure_client"
 
 module RaiderReporter
   class << self
@@ -27,13 +29,18 @@ module RaiderReporter
       yield configuration
     end
 
+    # Set by the Cucumber formatter when the run is a --dry-run.
+    attr_writer :dry_run
+
     def reset!
+      @dry_run = false
       @collector&.cleanup
       @configuration = nil
       @collector = nil
     end
 
     def start_collector!
+      @dry_run = false
       @collector = Collector.new(
         max_attachment_bytes: configuration.max_attachment_bytes,
         warn: ->(message) { warn(message) }
@@ -104,8 +111,10 @@ module RaiderReporter
       "Raider report uploaded"
     end
 
-    # `rspec --dry-run` reports every example as passed without running it.
+    # `rspec --dry-run` and `cucumber --dry-run` report every example as passed without running it.
     def dry_run?
+      return true if @dry_run
+
       defined?(::RSpec.configuration) && ::RSpec.configuration.respond_to?(:dry_run?) &&
         ::RSpec.configuration.dry_run?
     end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: raider_reporter
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Augustin Gottlieb
 bindir: exe
 cert_chain: []
-date: 2026-10-11 00:00:00.000000000 Z
+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.
+description: RSpec and Cucumber formatters that record results, screenshots and videos
+  in the Raider schema, write them locally, and optionally upload them to a Raider
+  server.
 email:
 - 33221555+aguspe@users.noreply.github.com
 executables:
@@ -23,19 +24,24 @@ files:
 - README.md
 - exe/raider-reporter
 - lib/raider_reporter.rb
+- lib/raider_reporter/azure_env.rb
 - lib/raider_reporter/ci_detector.rb
 - lib/raider_reporter/cli.rb
 - lib/raider_reporter/collector.rb
+- lib/raider_reporter/comment/azure_client.rb
 - lib/raider_reporter/comment/github_client.rb
 - lib/raider_reporter/comment/summary_client.rb
 - lib/raider_reporter/configuration.rb
 - lib/raider_reporter/content_types.rb
+- lib/raider_reporter/cucumber.rb
+- lib/raider_reporter/cucumber/formatter.rb
 - lib/raider_reporter/github_event.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/shard_detector.rb
+- lib/raider_reporter/text.rb
 - lib/raider_reporter/version.rb
 - lib/raider_reporter/writers/local.rb
 - lib/raider_reporter/writers/uploader.rb
@@ -60,7 +66,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.6
 specification_version: 4
-summary: 'Test reporting for Ruby Raider: local run.json and Raider uploads'
+summary: RSpec and Cucumber formatters that write Raider reports locally and upload
+  them to Raider
 test_files: []