cyrun 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f36d84fb3bdf5d10aa072b188d2777c968004eadd8a6f9fcaf99369c03f1f08f
+  data.tar.gz: 24d85427355c870c69c0ad77e2d058a7ae5b8f5e1f5b21214efb87cb7ba12e60
+SHA512:
+  metadata.gz: a18ca4b67327cbe269aa455fb5fe2425874142cbcbe05b6e303856a1dd94160c3faa91d5314aace4558482d308e2c349505aa8f787549f5bbdab021827bdf794
+  data.tar.gz: baf623d30f79bea0a540115b7f184593e9d703aea7ee85ade631d01b7923518c5b75f046979c0afa7f972aa89742e1bfe94d7a540de1fd9e0671a6f9a46c5b31

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 2.6

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cyrun.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'
+
+gem 'minitest', '~> 5.0'
+
+gem 'standard', '~> 1.3'
+
+
+gem 'nokogiri'
+
+gem 'colorize'

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,31 @@
+# Cyrun
+
+cyrun is a command line utility to run and automatically retry failed cypress specs.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add cyrun
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install cyrun
+
+## Usage
+
+cyrun uses npm to run the specs. It will call: 
+
+```shell
+npm run <task-name-you-specify> -- --specs <list-of-specs-to-run> --config <screenshot-configuration> --headless --reporter junit --reporter-options <options>
+```
+
+So for example, cyrun could be used as follows:
+
+```shell
+cyrun --task npm-task-for-cypress --working-directory --pattern "apps/e2e/**/*.spec.ts"
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "standard/rake"
+
+task default: %i[test standard]

data/cyrun.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/cyrun/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'cyrun'
+  spec.version = Cyrun::VERSION
+  spec.authors = ['Oskar Kirmis']
+  spec.email = ['oskar.kirmis@posteo.de']
+
+  spec.summary = 'Run and retry cypress specs'
+  spec.description = 'Run cypress specs in batches and re-run specs or test them for stability.'
+  spec.homepage = 'https://git.iftrue.de/okirmis/cyrun'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://git.iftrue.de/okirmis/cyrun'
+  spec.metadata['changelog_uri'] = 'https://git.iftrue.de/okirmis/cyrun'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+end

data/exe/cyrun

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'cyrun'
+require 'optparse'
+
+npm_task_name = 'e2e'
+pattern = '*/**/*.cy.{ts,js}'
+working_directory = Dir.pwd
+results_directory = "#{Dir.pwd}/results"
+group_size = 10000
+max_retries = nil
+iterations = nil
+screenshots_directory = "#{Dir.pwd}/screenshots"
+screenshots_pattern = '*/**/screenshots/**/*.png'
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: cyrun [options]'
+
+  opts.on('-t', '--task TASK', String, 'NPM task to execute') do |t|
+    npm_task_name = t
+  end
+
+  opts.on('-p', '--pattern PATTERN', String, 'File path pattern') do |p|
+    pattern = p
+  end
+
+  opts.on('-w', '--working-directory DIRECTORY', String, 'Working directory') do |w|
+    working_directory = w
+  end
+
+  opts.on('-r', '--retries RETRIES', Integer, 'Maximum number of retries') do |r|
+    max_retries = r
+  end
+
+  opts.on('-g', '--group-size GROUPSIZE', Integer, 'Number of specs to process in a batch') do |g|
+    group_size = g
+  end
+
+  opts.on('-i', '--stable-runs ITERATIONS', Integer, 'Number of times the spec is run (an has to pass)') do |i|
+    iterations = i
+  end
+
+  opts.on('-d', '--results-directory DIRECTORY', String, 'Directory where to store the result files') do |d|
+    results_directory = d
+  end
+
+  opts.on('-s', '--screenshots-directory DIRECTORY', String, 'Directory where to store the screenshot files') do |d|
+    screenshots_directory = d
+  end
+
+  opts.on('--screenshots-pattern PATTERN', String, 'Glob pattern where to look for screenshots') do |p|
+    screenshots_pattern = p
+  end
+end.parse!
+
+if !iterations.nil? && !max_retries.nil?
+  Cyrun::Logger.error 'Only --iterations OR --retries can be specified.'
+  Kernel.exit!(-1)
+end
+
+max_retries = 1 if iterations.nil? && max_retries.nil?
+
+base_directory = File.expand_path(working_directory)
+Dir.chdir base_directory
+
+runner = Cyrun::Runner.new(
+  base_directory,
+  pattern,
+  screenshots_pattern,
+  group_size,
+  npm_task_name,
+  max_retries: max_retries,
+  iterations: iterations
+)
+runner.run
+runner.store_results(results_directory, screenshots_directory)

data/lib/cyrun/group_builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Cyrun
+  class GroupBuilder
+    def initialize(group_size)
+      @queue = []
+      @group_size = group_size
+    end
+
+    # @param [SpecTask] task
+    def add_task(task)
+      @queue.push task
+    end
+
+    def next_group
+      group = []
+      group.push @queue.shift while @queue.any? && group.size < @group_size
+      group
+    end
+
+    def any?
+      @queue.any?
+    end
+  end
+end

data/lib/cyrun/logger.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'colorize'
+
+module Cyrun
+  class Logger
+    def self.error(*message)
+      puts "[ERROR] #{message.map(&:to_s).join}".red
+    end
+
+    def self.info(*message)
+      puts "[INFO]  #{message.map(&:to_s).join}"
+    end
+  end
+
+  module Logging
+    def info(*args)
+      Logger.info(*args)
+    end
+
+    def error(*args)
+      Logger.error(*args)
+    end
+  end
+end

data/lib/cyrun/result_directory.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Cyrun
+  class ResultDirectory
+    attr_reader :temp_directory, :screenshots_pattern, :spec_tasks
+
+    def initialize(temp_directory, screenshots_pattern, spec_tasks)
+      @temp_directory = temp_directory
+      @spec_tasks = spec_tasks
+      @screenshots_pattern = screenshots_pattern
+    end
+
+    def read_result_files
+      absolute_filenames = Dir
+                           .glob('results-*.xml', base: temp_directory)
+                           .map { |filename| File.expand_path(filename, temp_directory) }
+
+      results = absolute_filenames
+                .map { |filename| read_result_file filename }
+                .reject(&:nil?)
+
+      spec_tasks.map do |task|
+        find_result_for_task(results, task) || create_failed_spec_result(task)
+      end
+    end
+
+    def screenshots
+      Dir
+        .glob(screenshots_pattern, base: Dir.pwd)
+        .map { |filename| File.expand_path(filename, Dir.pwd) }
+    end
+
+    protected
+
+    def read_result_file(absolute_path)
+      document = Nokogiri::XML(File.read(absolute_path))
+
+      failure_count = extract_failures_from_document document
+      time_in_seconds = extract_time_in_seconds_from_document document
+      filename = extract_filename_from_document document
+
+      spec = spec_tasks.detect { |task| task.filename.end_with?(File.basename(filename)) }
+      return nil if spec.nil?
+
+      SingleSpecExecutionResult.new(spec, absolute_path, time_in_seconds, failure_count.zero?)
+    end
+
+    def extract_failures_from_document(document)
+      document.css('testsuites').first.attr('failures').to_i
+    end
+
+    def extract_time_in_seconds_from_document(document)
+      document.css('testsuites').first.attr('time').to_f.round
+    end
+
+    # @param [Nokogiri::XML::Document] document
+    def extract_filename_from_document(document)
+      document.css('testsuite').first&.attr('file').to_s
+    end
+
+    private
+
+    def create_failed_spec_result(task)
+      SingleSpecExecutionResult.new(task, nil, 0.0, false)
+    end
+
+    def find_result_for_task(results, task)
+      results.detect { |result| result.task == task }
+    end
+  end
+end

data/lib/cyrun/runner.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Cyrun
+  class Runner
+    include Logging
+
+    attr_reader :collector, :group_builder, :task_runner,
+                :overall_results, :max_retries, :iterations
+
+    def initialize(base_directory, pattern, screenshots_pattern, group_size, npm_task_name, max_retries: nil, iterations: nil)
+      @collector = SpecCollector.new(base_directory, npm_task_name, [pattern])
+      @group_builder = GroupBuilder.new(group_size)
+      @task_runner = TaskRunner.new(screenshots_pattern)
+
+      @overall_results = SpecGroupExecutionResult.create_empty
+      @max_retries = max_retries
+      @iterations = iterations
+    end
+
+    def run
+      collect_specs
+      run_next_group while group_builder.any?
+
+      overall_results
+    end
+
+    def store_results(results_directory, screenshots_directory)
+      latest_results = overall_results.latest_results
+      invalid_results = latest_results.select { |result| result.result_filename.nil? }
+      valid_results = latest_results - invalid_results
+
+      copy_result_files valid_results, results_directory
+      copy_screenshots overall_results, screenshots_directory
+
+      invalid_results.empty?
+    end
+
+    private
+
+    def copy_result_files(results, directory)
+      FileUtils.mkdir_p directory
+
+      success = true
+
+      info "Copying #{results.size} result files"
+      results.each do |result|
+        FileUtils.cp(result.result_filename, directory)
+      rescue StandardError
+        error "Failed to copy results for #{result.task.filename}"
+        success = false
+      end
+
+      success
+    end
+
+    def copy_screenshots(results, directory)
+      FileUtils.mkdir_p directory
+
+      success = true
+
+      info "Copying #{results.screenshots.size} screenshots"
+      results.screenshots.each do |path|
+        FileUtils.cp(path, "#{directory}/#{SecureRandom.uuid}-#{File.basename(path)}")
+      rescue StandardError
+        error "Failed to copy screenshot #{path}"
+        success = false
+      end
+
+      success
+    end
+
+    def collect_specs
+      info 'Collecting specs ...'
+      collector.files.each do |filename|
+        info filename
+
+        group_builder.add_task(
+          collector.create_task(filename)
+        )
+      end
+
+      info "Collected #{collector.files.size} specs"
+    end
+
+    def run_next_group
+      group = group_builder.next_group
+      info("Running #{group.size} specs")
+      results = task_runner.run(group)
+      info('Group completed with the following results:')
+
+      overall_results.merge!(results)
+
+      results
+        .single_results
+        .each(&method(:handle_single_execution_result))
+
+      log_results overall_results
+    end
+
+    def handle_single_execution_result(result)
+      log_spec_result result
+      requeue_on_for_retries(result, overall_results, max_retries, group_builder) unless max_retries.nil?
+      requeue_for_iteration(result, overall_results, iterations, group_builder) unless iterations.nil?
+    end
+
+    def requeue_on_for_retries(result, overall_results, max_retries, group_builder)
+      return if result.success
+
+      if overall_results.task_fail_count(result.task) > max_retries
+        Cyrun::Logger.info("    -> Finally failed #{result.task.name}")
+      else
+        Cyrun::Logger.info("    -> Re-queuing #{result.task.name}")
+        group_builder.add_task result.task
+      end
+    end
+
+    def requeue_for_iteration(result, overall_results, iterations, group_builder)
+      if result.success
+        group_builder.add_task result.task if overall_results.task_result_count(result.task) < iterations
+      else
+        Cyrun::Logger.info("    -> Not re-queuing #{result.task.name}")
+      end
+    end
+
+    def log_results(overall_results)
+      info(
+        "Execution time: #{overall_results.gross_time_in_seconds} seconds, ",
+        "Spec time: #{overall_results.net_time_in_seconds} seconds, ",
+        "Effectiveness: #{(overall_results.effectiveness * 100).round} %"
+      )
+    end
+
+    def log_spec_result(result)
+      if result.success
+        info("  - Spec #{result.task.name} completed (#{result.net_time_in_seconds} seconds)")
+      else
+        info("  - Spec #{result.task.name} failed (#{result.net_time_in_seconds} seconds)")
+      end
+    end
+  end
+end

data/lib/cyrun/single_spec_execution_result.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Cyrun
+  class SingleSpecExecutionResult
+    attr_reader :task, :net_time_in_seconds, :success, :result_filename
+
+    def initialize(task, result_filename, net_time_in_seconds, success)
+      @task = task
+      @net_time_in_seconds = net_time_in_seconds
+      @success = success
+      @result_filename = result_filename
+    end
+  end
+end

data/lib/cyrun/spec_collector.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Cyrun
+  class SpecCollector
+    attr_reader :patterns, :base_directory, :npm_task_name
+
+    def initialize(base_directory, npm_task_name, patterns)
+      @patterns = patterns
+      @npm_task_name = npm_task_name
+      @base_directory = base_directory
+    end
+
+    def files
+      @files ||= patterns
+                 .map { |pattern| Dir.glob(pattern, base: base_directory) }
+                 .flatten
+                 .map { |filename| File.expand_path(filename, base_directory) }
+    end
+
+    def create_task(filename)
+      SpecTask.new(filename, @npm_task_name)
+    end
+  end
+end

data/lib/cyrun/spec_group_execution_result.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Cyrun
+  class SpecGroupExecutionResult
+    attr_reader :single_results, :screenshots, :gross_time_in_seconds
+
+    def self.create_empty
+      SpecGroupExecutionResult.new([], [], 0)
+    end
+
+    def initialize(single_results, screenshots, gross_time_in_seconds)
+      @single_results = single_results
+      @gross_time_in_seconds = gross_time_in_seconds
+      @screenshots = screenshots
+    end
+
+    def net_time_in_seconds
+      single_results.map(&:net_time_in_seconds).sum
+    end
+
+    def effectiveness
+      return 0.0 if gross_time_in_seconds.zero?
+
+      net_time_in_seconds.to_f / gross_time_in_seconds
+    end
+
+    def merge!(other)
+      @single_results += other.single_results
+      @gross_time_in_seconds += other.gross_time_in_seconds
+      @screenshots += other.screenshots
+    end
+
+    def task_fail_count(task)
+      single_results
+        .select { |result| !result.success && result.task == task }
+        .size
+    end
+
+    def task_result_count(task)
+      task_results(task).size
+    end
+
+    def task_results(task)
+      single_results
+        .select { |result| result.task == task }
+    end
+
+    def latest_results
+      tasks = single_results.map(&:task).uniq
+
+      tasks.map do |task|
+        task_results(task).last
+      end
+    end
+  end
+end

data/lib/cyrun/spec_task.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cyrun
+  class SpecTask
+    attr_reader :filename, :npm_task_name
+
+    def initialize(filename, npm_task_name)
+      @filename = filename
+      @npm_task_name = npm_task_name
+    end
+
+    def name
+      File.basename(filename)
+    end
+  end
+end

data/lib/cyrun/task_runner.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'tmpdir'
+require 'securerandom'
+require 'time'
+
+module Cyrun
+  class TaskRunner
+    include Logging
+
+    CURRENT_SPEC_REGEX = /^\s*Running:\s+(\S+)\s+\([0-9]+ of [0-9]+\)\s*$/.freeze
+
+    attr_reader :screenshots_pattern
+
+    def initialize(screenshots_pattern)
+      @screenshots_pattern = screenshots_pattern
+    end
+
+    def run(group)
+      temp_directory = create_directory
+      command = build_command(group, temp_directory)
+
+      info "Command: #{command.join " "}"
+
+      execution_time = Cyrun::Timing.run do
+        execute_command command
+      end
+
+      results = ResultDirectory.new(temp_directory, screenshots_pattern, group)
+      SpecGroupExecutionResult.new(
+        results.read_result_files,
+        results.screenshots,
+        execution_time
+      )
+    end
+
+    protected
+
+    def create_directory
+      Dir.mktmpdir(SecureRandom.uuid)
+    end
+
+    def build_command(spec_tasks, temp_directory)
+      [
+        'npm', 'run', spec_tasks.first&.npm_task_name, '--'
+      ] +
+        build_spec_arguments(spec_tasks) +
+        build_reporter_options(temp_directory)
+    end
+
+    def build_spec_arguments(spec_tasks)
+      ['--spec', spec_tasks.map(&:filename).join(',')]
+    end
+
+    def build_reporter_options(temp_directory)
+      ['--headless', '--reporter', 'junit', '--reporter-options',
+       "mochaFile=#{temp_directory}/results-[hash].xml,toConsole=true"]
+    end
+
+    private
+
+    def execute_command(command)
+      output = []
+
+      # @type [IO]
+      process = IO.popen(command, err: %i[child out])
+      output.push process_command_output_line(process.gets) until process.eof?
+      process.close
+
+      return if $CHILD_STATUS.success?
+
+      Logger.error('Command failed')
+      Logger.error(output.join("\n"))
+    end
+
+    def process_command_output_line(line)
+      line ||= ''
+      current_spec_parts = line.scan CURRENT_SPEC_REGEX
+
+      Logger.info('  - Running ', current_spec_parts.first&.first) if current_spec_parts.any?
+
+      line
+    end
+  end
+end

data/lib/cyrun/timing.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Cyrun
+  module Timing
+    def self.run
+      start_time = Time.now.to_i
+
+      yield
+
+      end_time = Time.now.to_i
+      end_time - start_time
+    end
+  end
+end

data/lib/cyrun/version.rb

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

data/lib/cyrun.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'cyrun/version'
+require_relative 'cyrun/timing'
+require_relative 'cyrun/logger'
+require_relative 'cyrun/result_directory'
+require_relative 'cyrun/group_builder'
+require_relative 'cyrun/task_runner'
+require_relative 'cyrun/spec_collector'
+require_relative 'cyrun/spec_task'
+require_relative 'cyrun/single_spec_execution_result'
+require_relative 'cyrun/spec_group_execution_result'
+require_relative 'cyrun/runner'
+
+module Cyrun
+end

data/rbs_collection.yaml

@@ -0,0 +1,15 @@
+# Download sources
+sources:
+  - name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  # Skip loading rbs gem's RBS.
+  # It's unnecessary if you don't use rbs as a library.
+  - name: rbs
+    ignore: true

data/sig/cyrun/logging.rbs

@@ -0,0 +1,6 @@
+module Cyrun
+  module Logging
+    def error: (*String? message) -> void
+    def info: (*String? message) -> void
+  end
+end

data/sig/cyrun.rbs

@@ -0,0 +1,4 @@
+module Cyrun
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/sig/group_builder.rbs

@@ -0,0 +1,12 @@
+module Cyrun
+  class GroupBuilder
+    @group_size: Integer
+    @queue: Array[SpecTask]
+
+    def add_task: (task: SpecTask) -> void
+
+    def any?: -> bool
+
+    def next_group: -> Array[SpecTask]
+  end
+end

data/sig/logger.rbs

@@ -0,0 +1,6 @@
+module Cyrun
+  class Logger
+    def self.error: (*String? message) -> void
+    def self.info: (*String? message) -> void
+  end
+end

data/sig/result_directory.rbs

@@ -0,0 +1,23 @@
+module Cyrun
+  class ResultDirectory
+    attr_reader spec_tasks: Array[SpecTask]
+    attr_reader temp_directory: String
+    attr_reader screenshots_pattern: String
+
+    def initialize: (String, String, Array[SpecTask]) -> void
+
+    def extract_failures_from_document: (Nokogiri::XML::Document) -> Integer
+    def extract_filename_from_document: (Nokogiri::XML::Document) -> String
+    def extract_time_in_seconds_from_document: (Nokogiri::XML::Document) -> Float
+
+    def read_result_file: (String) -> SingleSpecExecutionResult?
+
+    def read_result_files: -> Array[SingleSpecExecutionResult]
+    def screenshots: -> Array[String]
+
+    private
+
+    def find_result_for_task: (Array[SingleSpecExecutionResult], SpecTask) -> SingleSpecExecutionResult?
+    def create_failed_spec_result: (SpecTask) -> SingleSpecExecutionResult
+  end
+end

data/sig/runner.rbs

@@ -0,0 +1,34 @@
+module Cyrun
+  class Runner
+
+    attr_reader collector: SpecCollector
+    attr_reader group_builder: GroupBuilder
+    attr_reader iterations: Integer?
+    attr_reader max_retries: Integer?
+    attr_reader npm_task_name: String
+    attr_reader overall_results: SpecGroupExecutionResult
+    attr_reader task_runner: TaskRunner
+
+    def initialize: (String, String, String, Integer, String, max_retries: Integer?, iterations: Integer?) -> void
+
+    def store_results: (String, String)-> bool
+
+    def run: -> SpecGroupExecutionResult
+
+    private
+
+    def collect_specs: (String) -> void
+
+    def copy_result_files: (Array[SingleSpecExecutionResult], String) -> bool
+    def copy_screenshots: (SpecGroupExecutionResult, String) -> bool
+
+    def handle_single_execution_result: (SingleSpecExecutionResult) -> void
+    def log_results: (SpecGroupExecutionResult) -> void
+    def log_spec_result: (SingleSpecExecutionResult) -> void
+
+    def requeue_on_for_retries: (SingleSpecExecutionResult, SpecGroupExecutionResult, Integer, GroupBuilder) -> void
+    def requeue_for_iteration: (SingleSpecExecutionResult, SpecGroupExecutionResult, Integer, GroupBuilder) -> void
+
+    def run_next_group: -> void
+  end
+end

data/sig/single_spec_execution_result.rbs

@@ -0,0 +1,10 @@
+module Cyrun
+  class SingleSpecExecutionResult
+    attr_reader net_time_in_seconds: Float
+    attr_reader result_filename: String?
+    attr_reader success: bool
+    attr_reader task: SpecTask
+
+    def initialize: (SpecTask, String?, Float, bool) -> void
+  end
+end

data/sig/spec_collector.rbs

@@ -0,0 +1,18 @@
+module Cyrun
+  class SpecCollector
+    @base_directory: String
+    @files: Array[String]
+    @npm_task_name: String
+    @patterns: Array[String]
+
+    attr_reader base_directory: String
+    attr_reader npm_task_name: String
+    attr_reader patterns: String
+
+    def initialize: (base_directory: String, patterns: Array[String]) -> void
+
+    def create_task: (String) -> SpecTask
+
+    def files: -> Array[String]
+  end
+end

data/sig/spec_group_execution_result.rbs

@@ -0,0 +1,18 @@
+module Cyrun
+  class SpecGroupExecutionResult
+    def self.create_empty: -> SpecGroupExecutionResult
+
+    attr_reader gross_time_in_seconds: Integer
+    attr_reader screenshots: Array[String]
+    attr_reader single_results: Array[SingleSpecExecutionResult]
+
+    def initialize: (Array[SingleSpecExecutionResult], Array[String], Integer) -> void
+    def effectiveness: -> Float
+    def merge!: (SpecGroupExecutionResult)-> void
+    def net_time_in_seconds: -> Integer
+    def task_fail_count: (SpecTask) -> Integer
+    def task_result_count: (SpecTask) -> Integer
+    def task_results: (SpecTask) -> Array[SingleSpecExecutionResult]
+    def latest_results: -> Array[SingleSpecExecutionResult]
+  end
+end

data/sig/spec_task.rbs

@@ -0,0 +1,10 @@
+module Cyrun
+  class SpecTask
+
+    attr_reader base_directory: String
+    attr_reader filename: String
+    attr_reader npm_task_name: String
+
+    def name: -> String
+  end
+end

data/sig/task_runner.rbs

@@ -0,0 +1,22 @@
+module Cyrun
+  class TaskRunner
+    CURRENT_SPEC_REGEX: Regexp
+
+    attr_reader screenshots_pattern: String
+
+    def build_command: (Array[SpecTask], String) -> Array[String]
+    def build_reporter_options: (String) -> Array[String]
+
+    def build_spec_arguments: (Array[SpecTask]) -> Array[String]
+
+    def create_directory: -> String
+
+
+    def run: (Array[SpecTask]) -> SpecGroupExecutionResult
+
+    private
+
+    def execute_command: (Array[String]) -> void
+    def process_command_output_line: (String?) -> String
+  end
+end

data/sig/timing.rbs

@@ -0,0 +1,5 @@
+module Cyrun
+  module Timing
+    def self.run: { () -> void } -> Integer
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: cyrun
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Oskar Kirmis
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-04-24 00:00:00.000000000 Z
+dependencies: []
+description: Run cypress specs in batches and re-run specs or test them for stability.
+email:
+- oskar.kirmis@posteo.de
+executables:
+- cyrun
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cyrun.gemspec
+- exe/cyrun
+- lib/cyrun.rb
+- lib/cyrun/group_builder.rb
+- lib/cyrun/logger.rb
+- lib/cyrun/result_directory.rb
+- lib/cyrun/runner.rb
+- lib/cyrun/single_spec_execution_result.rb
+- lib/cyrun/spec_collector.rb
+- lib/cyrun/spec_group_execution_result.rb
+- lib/cyrun/spec_task.rb
+- lib/cyrun/task_runner.rb
+- lib/cyrun/timing.rb
+- lib/cyrun/version.rb
+- rbs_collection.yaml
+- sig/cyrun.rbs
+- sig/cyrun/logging.rbs
+- sig/group_builder.rbs
+- sig/logger.rbs
+- sig/result_directory.rbs
+- sig/runner.rbs
+- sig/single_spec_execution_result.rbs
+- sig/spec_collector.rbs
+- sig/spec_group_execution_result.rbs
+- sig/spec_task.rbs
+- sig/task_runner.rbs
+- sig/timing.rbs
+homepage: https://git.iftrue.de/okirmis/cyrun
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://git.iftrue.de/okirmis/cyrun
+  source_code_uri: https://git.iftrue.de/okirmis/cyrun
+  changelog_uri: https://git.iftrue.de/okirmis/cyrun
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.13
+signing_key:
+specification_version: 4
+summary: Run and retry cypress specs
+test_files: []