ruby_ci 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: deccb17205a9125cad4257da4d460cdcc1a254b38259a434813437f17e5ba1e8
-  data.tar.gz: 96457b78c8cdc5573e998ae65260c850dc2d1385fe21ae6f70592076d6efe728
+  metadata.gz: 3635c09d11258f3e066c50631d7a25eb3946512ea3eedb4e35b9e240797b1f85
+  data.tar.gz: fb84e77923af72c0c2b3568d87a3c78d2165c176b0c6dbb2a6e6124062a127bd
 SHA512:
-  metadata.gz: 54b2a36f99862e51470b1ca379da26fb993ea13308418417407bb52210230d18467b9873ba6965c9343422c22811794ed3873186ab496f8fbbbc75941f78c420
-  data.tar.gz: c28f203e0a2d7756544aa4085c10823ce290d43bee1b73923997f8aae53a8a62c200282f7ea66ef016698ffd60949c0ddb3a4107d7a924322b05248dbcbe5084
+  metadata.gz: 9efac45b1459e07557e0d766d767460b8ab179c1dd8c1afa7189d17b8067df2d790a34bc14c00d3f8a342b52b22905bf313fc63bdf8f0ecf0e9eb276da2ffcbe
+  data.tar.gz: fe6fc89c19b6716cd9b132fdf3ef748859966318cbc6de6bb69e5fe5b9740b57b0c6049d415b97c6569913b5c5373aa51d2834e328245dd6e6273b271c5b6d48

data/lib/minitest/reporters/rubyci_reporter.rb

@@ -1,5 +1,28 @@
 module Minitest
   module Reporters
+    class Suite
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+
+      def ==(other)
+        name == other.name
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        name.hash
+      end
+
+      def to_s
+        name.to_s
+      end
+    end
+
     class RubyciReporter
       attr_accessor :tests, :test_results, :ids
 
@@ -7,16 +30,40 @@ module Minitest
         @tests = {}
         @test_results = {}
         @ids = {}
+        @events = []
 
-        RubyCI.minitest_ws.on(:enq_request) do
-          tests
-        end
+        $stdout = StringIO.new()
 
-        RubyCI.minitest_ws.on(:deq) do |api_tests|
-          test_results
+        if ENV['RBCI_REMOTE_TESTS'] != 'true'
+          RubyCI.minitest_ws.on(:enq_request) do
+            tests
+          end
+
+          RubyCI.minitest_ws.on(:deq) do |api_tests|
+            test_results
+          end
         end
       end
 
+      def start
+        test_count = Runnable.runnables.sum { |s| s.runnable_methods.count }
+        msg('start', { test_count: test_count })
+      end
+      
+      def get_output
+        return if $stdout.pos == 0
+        $stdout.rewind
+        res = $stdout.read
+        $stdout.flush
+        $stdout.rewind
+        return unless res
+        res.strip.chomp if res.strip.chomp != ""
+      end
+      
+      def before_test(test)
+        $stdout = StringIO.new()
+      end
+
       def prerecord(klass, name)
         description = test_description(name)
         path = test_path(klass.name)
@@ -36,6 +83,7 @@ module Minitest
       end
 
       def record(result)
+        test_finished(result)
         description = test_description(result.name)
         id = ids[description]
         path = test_path(result.klass)
@@ -61,15 +109,133 @@ module Minitest
           test_results[path][:file_status] = file_status
         end
 
-        RubyCI.minitest_await
+
+        if ENV['RBCI_REMOTE_TESTS'] == 'true'
+          send_events
+        else
+          RubyCI.minitest_await
+        end
       end
 
       def method_missing(method, *args)
         return
       end
