raider_reporter 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dda0a98d0886eefbfd851be91d57c881e74abee367956b0272fc9b7a464045cf
-  data.tar.gz: 8012de5d41e890b7dae144ab5f208c20ed2ffa94736645a4308901f6abe24174
+  metadata.gz: 291269e17dbda3cec36ff4822af7ba9b16b85f5f1d231eed8b96fb9b89f9e338
+  data.tar.gz: 16e1c480d70fc174b25f7b91fcd5f9b242b04f1e7b751172e796050a0c405a39
 SHA512:
-  metadata.gz: fa44978dfb6d93f9bbb316fe36d837b3ecb1ae668c7292b7f7e6ac345646b4c9099dd30375d8881e466f8f21eeb4ae6ae01d53e76652f975ffeaaa83b263939c
-  data.tar.gz: 6a43fa45d7a90997e64e95b9f5e40e978c398343695ce74950809f9cadbafd7420edce162c4560d01dd67892861b61180c5c7938afc2cf28a6191f1d1e18a54b
+  metadata.gz: 6bc649c77eaa3a22110dd19b9a5eb28f1e60aab2d6a2877985a8254c85ad647f58d83427e298f79d48a5e420893afc12c06c54a05526a0b0488ca43c015a6510
+  data.tar.gz: 1590461029cc94956c3e28fffa9003252d8de1f064211dbcc9d3dcdfe0cbe11c4f9125fafb459978f77f082419b80c36a4702d0a7917ba480d4ed6a740a5f8fb

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.10.0 — 2026-10-26
+
+- Video attachments play inline in the HTML report: `video/*` attachments render as a `<video controls>` player (metadata preloaded only) with a download link, instead of a plain link. Unsafe paths are still dropped
+- Videos get their own size cap, `config.max_video_bytes` (default 50 MB); the 5 MB `max_attachment_bytes` still applies to everything else. A video over its cap is skipped with a warning
+- Uploads keep non-video attachments (screenshots, logs) first; videos then fill whatever room is left in the upload budget. A video that does not fit is skipped and later, smaller ones are still tried
+- The Cucumber formatter works on Cucumber 12, which removed `config.strict`: it no longer logs `undefined method 'strict'` and keeps its failure counts (Cucumber 10 and 11 behave as before)
+- No breaking changes
+
 ## 0.9.0 — 2026-10-24
 
 - `raider-reporter gate` waits for the Raider quality gate verdict of the CI build (`GET /api/v1/builds/gate`, every 10 seconds, up to `RAIDER_GATE_TIMEOUT` seconds, default 600, 1–3600) and exits 0 when the gate passed or the project has no gate rules, 1 when it failed (naming the failed rules), and 2 when it gets no verdict (timeout, Raider unreachable, token rejected, build not found, any other error). 429, 5xx and network errors are retried within the time limit

data/README.md

