fast_ci 0.1.2 → 1.0.1

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'rubycritic/cli/application'
+require 'fast_ci'
+require 'base64'
+require 'zlib'
+
+module FastCI
+  module RubyCritic
+    module Cli
+      class Application < ::RubyCritic::Cli::Application
+        def execute
+          events = []
+          events << ['ruby_critic_run'.upcase, {}]
+          status = super
+
+          content = File.read('tmp/rubycritic/report.json')
+          report = JSON.load(content)
+          modules = report['analysed_modules']
+          report['analysed_modules'] = {}
+          modules.each do |mod|
+            report['analysed_modules'][ mod['path'] ] = mod
+            mod['smells'].each do |smell|
+              location = smell['locations'].first
+              start_line = location['line'] - 1
+              end_line = start_line + 3
+              lines = File.readlines(location['path'])[start_line..end_line]
+              location['src'] = lines.join
+              smell['locations'][0] = location
+            end
+          end
+
+          compressed_data = ::Base64.strict_encode64(Zlib::Deflate.deflate(report.to_json, 9))
+          events << ['ruby_critic_exit_status'.upcase, ['0', { exitstatus: status, output: '', compressed_data: compressed_data }]]
+
+          if ENV['FSCI_REMOTE_TESTS'] == 'true'
+            json_events = {
+              build_id: FastCI.configuration.orig_build_id,
+              compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+            }
+      
+            FastCI.send_events(json_events)
+          else
+            FastCI.report_ruby_critic(compressed_data, 'passed')
+          end
+          return status
+        end
+      end
+    end
+  end
+end

data/lib/fast_ci/runner_prepend.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+require_relative "rspec_formatter"
+require_relative "extract_definitions"
+
+module FastCI
+  module RunnerPrepend
+    def run_specs(example_groups)
+      @rspec_started_at = Time.now
+      json_events = {
+        build_id: FastCI.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)),
+      }
+      FastCI.send_events(json_events)
+
+      examples_count = @world.example_count(example_groups)
+
+      example_groups = example_groups.reduce({}) do |acc, ex_group|
+        if acc[ex_group.file_path]
+          acc[ex_group.file_path] << ex_group
+        else
+          acc[ex_group.file_path] = [ex_group]
+        end
+        acc
+      end
+
+      FastCI.configure { |c| c.run_key = "rspec" }
+
+      FastCI.rspec_ws.on(:enq_request) do
+        example_groups.reduce({}) do |example_group_descriptions, (file, example_groups)|
+          example_groups.each do |example_group|
+            data = FastCI::ExtractDescriptions.new.call(example_group, count: true)
+
+            next if data[:test_count] == 0
+
+            if example_group_descriptions[file]
+              example_group_descriptions[file].merge!(data) do |k, v1, v2|
+                v1 + v2
+              end
+            else
+              example_group_descriptions[file] = data
+            end
+          end
+        example_group_descriptions
+        end
+      end
+
+      examples_passed = @configuration.reporter.report(examples_count) do |reporter|
+        @configuration.with_suite_hooks do
+          if examples_count == 0 && @configuration.fail_if_no_examples
+            return @configuration.failure_exit_code
+          end
+
+          formatter = FastCI::RspecFormatter.new(STDOUT)
+
+          reporter.register_listener(formatter, :example_finished)
+          if ENV['FSCI_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
+
+          FastCI.rspec_ws.on(:deq) do |tests|
+            tests.each do |test|
+              file, scoped_id = test.split(":", 2)
+              Thread.current[:fastci_scoped_ids] = scoped_id
+              example_groups[file].each do |file_group|
+                formatter.current_test_key = test
+
+                file_group.run(reporter)
+              end
+            end
+
+            formatter.dump_and_reset
+          end
+
+          FastCI.rspec_await
+
+          formatter.passed?
+        end
+      end
+
+      exit_code(examples_passed)
+    end
+
+    def exit_code(examples_passed=false)
+      if ENV['FSCI_REMOTE_TESTS'] == 'true'
+        run_time = Time.now - (@rspec_started_at || 1.seconds.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: FastCI.configuration.orig_build_id,
+          compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+        }
+        FastCI.send_events(json_events)
+      end
+
+      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/fast_ci/simple_cov/reporting.rb

@@ -0,0 +1,39 @@
+module FastCI
+  module SimpleCov
+    module Reporting
+      def self.included base
+        base.instance_eval do
+          unless (ENV['FAST_CI_SECRET_KEY'] || '').empty?
+            def write_last_run(result)
+              ::SimpleCov::LastRun.write(result:
+                result.coverage_statistics.transform_values do |stats|
+                  round_coverage(stats.percent)
+                end)
+
+              source = {}
+
+              result.source_files.each do |source_file|
+                source[source_file.filename.gsub(root, '')] = source_file.src
+              end
+
+              result_json = {}
+
+              result.as_json.each do |command, data|
+                result_json[command] = data
+                data['coverage'].clone.each do |src, file_data|
+                  result_json[command]['coverage'].delete(src)
+
+                  file_data['src'] = source[src.gsub(root, '')]
+
+                  result_json[command]['coverage'][src.gsub(root, '')] = file_data
+                end
+              end
+
+              FastCI.report_simplecov(result_json.to_json)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast_ci/simple_cov.rb

@@ -0,0 +1,68 @@
+require_relative "simple_cov/reporting"
+
+module FastCI
+  module SimpleCov
+    if ENV['FSCI_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: FastCI.configuration.orig_build_id,
+          compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+        }
+  
+        FastCI.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: FastCI.configuration.orig_build_id,
+            compressed_data: Base64.strict_encode64(Zlib::Deflate.deflate(JSON.fast_generate(events), 9)),
+          }
+    
+          FastCI.send_events(json_events)
+          super
+        end
+      end
+
+      ::SimpleCov::Result.prepend(Scf)
+    else
+      ::SimpleCov.send(:include, FastCI::SimpleCov::Reporting) unless ENV['DRYRUN'] == 'true'
+    end
+  end
+end