+      
+      protected
+
+      def before_suite(suite)
+      end
+
+      def after_suite(_suite)
+      end
+
+      def record_print_status(test)
+        test_name = test.name.gsub(/^test_: /, "test:")
+        print pad_test(test_name)
+        print_colored_status(test)
+        print(" (%.2fs)" % test.time) unless test.time.nil?
+        puts
+      end
+      
+      def record_print_failures_if_any(test)
+        if !test.skipped? && test.failure
+          print_info(test.failure, test.error?)
+          puts
+        end
+      end
+      
+      def screenshots_base64(output)
+        return unless output
+        img_path = output&.scan(/\\[Screenshot Image\\]: (.*)$/)&.flatten&.first&.strip&.chomp ||
+          output&.scan(/\\[Screenshot\\]: (.*)$/)&.flatten&.first&.strip&.chomp
+
+        if img_path && File.exist?(img_path)
+          STDOUT.puts "SCREENSHOT!"
+          Base64.strict_encode64(File.read(img_path))
+        end
+      end
+      
+      def test_finished(test)
+        output = get_output
+
+        location = if !test.source_location.join(":").start_with?(::Rails.root.join('vendor').to_s)
+                    test.source_location.join(":")
+                    else
+                    if (file = `cat #{::Rails.root.join('vendor', 'bundle', 'minitest_cache_file').to_s} | grep "#{test.klass} => "`.split(" => ").last&.chomp)
+                      file + ":"
+                    else
+                      file = `grep -rw "#{::Rails.root.to_s}" -e "#{test.klass} "`.split(":").first
+                      `echo "#{test.klass} => #{file}" >> #{::Rails.root.join('vendor', 'bundle', 'minitest_cache_file').to_s}`
+                      file + ":"
+                    end
+                    end
+
+        fully_formatted = if test.failure
+                            fully_formatted = "\n" + test.failure.message.split("\n").first
+
+                            test.failure.backtrace.each do |l|
+                              if !l["/cache/"]
+                                fully_formatted << "\n    " + cyan + l + "\033[0m"
+                              end
+                            end
+
+                            fully_formatted
+                          end
+
+                          output_inside = output&.split("\n")&.select do |line|
+                            !line["Screenshot"]
+                          end&.join("\n")
+        event_data = {
+          test_class: Suite.new(test.klass),
+          test_name: test.name.gsub(/^test_\\d*/, "").gsub(/^test_: /, "test:").gsub(/^_/, "").strip,
+          assertions_count: test.assertions,
+          location: location,
+          status: status(test),
+          run_time: test.time,
+          fully_formatted: fully_formatted,
+          output_inside: output_inside,
+          screenshots_base64: [screenshots_base64(output)]
+        }
+
+        msg('test_finished', event_data)
+        if ENV['RBCI_REMOTE_TESTS'] == 'true'
+          send_events if @events.length >= 10
+        end
+      end
+      
+      def status(test)
+        if test.passed?
+          "passed"
+        elsif test.error?
+          "error"
+        elsif test.skipped?
+          "skipped"
+        elsif test.failure
+          "failed"
+        else
+          raise("Status not found")
+        end
+      end
 
       private
 
+      def msg(event, data)
+        @events << ["minitest_#{event}".upcase, data]   
+      end
+
+      def send_events
+        return unless @events.length > 0
+    
+        json_events = {
+          build_id: RubyCI.configuration.orig_build_id,
+          compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(@events), 9)),
+        }
+  
+        RubyCI.send_events(json_events)
+  
+        @events = []
+      end
+
       def test_description(name)
         test_name = name.split('test_').last
         test_name = test_name[2..-1] if test_name.starts_with?(': ')

data/lib/ruby_ci/brakeman.rb

@@ -6,11 +6,25 @@ require 'zlib'
 module RubyCI
   module Brakeman
     def self.start
+      events = []
+      events << ['brakeman_run'.upcase, {}]
       RubyCI::Brakeman::Commandline.start(output_files: ['tmp/brakeman.json'], ensure_ignore_notes: false)
 
       content = File.read('tmp/brakeman.json')
       compressed_data = ::Base64.strict_encode64(Zlib::Deflate.deflate(content, 9))