@@ -30,7 +30,7 @@ Run `bundle exec rspec` as usual. (For Cucumber, see [Cucumber](#cucumber).) Res
 
 ## 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.
+Requirements: Cucumber 9, 10, 11 or 12 (12 needs Ruby 3.3+) 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)
 
@@ -120,7 +120,11 @@ 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.
+`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 its size cap: 5 MB (`max_attachment_bytes`), or 50 MB for videos (`video/*`, `max_video_bytes`).
+
+Videos (`.webm`, `.mp4`) are attached the same way, for example `RaiderReporter.attach("video", path, type: :webm)`. In the local HTML report they play inline, with a download link.
+
+When a run is uploaded, screenshots and other non-video attachments are sent first; videos then fill the room left in the upload budget. A video that does not fit is skipped and later, smaller videos are still tried. The local `raider-results/attachments/` folder keeps every attachment that passed its size cap.
 
 ## Configuration
 
@@ -139,6 +143,9 @@ end
 | `clean_output_dir` | `true` | Remove the previous `run.json` and `attachments/` directory (`run-<n>.json` and `attachments-<n>/` when sharded) inside `output_dir` before writing. Nothing else in `output_dir` is touched, except a raider_reporter-written `index.html`. |
 | `html_report` | `true` | Write `index.html`, the local HTML report, into `output_dir` after each run. See [Local report](#local-report). |
 | `quarantine` | `true` when `ENV["RAIDER_QUARANTINE"]` is `1` or `true` | Fetch the quarantine list at run start and report matching failures as `quarantined`. Needs `token` and `endpoint`. See [Quarantine](#quarantine). |
+| `max_attachment_bytes` | `5 MB` | Largest non-video attachment `attach` accepts. |
+| `max_video_bytes` | `50 MB` | Largest `video/*` attachment `attach` accepts. |
+| `exec_summary_path` | `ENV["RAIDER_EXEC_SUMMARY"]` | File where the run writes its failure counts (framework failures, quarantined, errors outside tests) for `raider-reporter exec` to read when it decides the exit code. `exec` sets it for the command it runs; leave it unset otherwise. Nothing is written when it is unset. See [Quarantine](#quarantine). |
 | `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

data/lib/raider_reporter/collector.rb

@@ -8,9 +8,11 @@ require "set"
 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 },
+    def initialize(max_attachment_bytes:, warn:, max_video_bytes: Configuration::DEFAULT_MAX_VIDEO_BYTES,
+                   clock: -> { Time.now.utc }, uuid: -> { SecureRandom.uuid },
                    quarantine: -> { Quarantine::EMPTY })
       @max_attachment_bytes = max_attachment_bytes
+      @max_video_bytes = max_video_bytes
       @warn = warn
       @clock = clock
       @uuid = uuid
@@ -118,8 +120,9 @@ module RaiderReporter
         @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")
+      limit = attachment.content_type.to_s.start_with?("video/") ? @max_video_bytes : @max_attachment_bytes
+      if File.size(path) > limit
+        @warn.call("attachment #{path} is larger than #{limit} bytes; skipped")
         return false
       end
       true

data/lib/raider_reporter/configuration.rb

@@ -5,9 +5,10 @@ require "raider_reporter/azure_env"
 module RaiderReporter
   class Configuration
     TRUTHY = %w[1 true].freeze
+    DEFAULT_MAX_VIDEO_BYTES = 50 * 1024 * 1024
 
     attr_accessor :token, :endpoint, :output_dir, :clean_output_dir, :html_report, :environment, :max_attachment_bytes,
-                  :quarantine, :exec_summary_path
+                  :max_video_bytes, :quarantine, :exec_summary_path
 
     def initialize(env = ENV)
       @token = AzureEnv.value(env, "RAIDER_TOKEN")
@@ -17,6 +18,7 @@ module RaiderReporter
       @html_report = true
       @environment = {}
       @max_attachment_bytes = 5 * 1024 * 1024
+      @max_video_bytes = DEFAULT_MAX_VIDEO_BYTES
       @quarantine = TRUTHY.include?(AzureEnv.value(env, "RAIDER_QUARANTINE").to_s.downcase)
       @exec_summary_path = AzureEnv.value(env, "RAIDER_EXEC_SUMMARY")
     end

data/lib/raider_reporter/cucumber/formatter.rb

@@ -160,8 +160,8 @@ module RaiderReporter
         return if @outcomes_broken
 
         key = "#{test_case.location}|#{test_case.name}"
-        failed = !result.ok?(strict: @config.strict)
-        flaky = !failed && @failed_before[key] && @config.strict.strict?(:flaky)
+        failed = !result_ok?(result)
+        flaky = !failed && @failed_before[key] && strict_flaky?
         @failed_before[key] ||= failed
         @outcomes[key] = failed || flaky ? true : false
       rescue StandardError => e
@@ -169,6 +169,23 @@ module RaiderReporter
         RaiderReporter.warn("#{e.class}: #{e.message}")
       end
 
+      # Cucumber 10 and 11 carry a strict configuration (config.strict) that result.ok?
+      # takes as a keyword. Cucumber 12 removed it: result.ok? takes nothing, pending and
+      # undefined always fail, and a flaky scenario never does. Detect, never compare versions.
+      def strict_configuration
+        @config.strict if @config.respond_to?(:strict)
+      end
+
+      def result_ok?(result)
+        strict = strict_configuration
+        strict ? result.ok?(strict: strict) : result.ok?
+      end
+
+      def strict_flaky?
+        strict = strict_configuration
+        strict ? strict.strict?(:flaky) : false
+      end
+
       # Scenarios that make cucumber's run fail; one error outside tests when the run
       # stopped before every scenario finished (--fail-fast) (spec §4.4).
       def record_framework_counts

data/lib/raider_reporter/cucumber.rb

@@ -5,7 +5,7 @@ begin
 rescue LoadError => e
   raise unless e.path == "cucumber"
 
-  raise LoadError, "raider_reporter/cucumber needs the cucumber gem (>= 9, < 12) in your Gemfile"
+  raise LoadError, "raider_reporter/cucumber needs the cucumber gem (>= 9, < 13) in your Gemfile"
 end
 require "raider_reporter"
 require_relative "cucumber/formatter"

data/lib/raider_reporter/version.rb

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

data/lib/raider_reporter/writers/html.rb

@@ -224,8 +224,11 @@ module RaiderReporter
           href = safe_href(attachment["path"])
           next unless href
 
-          if attachment["content_type"].to_s.start_with?("image/")
+          content_type = attachment["content_type"].to_s
+          if content_type.start_with?("image/")
             %(<a href="#{href}"><img loading="lazy" src="#{href}" alt="#{h(attachment['name'])}"></a>)
+          elsif content_type.start_with?("video/")
+            %(<video controls preload="metadata" src="#{href}"></video><a href="#{href}" download>#{h(attachment['name'])}</a>)
           else
             %(<a href="#{href}">#{h(attachment['name'])}</a>)
           end
@@ -280,6 +283,7 @@ module RaiderReporter
         .r p{margin:2px 0;overflow-wrap:anywhere}.n{font-weight:500}.x{color:var(--ruby);font-weight:600}
         pre{margin:4px 0;padding:8px;background:var(--card);border-radius:6px;overflow-x:auto;white-space:pre-wrap;font-size:12px}
         .a img{max-width:100%;max-height:240px;border:1px solid var(--bdr);border-radius:4px;margin-top:4px}
+        .a video{max-width:100%;max-height:360px;display:block}
         a{color:var(--ruby)}.empty{padding:24px 0;color:var(--mute)}
       CSS
 

data/lib/raider_reporter/writers/uploader.rb

@@ -48,30 +48,59 @@ module RaiderReporter
 
       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.
+      # Keeps the attachments that fit the byte and count budget, non-video
+      # attachments first and videos in whatever room is left, and rebuilds the
+      # payload without the rest, so part names stay contiguous. Survivors keep
+      # their original order. 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
+        keep = budgeted(entries)
+        return payload if keep.size == entries.size
+
+        dropped = entries.size - keep.size
         @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 })
+          result.with(attachments: result.attachments.select { |attachment| keep.key?(attachment) })
         end))
       end
 
+      # Identity-keyed set of the attachments to upload. Non-videos come first
+      # and stop at the first byte overflow; videos then fill the room left,
+      # a video that does not fit is skipped and later ones are still tried.
+      def budgeted(entries)
+        videos, others = entries.partition { |entry| video?(entry[:attachment]) }
+        keep = {}.compare_by_identity
+        bytes = 0
+        others.each do |entry|
+          bytes += size_of(entry)
+          break if bytes > MAX_UPLOAD_ATTACHMENT_BYTES || keep.size >= MAX_UPLOAD_ATTACHMENTS
+
+          keep[entry[:attachment]] = true
+        end
+        videos.each do |entry|
+          break if keep.size >= MAX_UPLOAD_ATTACHMENTS
+
+          size = size_of(entry)
+          next if bytes + size > MAX_UPLOAD_ATTACHMENT_BYTES
+
+          bytes += size
+          keep[entry[:attachment]] = true
+        end
+        keep
+      end
+
+      def video?(attachment)
+        attachment.content_type.to_s.start_with?("video/")
+      end
+
+      def size_of(entry)
+        File.size?(entry[:attachment].source_path).to_i
+      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

data/lib/raider_reporter.rb

@@ -50,6 +50,7 @@ module RaiderReporter
       @project_root = Dir.pwd
       @collector = Collector.new(
         max_attachment_bytes: configuration.max_attachment_bytes,
+        max_video_bytes: configuration.max_video_bytes,
         warn: ->(message) { warn(message) },
         quarantine: -> { quarantined_keys }
       )
@@ -70,14 +71,15 @@ module RaiderReporter
         return false
       end
 
-      limit = configuration.max_attachment_bytes
+      content_type = ContentTypes.resolve(type, path)
+      limit = attachment_limit(content_type)
       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)))
+                                      content_type: content_type))
     rescue StandardError => e
       warn("attach(#{name.inspect}) failed: #{e.class}: #{e.message}")
       false
@@ -119,6 +121,10 @@ module RaiderReporter
 
     private
 
+    def attachment_limit(content_type)
+      content_type.start_with?("video/") ? configuration.max_video_bytes : configuration.max_attachment_bytes
+    end
+
     # First, so a later reporting problem cannot lose it. A failure here only means
     # no summary, and exec then keeps the command's exit code.
     def write_exec_summary

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raider_reporter
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Augustin Gottlieb
@@ -74,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: RSpec and Cucumber formatters that write Raider reports locally and upload
   them to Raider