test-recorder 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ce916b59fcd166bdcafb222263423739c9c8fe58e53a50f5895c95485145522
-  data.tar.gz: 71fd0cb14988364e06d7977c38815a6656522c2acb79180ec06e5889b5eab155
+  metadata.gz: f2df7b7454c1776d950afaadc9fcefdab037f2638a0a0f05ba7251ef08131428
+  data.tar.gz: 97e45933561090c772aef6a26849075626c7d8e9766d0e25c60a642841a38f36
 SHA512:
-  metadata.gz: 3caaba9397db23c5c2bdb215812345af54f04a21e25c56ae6c83209c45f42a2bfd1891a587e7c58682ee85bd07b806d077adb7f7e780e2cd1c202fa2a38e5b64
-  data.tar.gz: 50f45dfc872ff6cc60a997f842bff3ba95d225cd88621879d2a07c0119c577376528ac3cedf306322c9c7efe1e18a1be63d232109c4d3ac29f3689d22aed27b9
+  metadata.gz: 2ced41859d336565547e55de99b4574952f175bc3acb7ce6a6231c07ce32bab27483689f6a9c3967950d4da80145ea2002a0abe2ba3b6905c56fa9728902e004
+  data.tar.gz: 1657c90f69bcf393bb7e4905fde1a9e6afc74b7c5e864521a72bee0f4d3f97db9b1ceba28e466d321e7122ce2545548431ccd593a576e53f2b7c3c45d34214da

data/.github/workflows/ci.yml

@@ -3,32 +3,45 @@ name: CI
 on:
   push:
     branches:
-      - master
+      - main
 
   pull_request:
 
+env:
+  FFMPEG_BUILD: ffmpeg-n8.1-latest-linux64-gpl-8.1
+
 jobs:
   build:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
 
-    concurrency:
-      group: ${{ github.ref }}
-      cancel-in-progress: true
+    strategy:
+      matrix:
+        ruby: [ '4.0', '3.4', '3.3' ]
 
     steps:
-    - uses: actions/checkout@v3
-    - uses: ruby/setup-ruby@v1
+    - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+    - uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
       with:
-        ruby-version: '3.2'
-    - uses: actions/setup-node@v2
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Cache ffmpeg
+      id: cache-ffmpeg
+      uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
       with:
-        node-version: '18'
+        path: ~/.local/bin/ffmpeg
+        key: ffmpeg-${{ runner.os }}-${{ env.FFMPEG_BUILD }}
     - name: Install ffmpeg
+      if: steps.cache-ffmpeg.outputs.cache-hit != 'true'
       run: |
-        sudo apt update && sudo apt install ffmpeg
-    - name: Install dependencies
+        mkdir -p "$HOME/.local/bin"
+        curl -fsSL -o "$RUNNER_TEMP/ffmpeg.tar.xz" \
+          "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/${FFMPEG_BUILD}.tar.xz"
+        tar -xJf "$RUNNER_TEMP/ffmpeg.tar.xz" -C "$RUNNER_TEMP" "${FFMPEG_BUILD}/bin/ffmpeg"
+        mv "$RUNNER_TEMP/${FFMPEG_BUILD}/bin/ffmpeg" "$HOME/.local/bin/ffmpeg"
+    - name: Set up ffmpeg
       run: |
-        gem install bundler --no-document
-        bundle install
+        chmod +x "$HOME/.local/bin/ffmpeg"
+        echo "$HOME/.local/bin" >> "$GITHUB_PATH"
     - name: Run test
       run: bundle exec rake

data/.github/workflows/push_gem.yml

@@ -0,0 +1,33 @@
+name: Push Gem
+
+on:
+  push:
+    tags:
+      - v*
+
+permissions:
+  contents: read
+
+jobs:
+  push:
+    if: github.repository == 'y-yagi/test-recorder'
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@05e31511f85b41b11d1cf0ef85d0992719546e2c # v2.21.0
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
+        with:
+          bundler-cache: true
+          ruby-version: ruby
+
+      - uses: rubygems/release-gem@7f9650160c1a4e7989fdc9855807bdbd421d8b6b # v1.4.1

data/.gitignore