-      RubyCI.report_brakeman(compressed_data, 'passed')
+
+      events << ['brakeman_exit_status'.upcase, ['0', { exitstatus: 0, stderr: '', output: '', compressed_data: compressed_data ]]
+
+      if ENV['RBCI_REMOTE_TESTS'] == 'true'
+        json_events = {
+          build_id: RubyCI.configuration.orig_build_id,
+          compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+        }
+  
+        RubyCI.send_events(json_events)
+      else
+        RubyCI.report_brakeman(compressed_data, 'passed')
+      end
     end
   end
 end

data/lib/ruby_ci/configuration.rb

@@ -3,7 +3,7 @@
 module RubyCI
   class Configuration
     attr_accessor :run_key, :build_id, :commit_msg, :commit, :branch,
-                  :api_url, :secret_key, :author
+                  :api_url, :secret_key, :author, :rubyci_main_url, :rubyci_api_url, :orig_build_id
 
     def initialize
       # Settings defaults
@@ -15,6 +15,9 @@ module RubyCI
       self.api_url = ENV["RUBY_CI_API_URL"] || "api.fast.ci"
       self.secret_key = ENV.fetch("RUBY_CI_SECRET_KEY")
       self.author = guess_author
+      self.rubyci_main_url = ENV.fetch('RUBYCI_MAIN_URL', 'https://events.ruby.ci')
+      self.rubyci_api_url = ENV.fetch('RUBYCI_API_RB_URL', 'https://fast.ruby.ci')
+      self.orig_build_id = ENV['RBCI_ORIG_BUILD_ID']
     end
 
     def reset

data/lib/ruby_ci/dryrun_runner_prepend.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative "rspec_formatter"
+require_relative "extract_definitions"
+
+module RubyCI
+  module DryrunRunnerPrepend
+    def run(err, out)
+      @rspec_started_at = Time.now
+      super
+    end
+
+    def exit_code(examples_passed=false)
+      run_time = Time.now - (@rspec_started_at || 1.second.ago)
+      events = @world.non_example_failure ? [['RSPEC_DRYRUN', { failed_after: run_time, test_env_number: ENV["TEST_ENV_NUMBER"], data: 'error' }]] : [['RSPEC_DRYRUN', { succeed_after: run_time, test_env_number: ENV["TEST_ENV_NUMBER"] }]]
+      STDOUT.puts events.inspect
+      json_events = {
+        build_id: RubyCI.configuration.orig_build_id,
+        compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+      }
+      RubyCI.send_events(json_events)
+
+      return @configuration.error_exit_code || @configuration.failure_exit_code if @world.non_example_failure
+      return @configuration.failure_exit_code unless examples_passed
+
+      0
+    end
+  end
+end

data/lib/ruby_ci/rspec_dryrun_formatter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RubyCI
+  class RspecDryrunFormatter
+    RSpec::Core::Formatters.register self,
+    :start,
+    :message,
+    :example_passed,
+    :example_failed,
+    :example_pending,
+    :example_group_finished,
+    :example_group_started,
+    :dump_summary,
+    :close
+
+    def initialize(output)
+      @output = output
+      @current_group_path = []
+      @current_file = nil
+      @current_file_count = 0
+      @events = []
+    end
+  
+    def message(message_notification)
+      @output.print message_notification.message
+      @output.print "\n"
+    end
+  
+    def start(example_count)
+      msg(:start, { "example_count" => example_count.count, "timestamp" => time_now })
+    end
+  
+    def close(*args)
+      msg(:close, { "timestamp" => time_now })
+      send_events
+    end
+  
+    def dump_summary(summary_notification)
+    end
+  
+    def time_now
+      time_frozen? ? Timecop.return { Time.now } : Time.now
+    end
+  
+    def time_frozen?
+      return unless defined?(Timecop)
+      Timecop.frozen?
+    end
+  
+    def example_passed(example_notification)
+      example_finished(example_notification)
+      @output.print RSpec::Core::Formatters::ConsoleCodes.wrap('.', :success)
+    end
+
+    def example_failed(example_notification)
+      example_finished(example_notification)
+      @output.print RSpec::Core::Formatters::ConsoleCodes.wrap('F', :failure)
+    end
+  
+    def example_pending(example_notification)
+      example_finished(example_notification)
+      @output.print RSpec::Core::Formatters::ConsoleCodes.wrap('*', :pending)
+    end
+  
+    def start_dump(_notification)
+      @output.print "\n"
+    end
+
+    def example_group_finished(_group_notification)
+      @current_group_path.pop
+      if @current_group_path.empty? # its a file
+        msg(:file_examples_count, [@current_file, @current_file_count])
+        @current_file_count = 0
+        @current_file = nil
+      end
+    end
+  
+    def example_group_started(group_notification)
+      if @current_group_path.size == 0
+        @current_file = group_notification.group.metadata[:file_path].gsub("./".freeze, "".freeze)
+        @current_file_count = 0
+      end
+      @current_group_path << 1
+    end
+
+    private
+  
+    def example_finished(example_notification)
+      @current_file_count += 1
+    end
+  
+    def send_events
+      return unless @events.length > 0
+  
+      json_events = {
+        build_id: RubyCI.configuration.orig_build_id,
+        compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(@events), 9)),
+      }
+
+      RubyCI.send_events(json_events)
+
+      @events = []
+    end
+  
+    def msg(event, data)
+      @events << ["rspec_dryrun_#{event}".upcase, ['0', data]]
+    end
+  
+    def get_scope_id(metadata)
+      metadata[:scoped_id].split(":").last || raise("No scoped id")
+    end
+  end
+end