data/lib/fast_ci/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastCI
-  VERSION = "0.1.2"
+  VERSION = "1.0.1"
 end

data/lib/fast_ci.rb

@@ -3,10 +3,12 @@
 require_relative "fast_ci/version"
 require_relative "fast_ci/configuration"
 require_relative "fast_ci/exceptions"
+require_relative "minitest/reporters/FastCI_reporter"
 
 require "async"
 require "async/http/endpoint"
 require "async/websocket/client"
+require "net/http"
 
 module FastCI
   class Error < StandardError; end
@@ -20,27 +22,86 @@ module FastCI
       yield(configuration)
     end
 
-    def ws
-      @ws ||= WebSocket.new
+    def rspec_ws
+      @rspec_ws ||= WebSocket.new('rspec')
     end
 
-    def await
-      ws.await
+    def minitest_ws
+      @minitest_ws ||= WebSocket.new('minitest')
+    end
+
+    def report_simplecov(results)
+      post_report(report_options('simplecov', results))
+    end
+
+    def report_ruby_critic(compressed_data, status)
+      post_report(report_options('ruby_critic', compressed_data).merge({ status: status }))
+    end
+
+    def report_brakeman(compressed_data, status)
+      post_report(report_options('brakeman', compressed_data).merge({ status: status }))
+    end
+
+    def report_bundler_audit(compressed_data, status)
+      post_report(report_options('bundler_audit', compressed_data).merge({ status: status }))
+    end
+
+    def rspec_await
+      rspec_ws.await
+    end
+
+    def minitest_await
+      minitest_ws.await
     end
 
     def debug(msg)
-      puts "\n\e[36mDEBUG: \e[0m #{msg}\n" if ENV["FAST_CI_DEBUG"]
+      puts "\n\e[36mDEBUG: \e[0m #{msg}\n" if ENV["fast_ci_DEBUG"]
+    end
+
+    def report_options(run_key, content)
+      {
+        build_id: FastCI.configuration.build_id,
+        run_key: run_key,
+        secret_key: FastCI.configuration.secret_key,
+        branch: FastCI.configuration.branch,
+        commit: FastCI.configuration.commit,
+        commit_msg: FastCI.configuration.commit_msg,
+        author: FastCI.configuration.author.to_json,
+        content: content
+      }
+    end
+
+    def post_report(data)
+      uri = URI("#{FastCI.configuration.fastci_api_url}/api/runs")
+      res = Net::HTTP.post_form(uri, data)
+    end
+
+    def send_events(data)
+      reset_webmock = false
+      if defined?(WebMock)
+        reset_webmock = !WebMock.net_connect_allowed?
+        WebMock.allow_net_connect!
+      end
+
+      uri = URI("#{FastCI.configuration.fastci_main_url}/api/v1/gitlab_events")
+      res = Net::HTTP.post_form(uri, data)
+
+      if reset_webmock
+        WebMock.disable_net_connect!
+      end
     end
   end
 
   class WebSocket
     attr_reader :node_index