@@ -6,3 +6,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+Gemfile.lock

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## Unreleased
+
+## 0.4.0 - 2026-08-30
+
+* Record each frame with its own timestamp so that videos play back at the same speed as the test
+
+## 0.3.0 - 2026-08-23
+
+* Reduce recording overhead
+* Make recording JPEG quality, max dimension and screencast frame interval configurable
+* Explicitly encode videos with VP8 to avoid relying on ffmpeg's default codec
+* Sanitize characters that can't use for video file names
+* Stop recording a video for a skipped Rails system test
+
 ## 0.2.0 - 2023-08-23
 
 * Add support for aggregate_failures #21 (@willnet)

data/Gemfile

@@ -3,6 +3,6 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in test-recorder.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
+gem "rake"
 gem "minitest", "~> 5.0"
 gem "debug"

data/README.md

@@ -94,4 +94,21 @@ TestRecorder.disable!
 it "test to something", test_recorder: true do
   # ...
 end
+```
+
+### Configuration
+
+You can change the recording quality and the max width/height (in pixels).
+
+```ruby
+TestRecorder.jpeg_quality = 80    # default: 60
+TestRecorder.max_dimension = 1280 # default: 1000
+```
+
+You can also record only every Nth frame. This lowers the recording overhead
+at the cost of a choppier video. The playback duration stays the same.
+
+```ruby
+TestRecorder.every_nth_frame = 3 # default: 1
+```
 

data/Rakefile

@@ -6,7 +6,7 @@ Rake::TestTask.new(:test) do |t|
   t.libs << "lib"
   t.verbose = true
   t.warning = true
-  t.test_files = ["test/integration_test.rb"]
+  t.test_files = ["test/integration_test.rb", "test/frame_writer_test.rb", "test/test_recorder_config_test.rb"]
 end
 
 task :default => :test

data/lib/test_recorder/cdp_recorder.rb

@@ -1,19 +1,78 @@
-require "open3"
+require "base64"
 require "fileutils"
 require "tempfile"
 
+require "test_recorder/frame_writer"
+
 module TestRecorder
   class CdpRecorder
+    FFMPEG_ENCODE_OPTIONS = %w[-y -an -r 25 -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1].freeze
+
+    # ffmpeg's -t treats the given duration as an exclusive cutoff, dropping the very frame that
+    # marks the video's real length if it lands exactly on it. This nudges -t just past that frame
+    # so it is kept, without adding a duration long enough to be noticeable.
+    FFMPEG_DURATION_SLACK_S = 0.01
+
+    Record = Struct.new(:page, :io, :last_metadata_time, :last_metadata_received_at)
+
+    class << self
+      def record(devtools)
+        records[devtools] ||= begin
+          page = devtools.page
+          page.enable
+
+          record = Record.new(page)
+          page.on(:screencast_frame) do |event|
+            write_frame(record, event)
+            record.page.screencast_frame_ack(session_id: event["sessionId"])
+          end
+          record
+        end
+      end
+
+      private
+
+      def write_frame(record, event)
+        record.io&.write(Base64.decode64(event["data"]), frame_time(record, event))
+      rescue IOError
+        # A frame can still arrive after the recording was stopped and the file was closed.
+      rescue => e
+        warn "[TestRecorder] Failed to write a screencast frame: #{e.class}: #{e.message}"
+      end
+
+      # `metadata.timestamp` is the wall clock time of the frame swap, in seconds, on the browser's
+      # clock. The protocol marks it optional, so when it is missing, estimate it from the last
+      # frame that did carry one plus how much monotonic time has passed since. Falling back to
+      # this process's own wall clock instead would silently distort pacing whenever the browser
+      # runs on a different host than the driver, since the two wall clocks are not guaranteed to
+      # agree.
+      def frame_time(record, event)
+        metadata = event["metadata"]
+        timestamp = metadata && metadata["timestamp"]
+
+        if timestamp
+          record.last_metadata_time = timestamp
+          record.last_metadata_received_at = monotonic_time
+          timestamp
+        elsif record.last_metadata_time
+          record.last_metadata_time + (monotonic_time - record.last_metadata_received_at)
+        else
+          Time.now.to_f
+        end
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def records
+        @records ||= {}.compare_by_identity
+      end
+    end
+
     def initialize(enabled:)
       @enabled = enabled
       @started = nil
-      @page = nil
-      setup
-    end
-
-    def setup
-      @video_dir = ::Rails.root.join("tmp", "videos")
-      FileUtils.mkdir_p(@video_dir)
     end
 
     def start(page:, enabled: nil)
@@ -21,40 +80,61 @@ module TestRecorder
       @started = enabled
       return unless @started
 
-      @tmp_video = Tempfile.open(["testrecorder", ".webm"])
-      cmd = "ffmpeg -loglevel quiet -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i - -y -an -r 25 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 #{@tmp_video.path}"
-      @stdin, @wait_thrs = *Open3.pipeline_w(cmd)
-      @stdin.set_encoding("ASCII-8BIT")
+      @tmp_video = Tempfile.new(["testrecorder", ".mkv"])
+      @tmp_video.binmode
 
-      @page = page
-      @page.driver.browser.devtools.page.enable
+      @record = self.class.record(page.driver.browser.devtools)
+      @frame_writer = FrameWriter.new(@tmp_video)
+      @record.io = @frame_writer
 
-      @page.driver.browser.devtools.page.on(:screencast_frame) do |event|
-        decoded_data = Base64.decode64(event["data"])
-        @stdin.print(decoded_data) rescue nil
-        @page.driver.browser.devtools.page.screencast_frame_ack(session_id: event["sessionId"])
-      end
-
-      @page.driver.browser.devtools.page.start_screencast(format: "jpeg", quality: 90)
+      @record.page.start_screencast(format: "jpeg", quality: TestRecorder.jpeg_quality, max_width: TestRecorder.max_dimension, max_height: TestRecorder.max_dimension, every_nth_frame: TestRecorder.every_nth_frame)
     end
 
     def stop_and_discard
-      if @started
-        @page.driver.browser.devtools.page.stop_screencast
-        @stdin.close
-      end
+      return unless @started
+
+      @record.io = nil
+      @record.page.stop_screencast
+      @tmp_video.close!
     end
 
     def stop_and_save(filename)
       return "" unless @started
 
-      @page.driver.browser.devtools.page.stop_screencast
-      @stdin.close
-      @wait_thrs.each(&:join)
+      @record.io = nil
+      @record.page.stop_screencast
+      @frame_writer.finish
+      @tmp_video.flush
+
+      # Chrome sends a frame as soon as the screencast starts, so a test that fails
+      # before it draws anything still leaves behind the one frame of the blank page
+      # it started on.
+      if @frame_writer.frame_count < 2
+        warn "[TestRecorder] The screencast captured no page updates, so no video was saved."
+        @tmp_video.close!
+        return ""
+      end
+
+      video_dir = ::Rails.root.join("tmp", "videos")
+      FileUtils.mkdir_p(video_dir)
+      video_path = video_dir.join(filename).to_s
 
-      video_path = File.join(@video_dir, filename)
-      FileUtils.copy(@tmp_video.path, video_path)
-      @tmp_video.close(true)
+      # Each frame carries its own timestamp in the Matroska stream, so ffmpeg knows how long to
+      # hold it and duplicates frames to reach the constant output frame rate on its own. Without a
+      # known end, though, ffmpeg pads however long it likes past the last real timestamp, so -t
+      # caps the output at the video's real duration explicitly.
+      duration = @frame_writer.duration + FFMPEG_DURATION_SLACK_S
+      result = system("ffmpeg", "-loglevel", "error", "-f", "matroska", "-i", @tmp_video.path, "-t", duration.to_s, *FFMPEG_ENCODE_OPTIONS, video_path)
+
+      @tmp_video.close!
+
+      if result.nil?
+        warn "[TestRecorder] Failed to execute ffmpeg. Please make sure that FFmpeg is installed."
+        return ""
+      elsif !result
+        warn "[TestRecorder] ffmpeg failed to encode #{video_path}."
+        return ""
+      end
 
       video_path
     end

data/lib/test_recorder/frame_writer.rb

@@ -0,0 +1,83 @@
+require "test_recorder/matroska_writer"
+
+module TestRecorder
+  class FrameWriter
+    # How long the last frame stays visible at the end of the video. A test usually fails some
+    # time after the last repaint, and that last screen is the one worth looking at.
+    MIN_LAST_FRAME_DURATION = 1.0
+    MAX_LAST_FRAME_DURATION = 5.0
+
+    def initialize(io)
+      @container = MatroskaWriter.new(io)
+      @first_frame_time = nil
+      @last_frame = nil
+      @last_write_at = nil
+      @last_timestamp_ms = 0
+      @duration = nil
+      @frame_count = 0
+      @finished = false
+      # CDP dispatches every screencast frame event on its own thread, and `finish` can run on the
+      # main thread while a frame is still in flight, so all access to the state above and to the
+      # container is serialized through this.
+      @mutex = Mutex.new
+    end
+
+    def empty?
+      @last_frame.nil?
+    end
+
+    # How many seconds the finished video should run for. ffmpeg does not reliably infer this from
+    # the container alone, so `stop_and_save` passes it to ffmpeg explicitly. Only meaningful after
+    # `finish` has run.
+    attr_reader :duration
+
+    # Chrome sends a frame as soon as the screencast starts, so a test that fails before it draws
+    # anything still leaves behind the one frame of the blank page it started on. Callers use this
+    # to tell that apart from a real recording.
+    attr_reader :frame_count
+
+    def write(frame, time)
+      @mutex.synchronize do
+        return if @finished
+
+        @first_frame_time ||= time
+        write_at(frame, time)
+        @last_frame = frame
+        @last_write_at = monotonic_time
+        @frame_count += 1
+      end
+    end
+
+    # Repeats the last frame at the end of the recording so that it stays on screen, and so that
+    # the video covers the time between the last repaint and the end of the test. That interval is
+    # measured with the monotonic clock, so a wall clock adjustment cannot stretch or shrink it.
+    def finish
+      @mutex.synchronize do
+        return if @finished
+
+        @finished = true
+        return if empty?
+
+        elapsed = (monotonic_time - @last_write_at).clamp(MIN_LAST_FRAME_DURATION, MAX_LAST_FRAME_DURATION)
+        write_ms(@last_frame, @last_timestamp_ms + (elapsed * 1000).round)
+        @duration = @last_timestamp_ms / 1000.0
+      end
+    end
+
+    private
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def write_at(frame, time)
+      write_ms(frame, ((time - @first_frame_time) * 1000).round)
+    end
+
+    def write_ms(frame, timestamp_ms)
+      timestamp_ms = [timestamp_ms, @last_timestamp_ms].max
+      @container.write_frame(frame, timestamp_ms)
+      @last_timestamp_ms = timestamp_ms
+    end
+  end
+end

data/lib/test_recorder/matroska_writer.rb

@@ -0,0 +1,177 @@
+module TestRecorder
+  # Writes a Matroska stream holding a single MJPEG video track, where every frame carries the
+  # time it was captured. Chrome emits a screencast frame only when the page repaints, so frames
+  # are not evenly spaced; keeping the real times lets ffmpeg reproduce the original pacing
+  # instead of assuming a fixed frame rate.
+  #
+  # Written against the specifications:
+  #   EBML     https://datatracker.ietf.org/doc/html/rfc8794
+  #   Matroska https://datatracker.ietf.org/doc/html/rfc9559
+  #   Codecs   https://datatracker.ietf.org/doc/html/draft-ietf-cellar-codec
+  #
+  # RFC 9559 updates RFC 8794, so read the two together: it makes 0x80 a legal EBML ID, which
+  # leaves 0xFF as the only reserved one. Codec IDs such as V_MJPEG are defined by neither, but by
+  # the codec document, which is still a draft.
+  #
+  # Only the elements those specifications require for this kind of stream are emitted. The stream
+  # is written as it is captured, so the sizes of the Segment and of each Cluster are not known
+  # when they start and are left unknown, which Matroska allows for those two elements alone.
+  class MatroskaWriter
+    # Element IDs, as defined by Matroska. The leading byte of an ID already encodes how many
+    # bytes the ID occupies, so an ID is written as the minimal big endian form of these numbers.
+    module Id
+      EBML = 0x1A45DFA3
+      EBML_VERSION = 0x4286
+      EBML_READ_VERSION = 0x42F7
+      EBML_MAX_ID_LENGTH = 0x42F2
+      EBML_MAX_SIZE_LENGTH = 0x42F3
+      DOC_TYPE = 0x4282
+      DOC_TYPE_VERSION = 0x4287
+      DOC_TYPE_READ_VERSION = 0x4285
+      SEGMENT = 0x18538067
+      INFO = 0x1549A966
+      TIMESTAMP_SCALE = 0x2AD7B1
+      MUXING_APP = 0x4D80
+      WRITING_APP = 0x5741
+      TRACKS = 0x1654AE6B
+      TRACK_ENTRY = 0xAE
+      TRACK_NUMBER = 0xD7
+      TRACK_UID = 0x73C5
+      TRACK_TYPE = 0x83
+      FLAG_LACING = 0x9C
+      CODEC_ID = 0x86
+      VIDEO = 0xE0
+      PIXEL_WIDTH = 0xB0
+      PIXEL_HEIGHT = 0xBA
+      CLUSTER = 0x1F43B675
+      TIMESTAMP = 0xE7
+      SIMPLE_BLOCK = 0xA3
+    end
+    private_constant :Id
+
+    # A size whose data bits are all ones means "unknown". One byte is enough to say that.
+    UNKNOWN_SIZE = [0xFF].pack("C")
+
+    # TimestampScale is given in nanoseconds per tick, so this makes every timestamp in the stream
+    # a number of milliseconds.
+    TIMESTAMP_SCALE_NS = 1_000_000
+
+    # A block states its time as a 16 bit signed offset from the timestamp of its cluster, so a
+    # cluster can only cover about 32 seconds. Matroska also recommends keeping clusters short,
+    # a few seconds at most.
+    MAX_CLUSTER_DURATION_MS = 5_000
+
+    TRACK_NUMBER = 1
+    TRACK_TYPE_VIDEO = 1
+    KEYFRAME = 0x80
+
+    def initialize(io)
+      @io = io
+      @cluster_timestamp_ms = nil
+
+      write_header
+    end
+
+    # Appends one JPEG, shown at the given number of milliseconds from the start of the stream.
+    # Timestamps must not go backwards.
+    def write_frame(frame, timestamp_ms)
+      open_cluster(timestamp_ms) if start_new_cluster?(timestamp_ms)
+
+      # The block header is written separately from the frame so that the frame, which is by far
+      # the largest part, never has to be copied into another string.
+      @io.write(simple_block_header(frame.bytesize, timestamp_ms - @cluster_timestamp_ms))
+      @io.write(frame)
+    end
+
+    private
+
+    def write_header
+      @io.write(element(Id::EBML, [
+        element(Id::EBML_VERSION, uint(1)),
+        element(Id::EBML_READ_VERSION, uint(1)),
+        element(Id::EBML_MAX_ID_LENGTH, uint(4)),
+        element(Id::EBML_MAX_SIZE_LENGTH, uint(8)),
+        element(Id::DOC_TYPE, "matroska"),
+        element(Id::DOC_TYPE_VERSION, uint(4)),
+        element(Id::DOC_TYPE_READ_VERSION, uint(2))
+      ].join))
+
+      # Everything below lives inside the segment, which stays open until the file ends.
+      @io.write(id(Id::SEGMENT) + UNKNOWN_SIZE)
+
+      @io.write(element(Id::INFO, [
+        element(Id::TIMESTAMP_SCALE, uint(TIMESTAMP_SCALE_NS)),
+        element(Id::MUXING_APP, "test-recorder"),
+        element(Id::WRITING_APP, "test-recorder")
+      ].join))
+
+      @io.write(element(Id::TRACKS, element(Id::TRACK_ENTRY, [
+        element(Id::TRACK_NUMBER, uint(TRACK_NUMBER)),
+        element(Id::TRACK_UID, uint(TRACK_NUMBER)),
+        element(Id::TRACK_TYPE, uint(TRACK_TYPE_VIDEO)),
+        # Lacing packs several frames into one block. Each frame here is a whole picture with its
+        # own time, so it is turned off.
+        element(Id::FLAG_LACING, uint(0)),
+        element(Id::CODEC_ID, "V_MJPEG"),
+        # PixelWidth and PixelHeight are mandatory, but the frame size is not known before the
+        # first frame arrives, and the browser may change it mid recording. Every JPEG states its
+        # own size, so declare the smallest allowed picture and let the decoder use the real one.
+        # Declaring a plausible size instead is actively harmful: ffmpeg then compares it with the
+        # size it decodes and can read a shorter picture as one field of an interlaced frame.
+        element(Id::VIDEO, element(Id::PIXEL_WIDTH, uint(1)) + element(Id::PIXEL_HEIGHT, uint(1)))
+      ].join)))
+    end
+
+    def start_new_cluster?(timestamp_ms)
+      @cluster_timestamp_ms.nil? || timestamp_ms - @cluster_timestamp_ms > MAX_CLUSTER_DURATION_MS
+    end
+
+    def open_cluster(timestamp_ms)
+      @io.write(id(Id::CLUSTER) + UNKNOWN_SIZE)
+      @io.write(element(Id::TIMESTAMP, uint(timestamp_ms)))
+      @cluster_timestamp_ms = timestamp_ms
+    end
+
+    def simple_block_header(frame_length, relative_ms)
+      track = vint(TRACK_NUMBER)
+      # The payload is the track number, the 16 bit offset, the flags and then the frame itself.
+      size = track.bytesize + 2 + 1 + frame_length
+
+      id(Id::SIMPLE_BLOCK) + vint(size) + track + [relative_ms].pack("s>") + [KEYFRAME].pack("C")
+    end
+
+    # An element is its ID, then its length as a variable size integer, then its content.
+    def element(element_id, content)
+      id(element_id) + vint(content.bytesize) + content
+    end
+
+    # A variable size integer starts with a marker bit that says how many bytes it spans, and
+    # carries the value in the bits after it. A value that would fill every remaining bit is
+    # reserved to mean "unknown", so it needs one more byte.
+    def vint(value)
+      width = 1
+      width += 1 until value < (1 << (7 * width)) - 1
+
+      bytes = big_endian_bytes(value, width)
+      bytes[0] |= 1 << (8 - width)
+      bytes.pack("C*")
+    end
+
+    # Numbers are stored big endian, in as few bytes as they fit into.
+    def uint(value)
+      big_endian_bytes(value).pack("C*")
+    end
+    alias id uint
+
+    def big_endian_bytes(value, width = nil)
+      bytes = []
+      loop do
+        bytes.unshift(value & 0xFF)
+        value >>= 8
+        break if value.zero?
+      end
+      bytes.unshift(0) while width && bytes.size < width
+      bytes
+    end
+  end
+end

data/lib/test_recorder/rails/setup_and_teardown.rb

@@ -10,11 +10,11 @@ module TestRecorder
       end
 
       def before_teardown
-        if failures.empty?
-          @cdp_recorder.stop_and_discard
-        else
-          video_path = @cdp_recorder.stop_and_save("failures_#{self.name}.webm")
+        if failures.any? { |failure| !failure.is_a?(Minitest::Skip) }
+          video_path = @cdp_recorder.stop_and_save("failures_#{TestRecorder.sanitize_filename(self.name)}.webm")
           puts "[Video]: #{video_path}" if File.exist?(video_path)
+        else
+          @cdp_recorder.stop_and_discard
         end
       ensure
         super

data/lib/test_recorder/rails.rb

@@ -1,3 +1,4 @@
+require "test_recorder"
 require "test_recorder/cdp_recorder"
 require "test_recorder/rails/setup_and_teardown"
 

data/lib/test_recorder/rspec.rb

@@ -1,10 +1,9 @@
+require "test_recorder"
 require "test_recorder/cdp_recorder"
 require "test_recorder/rspec/example_wrapper"
 
 module TestRecorder
   module RSpec
-    CHARS_TO_TRANSLATE = ['/', '.', ':', ',', "'", '"', " "].freeze
-
     class << self
       attr_accessor :cdp_recorder
 
@@ -20,7 +19,7 @@ module TestRecorder
       end
 
       def method_name(example)
-        example.description.underscore.tr(CHARS_TO_TRANSLATE.join, "_")[0...200] + "_#{rand(1000)}"
+        TestRecorder.sanitize_filename(example.description.underscore)[0...200] + "_#{rand(1000)}"
       end
 
       def passed?(example)

data/lib/test_recorder/version.rb

@@ -1,3 +1,3 @@
 module TestRecorder
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/test_recorder.rb

@@ -1,7 +1,15 @@
 require "test_recorder/version"
 
 module TestRecorder
+  DEFAULT_JPEG_QUALITY = 60
+  DEFAULT_MAX_DIMENSION = 1000
+  DEFAULT_EVERY_NTH_FRAME = 1
+
+  CHARS_TO_TRANSLATE = ['/', '.', ':', ',', "'", '"', " "].freeze
+
   class << self
+    attr_writer :jpeg_quality, :max_dimension, :every_nth_frame
+
     def enable!
       @enable = true
     end
@@ -13,5 +21,21 @@ module TestRecorder
     def enabled?
       defined?(@enable) ? @enable : true
     end
+
+    def jpeg_quality
+      defined?(@jpeg_quality) ? @jpeg_quality : DEFAULT_JPEG_QUALITY
+    end
+
+    def max_dimension
+      defined?(@max_dimension) ? @max_dimension : DEFAULT_MAX_DIMENSION
+    end
+
+    def every_nth_frame
+      defined?(@every_nth_frame) ? @every_nth_frame : DEFAULT_EVERY_NTH_FRAME
+    end
+
+    def sanitize_filename(name)
+      name.tr(CHARS_TO_TRANSLATE.join, "_")
+    end
   end
 end

data/test-recorder.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Automatically record videos when tests failed.}
   spec.homepage      = "http://github.com/y-yagi/test-recorder"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: test-recorder
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Yuji Yaginuma
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,7 +65,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
 email:
 - yuuji.yaginuma@gmail.com
 executables: []
@@ -74,10 +72,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
+- ".github/workflows/push_gem.yml"
 - ".gitignore"
 - CHANGELOG.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -86,6 +84,8 @@ files:
 - lib/test-recorder.rb
 - lib/test_recorder.rb
 - lib/test_recorder/cdp_recorder.rb
+- lib/test_recorder/frame_writer.rb
+- lib/test_recorder/matroska_writer.rb
 - lib/test_recorder/rails.rb
 - lib/test_recorder/rails/setup_and_teardown.rb
 - lib/test_recorder/rspec.rb
@@ -97,7 +97,6 @@ licenses:
 - MIT
 metadata:
   homepage_uri: http://github.com/y-yagi/test-recorder
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -105,15 +104,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Automatically record videos when tests failed.
 test_files: []

data/Gemfile.lock

@@ -1,55 +0,0 @@
-PATH
-  remote: .
-  specs:
-    test-recorder (0.2.0)
-      activesupport
-      selenium-devtools
-      selenium-webdriver (>= 4.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (7.0.7)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 1.6, < 2)
-      minitest (>= 5.1)
-      tzinfo (~> 2.0)
-    activesupport-testing-metadata (0.1.0)
-      activesupport (>= 4.0)
-    concurrent-ruby (1.2.2)
-    debug (1.8.0)
-      irb (>= 1.5.0)
-      reline (>= 0.3.1)
-    i18n (1.14.1)
-      concurrent-ruby (~> 1.0)
-    io-console (0.6.0)
-    irb (1.7.4)
-      reline (>= 0.3.6)
-    minitest (5.19.0)
-    rake (12.3.3)
-    reline (0.3.8)
-      io-console (~> 0.5)
-    rexml (3.2.6)
-    rubyzip (2.3.2)
-    selenium-devtools (0.115.0)
-      selenium-webdriver (~> 4.2)
-    selenium-webdriver (4.11.0)
-      rexml (~> 3.2, >= 3.2.5)
-      rubyzip (>= 1.2.2, < 3.0)
-      websocket (~> 1.0)
-    tzinfo (2.0.6)
-      concurrent-ruby (~> 1.0)
-    websocket (1.2.9)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport-testing-metadata
-  debug
-  minitest (~> 5.0)
-  rake (~> 12.0)
-  test-recorder!
-
-BUNDLED WITH
-   2.4.3