data/lib/ruby_ci/rspec_formatter.rb

@@ -4,9 +4,57 @@ module RubyCI
   class RspecFormatter
     attr_reader :current_test_key
 
-    def initialize
-      @output = {}
+    def initialize(output)
+      @output = output
+      @event_output = {}
       @is_failed = false
+      @current_path = []
+      @current_path_started_at = []
+      @max_heap_live_num = 0
+      @dup_stdout = STDOUT.clone
+      @events = []
+
+      $stdout = StringIO.new()
+
+      @log_thread = Thread.new do
+        loop do
+          sleep 10
+          check_heap_live_num
+          @should_send_events = true
+        end
+      end
+    end
+
+    def time_now
+      time_frozen? ? Timecop.return { Time.now } : Time.now
+    end
+
+    def time_frozen?
+      return unless defined?(Timecop)
+      Timecop.frozen?
+    end
+
+    def rspec_runner_index
+      ENV["TEST_ENV_NUMBER"]
+    end
+
+    def send_events
+      @should_send_events = false
+  
+      if @events.length > 0
+        json_events = {
+          build_id: RubyCI.configuration.orig_build_id,
+          compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(@events), 9)),
+        }
+
+        RubyCI.send_events(json_events)
+
+        @events = []
+      end
+    end
+  
+    def check_heap_live_num
+      @max_heap_live_num = [@max_heap_live_num, GC.stat[:heap_live_slots] || GC.stat[:heap_live_num]].max
     end
 
     def passed?
@@ -17,13 +65,100 @@ module RubyCI
       @current_test_key = value
     end
 
+    def start(start_notification)
+      # $stderr = $stdout
+  
+      data = {
+        load_time: start_notification.load_time,
+        example_count: start_notification.count,
+        started_at: time_now.to_s
+      }
+  
+      return if running_only_failed? ||
+        running_gem_or_engine? ||
+        ENV["EXTRA_SLOWER_RUN"]
+  
+      msg(:start, data)
+    end
+  
+    def close(null_notification)
+      # check_heap_live_num
+      msg(:gc_stat, GC.stat.merge(max_heap_live_num: @max_heap_live_num))
+      unless running_only_failed? || ENV["EXTRA_SLOWER_RUN"] || running_gem_or_engine?
+        msg(:close, {final_output: get_output})
+      end
+      send_events
+      $stdout = @dup_stdout
+    end
+  
+    def example_group_started(group_notification)
+      metadata = group_notification.group.metadata
+      @current_path_started_at << time_now
+  
+      if @current_path.size == 0
+        @example_failed_index = 0
+        file_path = metadata[:file_path].gsub("./".freeze, "".freeze)
+        file_path = [ENV["DIR_PREFIX"], file_path].join("/") if ENV["DIR_PREFIX"]
+        @current_path << file_path
+      end
+  
+      @current_path << id(metadata)
+  
+      msg(:group_started, [
+        path_with_file(group_notification.group),
+        {
+          line_number: metadata[:line_number],
+          description: metadata[:description],
+        }
+      ])
+    end
+  
+    def example_started(example_notification)
+      @output_before = get_output
+    end
+  
+    def example_passed(example_notification)
+      metadata = example_notification.example.metadata
+      broadcast_example_finished(serialize_example(metadata, "passed".freeze), example_notification.example)
+    end
+  
+    def example_failed(example_notification)
+      @example_failed_index += 1
+      metadata = example_notification.example.metadata
+      fully_formatted = example_notification.fully_formatted(@example_failed_index, ::RSpec::Core::Formatters::ConsoleCodes)
+  
+      broadcast_example_finished(
+        serialize_example(metadata, "failed".freeze, fully_formatted),
+        example_notification.example
+      )
+    end
+  
+    def example_pending(example_notification)
+      metadata = example_notification.example.metadata
+      broadcast_example_finished(
+        serialize_example(metadata, "pending".freeze),
+        example_notification.example
+      )
+    end
+
+    def example_group_finished(group_notification)
+      run_time = time_now - @current_path_started_at.pop
+      if (run_time < 0) || (run_time > 2400)
+        run_time = 0.525
+      end
+        msg(:group_finished, [path_with_file(group_notification.group), {run_time: run_time}])
+        # msg(:group_finished, [@current_path.map(&:to_s), {run_time: run_time}])
+      @current_path.pop
+      @current_path.pop if @current_path.size == 1 # Remove the file_path at the beggining
+    end
+
     def example_finished(notification)
       example =  notification.example
       metadata = example.metadata
 
       *example_group_ids, example_id = metadata[:scoped_id].split(":")
 