+    attr_accessor :connection, :task, :run_key
 
     SUPPORTED_EVENTS = %i[enq_request deq].freeze
 
-    def initialize
+    def initialize(run_key)
       @on = {}
       @ref = 0
+      @run_key = run_key
     end
 
     def on(event, &block)
@@ -50,34 +111,49 @@ module FastCI
       @on[event] = block
     end
 
-    def send_msg(connection, event, payload = {})
+    def send_msg(event, payload = {})
       FastCI.debug("ws#send_msg: #{event} -> #{payload.inspect}")
       connection.write({ "topic": topic, "event": event, "payload": payload, "ref": ref })
       connection.flush
     end
 
-    def await
-      before_start_connection
+    def connect_to_ws
       Async do |task|
+        before_start_connection
         Async::WebSocket::Client.connect(endpoint) do |connection|
           after_start_connection
-          send_msg(connection, "phx_join")
+          self.connection = connection
+          self.task = task
+          yield
+        ensure
 
+          leave
+        end
+      end
+    end
+
+    def await(retry_count = 0)
+      connect_to_ws do
+        send_msg("phx_join")
+
+        begin
           while message = connection.read
             FastCI.debug("ws#msg_received: #{message.inspect}")
 
             response = message.dig(:payload, :response)
 
             case response&.dig(:event) || message[:event]
+            when "phx_error"
+              raise("[FastCI] Unexpected error")
             when "join"
-              handle_join(connection, response)
+              handle_join(response)
             when "deq_request"
-              handle_deq_request(connection, response)
+              handle_deq_request(response)
             when "deq"
               if (tests = response[:tests]).any?
                 result = @on[:deq].call(tests)
                 task.async do
-                  send_msg(connection, "deq", result)
+                  send_msg("deq", result)
                 end
               else
                 break
@@ -88,15 +164,23 @@ module FastCI
               puts response
             end
           end
-        ensure
-          send_msg(connection, "leave")
-          connection.close
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+          task&.stop
         end
       end
     end
 
     private
 
+    def leave
+      send_msg("leave")
+      connection.close
+    rescue StandardError => e
+      # noop
+    end
+
     # https://github.com/bblimke/webmock/blob/b709ba22a2949dc3bfac662f3f4da88a21679c2e/lib/webmock/http_lib_adapters/async_http_client_adapter.rb#L8
     def before_start_connection
       if defined?(WebMock::HttpLibAdapters::AsyncHttpClientAdapter)
@@ -111,18 +195,18 @@ module FastCI
       end
     end
 
-    def handle_join(connection, response)
+    def handle_join(response)
       @node_index = response[:node_index]
 
       FastCI.debug("NODE_INDEX: #{@node_index}")
 
-      send_msg(connection, "enq", { tests: @on[:enq_request].call }) if node_index.zero?
+      send_msg("enq", { tests: @on[:enq_request].call }) if node_index.zero?
 
-      send_msg(connection, "deq") if response[:state] == "running"
+      send_msg("deq") if response[:state] == "running"
     end
 
-    def handle_deq_request(connection, _response)
-      send_msg(connection, "deq")
+    def handle_deq_request(_response)
+      send_msg("deq")
     end
 
     def ref
@@ -130,21 +214,23 @@ module FastCI
     end
 
     def topic
-      "test_orchestrator:#{FastCI.configuration.run_key}-#{FastCI.configuration.build_id}"
+      "test_orchestrator:#{run_key}-#{FastCI.configuration.build_id}"
     end
 
     def endpoint
       params = URI.encode_www_form({
                                      build_id: FastCI.configuration.build_id,
-                                     run_key: FastCI.configuration.run_key,
+                                     run_key: run_key,
                                      secret_key: FastCI.configuration.secret_key,
+                                     branch: FastCI.configuration.branch,
                                      commit: FastCI.configuration.commit,
-                                     branch: FastCI.configuration.branch
+                                     commit_msg: FastCI.configuration.commit_msg,
+                                     author: FastCI.configuration.author.to_json
                                    })
 
-      url = "ws://#{FastCI.configuration.api_url}/test_orchestrators/socket/websocket?#{params}"
+      url = "wss://#{FastCI.configuration.api_url}/test_orchestrators/socket/websocket?#{params}"
 
-      Async::HTTP::Endpoint.parse(url)
+      Async::HTTP::Endpoint.parse(url, alpn_protocols: Async::HTTP::Protocol::HTTP11.names)
     end
   end
 end