-      file_output = @output[current_test_key] ||= {}
+      file_output = @event_output[current_test_key] ||= {}
 
       example_group = example_group_ids.reduce(file_output) do |output, scope_id|
         output[scope_id] ||= {}
@@ -49,9 +184,91 @@ module RubyCI
     end
 
     def dump_and_reset
-      output = @output
-      @output = {}
-      output
+      event_output = @event_output
+      @event_output = {}
+      event_output
+    end
+
+    def path_with_file(group)
+      file_path = group.parent_groups.last.file_path.gsub("./".freeze, "".freeze)
+  
+      group.metadata[:scoped_id].split(":").unshift(file_path)
+    end
+
+    private
+
+    def running_gem_or_engine?
+      !!ENV["DIR_PREFIX"]
+    end
+  
+    def running_only_failed?
+      !!ENV["RERUN_FAILED_FILES"]
+    end
+  
+    def serialize_example(metadata, status, fully_formatted = nil)
+      run_time = metadata[:execution_result].run_time
+      if (run_time < 0) || (run_time > 2400)
+        run_time = 0.525
+      end
+  
+      result = {
+        id: id(metadata),
+        status: status,
+        line_number: metadata[:line_number].to_s,
+        description: metadata[:description],
+        run_time: run_time,
+        fully_formatted: fully_formatted,
+        scoped_id: metadata[:scoped_id],
+      }.compact
+  
+      result[:gem_or_engine] = true if running_gem_or_engine?
+  
+      if running_only_failed?
+        result[:reruned] = true
+      elsif status == "failed" && !running_gem_or_engine?
+        File.write('tmp/rspec_failures', "#{@current_path.first}[#{metadata[:scoped_id]}]", mode: 'a+')
+      end
+  
+      if status == "failed"
+        img_path = metadata.dig(:screenshot, :image) ||
+          fully_formatted&.scan(/\[Screenshot Image\]: (.*)$/).flatten.first&.strip&.chomp ||
+          fully_formatted&.scan(/\[Screenshot\]: (.*)$/).flatten.first&.strip&.chomp
+  
+        if img_path && File.exist?(img_path)
+          STDOUT.puts "SCREENSHOT!"
+          result[:screenshots_base64] ||= []
+          result[:screenshots_base64] << Base64.strict_encode64(File.read(img_path))
+        end
+      end
+      @last_example_finished_at = time_now
+      # TODO annalyze this: run_time: metadata[:execution_result].run_time,
+      result
+    end
+
+    def msg(event, data)
+      @events << ["rspec_#{event}".upcase, [rspec_runner_index, data]]
+    end
+
+    def id(metadata)
+      metadata[:scoped_id].split(":").last || raise("No scoped id")
+    end
+
+    def broadcast_example_finished(data, example)
+      msg(:example_finished, [
+        path_with_file(example.example_group),
+        data.merge(output_inside: get_output, output_before: @output_before)
+      ])
+  
+      send_events if @should_send_events
+    end
+
+    def get_output
+      return if $stdout.pos == 0
+      $stdout.rewind
+      res = $stdout.read
+      $stdout.flush
+      $stdout.rewind
+      res
     end
   end
 end

data/lib/ruby_ci/ruby_critic/cli/application.rb

@@ -10,6 +10,8 @@ module RubyCI
     module Cli
       class Application < ::RubyCritic::Cli::Application
         def execute
+          events = []
+          events << ['ruby_critic_run'.upcase, {}]
           status = super
 
           content = File.read('tmp/rubycritic/report.json')
@@ -29,8 +31,18 @@ module RubyCI
           end
 
           compressed_data = ::Base64.strict_encode64(Zlib::Deflate.deflate(report.to_json, 9))
-          RubyCI.report_ruby_critic(compressed_data, 'passed')
+          events << ['ruby_critic_exit_status'.upcase, { exitstatus: status, output: '', compressed_data: compressed_data }]
 
+          if ENV['RBCI_REMOTE_TESTS'] == 'true'
+            json_events = {
+              build_id: RubyCI.configuration.orig_build_id,
+              compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+            }
+      
+            RubyCI.send_events(json_events)
+          else
+            RubyCI.report_ruby_critic(compressed_data, 'passed')
+          end
           return status
         end
       end

data/lib/ruby_ci/runner_prepend.rb

@@ -5,6 +5,13 @@ require_relative "extract_definitions"
 module RubyCI
   module RunnerPrepend
     def run_specs(example_groups)
+      @rspec_started_at = Time.now
+      json_events = {
+        build_id: RubyCI.configuration.orig_build_id,
+        compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate([['RSPEC_RUN', { started_at: @rspec_started_at, test_env_number: ENV["TEST_ENV_NUMBER"] }]]), 9)),
+      }
+      RubyCI.send_events(json_events)
+
       examples_count = @world.example_count(example_groups)
 
       example_groups = example_groups.reduce({}) do |acc, ex_group|
@@ -43,9 +50,19 @@ module RubyCI
             return @configuration.failure_exit_code
           end
 
-          formatter = RubyCI::RspecFormatter.new
+          formatter = RubyCI::RspecFormatter.new(STDOUT)
 
           reporter.register_listener(formatter, :example_finished)
+          if ENV['RBCI_REMOTE_TESTS'] == 'true'
+            reporter.register_listener(formatter, :start)
+            reporter.register_listener(formatter, :example_group_started)
+            reporter.register_listener(formatter, :example_started)
+            reporter.register_listener(formatter, :example_passed)
+            reporter.register_listener(formatter, :example_failed)
+            reporter.register_listener(formatter, :example_pending)
+            reporter.register_listener(formatter, :example_group_finished)
+            reporter.register_listener(formatter, :close)
+          end
 
           RubyCI.rspec_ws.on(:deq) do |tests|
             tests.each do |test|
@@ -71,6 +88,14 @@ module RubyCI
     end
 
     def exit_code(examples_passed=false)
+      run_time = Time.now - (@rspec_started_at || 1.second.ago)
+      events = @world.non_example_failure ? [['RSPEC_RUN', { failed_after: run_time, test_env_number: ENV["TEST_ENV_NUMBER"] }]] : [['RSPEC_RUN', { succeed_after: run_time, test_env_number: ENV["TEST_ENV_NUMBER"] }]]
+      json_events = {
+        build_id: RubyCI.configuration.orig_build_id,
+        compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+      }
+      RubyCI.send_events(json_events)
+
       return @configuration.error_exit_code || @configuration.failure_exit_code if @world.non_example_failure
       return @configuration.failure_exit_code unless examples_passed
 

data/lib/ruby_ci/simple_cov.rb

@@ -2,6 +2,67 @@ require_relative "simple_cov/reporting"
 
 module RubyCI
   module SimpleCov
-    ::SimpleCov.send(:include, RubyCI::SimpleCov::Reporting)
+    if ENV['RBCI_REMOTE_TESTS'] == 'true' && ENV["SIMPLECOV_ACTIVE"] && ENV['DRYRUN'] != 'true'
+      ::SimpleCov.send(:at_exit) do
+        ::SimpleCov.result.format!
+
+        config = {
+          minimum_coverage: ::SimpleCov.minimum_coverage,
+          maximum_coverage_drop: ::SimpleCov.maximum_coverage_drop,
+          minimum_coverage_by_file: ::SimpleCov.minimum_coverage_by_file,
+        }
+        rspec_runner_index = ENV["TEST_ENV_NUMBER".freeze].to_i
+        events = [['simplecov_config'.upcase, [ rspec_runner_index, config ]]]
+
+        json_events = {
+          build_id: RubyCI.configuration.orig_build_id,
+          compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+        }
+  
+        RubyCI.send_events(json_events)
+      end
+
+      module PrependSc
+        def start(*args, &block)
+          add_filter "tmp"
+          merge_timeout 3600
+          command_name "RSpec_#{ENV["TEST_ENV_NUMBER".freeze].to_i}"
+
+          if ENV["NO_COVERAGE"]
+            use_merging false
+            return
+          end
+          super
+        end
+      end
+      ::SimpleCov.singleton_class.prepend(PrependSc)
+
+      module Scf
+        def format!
+          return if ENV["NO_COVERAGE"]
+          rspec_runner_index = ENV["TEST_ENV_NUMBER".freeze].to_i
+
+          original_result_json = if ENV['CI_PROJECT_DIR'].present?
+            JSON.fast_generate(original_result.transform_keys {|key| key.sub(ENV['CI_PROJECT_DIR'], '/app') })
+          else
+            JSON.fast_generate(original_result)
+          end
+          compressed_data = Base64.strict_encode64(Zlib::Deflate.deflate(original_result_json, 9))
+          events = [['simplecov_result'.upcase, [ rspec_runner_index, compressed_data ]]]
+
+          json_events = {
+            build_id: RubyCI.configuration.orig_build_id,
+            compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+          }
+    
+          RubyCI.send_events(json_events)
+          super
+        end
+      end
+
+      ::SimpleCov::Result.prepend(Scf)
+    else
+      ::SimpleCov.send(:include, RubyCI::SimpleCov::Reporting) unless ENV['DRYRUN'] == 'true'
+    end
   end
 end

data/lib/ruby_ci/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyCI
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

data/lib/ruby_ci.rb

@@ -67,7 +67,12 @@ module RubyCI
     end
 
     def post_report(data)
-      uri = URI('https://fast.ruby.ci/api/runs')
+      uri = URI("#{RubyCI.configuration.rubyci_api_url}/api/runs")
+      res = Net::HTTP.post_form(uri, data)
+    end
+
+    def send_events(data)
+      uri = URI("#{RubyCI.configuration.rubyci_main_url}/api/v1/gitlab_events")
       res = Net::HTTP.post_form(uri, data)
     end
   end

data/ruby_ci.gemspec

@@ -30,5 +30,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "async-websocket", '<= 0.20.0'
   spec.add_dependency "rubycritic", "~> 4.8.0"
   spec.add_dependency "brakeman", "~> 5.4.1"
+  spec.add_dependency "minitest-rails", ">= 5.1"
   spec.add_development_dependency "pry"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_ci
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Ale ∴
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-29 00:00:00.000000000 Z
+date: 2024-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: console
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.4.1
+- !ruby/object:Gem::Dependency
+  name: minitest-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -109,8 +123,10 @@ files:
 - lib/ruby_ci/brakeman.rb
 - lib/ruby_ci/brakeman/commandline.rb
 - lib/ruby_ci/configuration.rb
+- lib/ruby_ci/dryrun_runner_prepend.rb
 - lib/ruby_ci/exceptions.rb
 - lib/ruby_ci/extract_definitions.rb
+- lib/ruby_ci/rspec_dryrun_formatter.rb
 - lib/ruby_ci/rspec_formatter.rb
 - lib/ruby_ci/ruby_critic/cli/application.rb
 - lib/ruby_ci/runner_prepend.rb