blinka-reporter 0.5.2 → 0.7.0

data/lib/blinka_reporter/blinka.rb

@@ -0,0 +1,172 @@
+require 'httparty'
+require 'blinka_reporter/error'
+
+module BlinkaReporter
+  class Blinka
+    SUPPORTED_MIME_TYPES = {
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      png: 'image/png'
+    }
+
+    include HTTParty
+
+    def self.report(data:, config:)
+      Blinka.new(data: data, config: config).report
+    end
+
+    def initialize(data:, config:)
+      @data = data
+      @config = config
+      self.class.base_uri("#{@config.host}/api/v1")
+    end
+
+    def report
+      if ENV.fetch('BLINKA_ALLOW_WEBMOCK_DISABLE', 'true') == 'true' &&
+           defined?(WebMock) && WebMock.respond_to?(:disable!)
+        WebMock.disable!
+      end
+
+      @config.validate_blinka
+      self.authenticate
+
+      results =
+        @data
+          .fetch(:results, [])
+          .map do |result|
+            if !result[:image].nil?
+              result[:image] = Blinka.upload_image(filepath: result[:image])
+              result
+            else
+              result
+            end
+          end
+
+      body = {
+        report: {
+          repository: @config.repository,
+          tag: @config.tag,
+          commit: @config.commit,
+          metadata: {
+            total_time: @data[:total_time],
+            nbr_tests: @data[:nbr_tests],
+            nbr_assertions: @data[:nbr_assertions],
+            seed: @data[:seed]
+          }.compact,
+          results: results
+        }
+      }
+
+      response =
+        self.class.post(
+          '/report',
+          body: body.to_json,
+          headers: {
+            'Content-Type' => 'application/json',
+            'Authorization' => "Bearer #{@jwt_token}"
+          }
+        )
+      case response.code
+      when 200
+        puts "Reported #{@data[:nbr_tests]} tests of commit #{@config.commit}!"
+      else
+        raise(
+          BlinkaReporter::Error,
+          "Could not report, got response code #{response.code}"
+        )
+      end
+    rescue => error
+      raise(BlinkaReporter::Error, <<-EOS)
+        BLINKA:
+          Failed to create report because of #{error.class} with message:
+          #{error.message}
+        EOS
+    ensure
+      WebMock.enable! if defined?(WebMock) && WebMock.respond_to?(:enable!)
+    end
+
+    def authenticate
+      response =
+        self.class.post(
+          '/authentication',
+          body: {
+            token_id: @config.team_id,
+            token_secret: @config.team_secret
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+      case response.code
+      when 200
+        @jwt_token = JSON.parse(response.body).dig('auth_token')
+      else
+        raise(
+          BlinkaReporter::Error,
+          "Could not authenticate to API #{response.code}"
+        )
+      end
+    end
+
+    def self.upload_image(filepath:)
+      return unless File.exist?(filepath)
+
+      file = File.open(filepath)
+      filename = File.basename(filepath)
+      extension = File.extname(filepath).delete('.').to_sym
+      content_type = SUPPORTED_MIME_TYPES[extension]
+      return if content_type.nil?
+
+      presigned_post =
+        Blinka.presign_image(filename: filename, content_type: content_type)
+      Blinka.upload_to_storage(presigned_post: presigned_post, file: file)
+
+      puts "Uploaded: #{filename}"
+      Blinka.to_shrine_object(
+        presigned_post: presigned_post,
+        file: file,
+        filename: filename
+      )
+    end
+
+    def self.presign_image(filename:, content_type:)
+      response =
+        self.get(
+          '/presign',
+          body: { filename: filename, content_type: content_type }
+        )
+
+      case response.code
+      when 200
+        JSON.parse(response.body)
+      else
+        raise(BlinkaReporter::Error, 'Could not presign file')
+      end
+    end
+
+    def self.upload_to_storage(presigned_post:, file:)
+      url = URI.parse(presigned_post.fetch('url'))
+
+      body = presigned_post['fields'].merge({ 'file' => file.read })
+      response = HTTParty.post(url, multipart: true, body: body)
+
+      case response.code
+      when 204
+        true
+      else
+        raise(BlinkaReporter::Error, 'Could not upload file to storage')
+      end
+    end
+
+    def self.to_shrine_object(presigned_post:, file:, filename:)
+      storage, idx = presigned_post.dig('fields', 'key').split('/')
+      {
+        "id": idx,
+        "storage": storage,
+        "metadata": {
+          "size": file.size,
+          "filename": filename,
+          "mime_type": presigned_post.dig('fields', 'Content-Type')
+        }
+      }
+    end
+  end
+end

data/lib/blinka_reporter/cli.rb

@@ -0,0 +1,66 @@
+require 'blinka_reporter/client'
+require 'blinka_reporter/version'
+
+module BlinkaReporter
+  class Cli
+    def self.run(argv)
+      if (argv.index('--help') || -1) >= 0
+        puts(<<~EOS)
+          blinka_reporter version #{BlinkaReporter::VERSION}
+
+          Options:
+          --path <path>: Path to test results file, can be supplied multiple times to combine results
+            - ./blinka_results.json blinka json format
+            - ./rspec.xml from https://github.com/sj26/rspec_junit_formatter
+
+          --tap: Flag for outputting test results in TAP-protocol, helpful on Heroku CI
+          --blinka: Flag for reporting test results to blinka.app, requires also supplying:
+            - --team-id
+            - --team-secret
+            - --repository
+            - --commit
+          --team-id <team-id>: Blinka team id, only used with --blinka
+          --team-secret <team-secret>: Blinka team secret, only used with --blinka
+          --commit <commit>: The commit hash to report
+          --tag <tag>: The tag for the run, for example to separate a test matrix
+          --repository <repository>: The Github repository
+          --host <host>: Override Blink host to send report
+
+        EOS
+        return 0
+      end
+
+      tap = (argv.index('--tap') || -1) >= 0
+
+      paths = argv_value_for(argv, '--path')
+
+      blinka = (argv.index('--blinka') || -1) >= 0
+      commit = argv_value_for(argv, '--commit')&.first
+      repository = argv_value_for(argv, '--repository')&.first
+      tag = argv_value_for(argv, '--tag')&.first
+      team_id = argv_value_for(argv, '--team-id')&.first
+      team_secret = argv_value_for(argv, '--team-secret')&.first
+      host = argv_value_for(argv, '--host')&.first
+
+      client = BlinkaReporter::Client.new
+      data = client.parse(paths: paths)
+      config =
+        BlinkaReporter::Config.new(
+          tag: tag,
+          commit: commit,
+          team_id: team_id,
+          team_secret: team_secret,
+          repository: repository,
+          host: host
+        )
+      client.report(data: data, config: config, tap: tap, blinka: blinka)
+    end
+
+    def self.argv_value_for(argv, option_name)
+      argv
+        .each_index
+        .select { |index| argv[index] == option_name }
+        .map { |index| argv[index + 1] }
+    end
+  end
+end

data/lib/blinka_reporter/client.rb

@@ -0,0 +1,128 @@
+require 'httparty'
+require 'ox'
+
+require 'blinka_reporter/blinka'
+require 'blinka_reporter/config'
+require 'blinka_reporter/error'
+require 'blinka_reporter/tap'
+
+module BlinkaReporter
+  class Client
+    def parse(paths: nil)
+      paths ||= ['./blinka_results.json']
+      paths = Array(paths)
+      paths.each do |path|
+        unless File.exist?(path)
+          raise(
+            BlinkaReporter::Error,
+            "Could not find #{path}, make sure the path is correct."
+          )
+        end
+      end
+
+      merge_results(
+        paths.map do |path|
+          if path.end_with?('.xml')
+            parse_xml(path: path)
+          elsif path.end_with?('.json')
+            parse_json(path: path)
+          else
+            raise(
+              BlinkaReporter::Error,
+              "Unknown format of #{path}, needs to be .json or .xml"
+            )
+          end
+        end
+      )
+    end
+
+    def report(data:, blinka: false, tap: false, config: nil)
+      BlinkaReporter::Tap.report(data) if tap
+      BlinkaReporter::Blinka.report(config: config, data: data) if blinka
+      0
+    end
+
+    private
+
+    def merge_results(data_array)
+      data = { total_time: 0, nbr_tests: 0, nbr_assertions: 0, results: [] }
+      data_array.each do |result|
+        data[:total_time] += result[:total_time] || 0
+        data[:nbr_tests] += result[:nbr_tests] || 0
+        data[:nbr_assertions] += result[:nbr_assertions] || 0
+        data[:results] += result[:results] || []
+      end
+      data
+    end
+
+    def parse_json(path:)
+      JSON.parse(File.open(path).read, symbolize_names: true)
+    end
+
+    def parse_xml(path:)
+      data = Ox.load_file(path, { symbolize_keys: true, skip: :skip_none })
+      test_suite = data.root
+      unless test_suite.name == 'testsuite'
+        raise("Root element is not <testsuite>, instead #{test_suite.name}")
+      end
+
+      properties = test_suite.nodes.select { |node| node.name == 'properties' }
+      test_cases = test_suite.nodes.select { |node| node.name == 'testcase' }
+      {
+        nbr_tests: Integer(test_suite.tests || 0),
+        total_time: Float(test_suite.time),
+        seed: xml_seed(properties),
+        results: xml_test_cases(test_cases)
+      }
+    end
+
+    def xml_seed(ox_properties)
+      ox_properties.each do |property|
+        property.nodes.each do |node|
+          return node.attributes[:value] if node.attributes[:name] == 'seed'
+        end
+      end
+      nil
+    end
+
+    # Kind is extracted from the second part of spec.models.customer_spec
+    def xml_test_cases(test_cases)
+      test_cases.map do |test_case|
+        result = {
+          kind: Array(test_case.attributes[:classname]&.split('.'))[1],
+          name: test_case.attributes[:name],
+          path: test_case.attributes[:file]&.delete_prefix('./'),
+          time: Float(test_case.attributes[:time] || 0)
+        }
+        if test_case.nodes.any?
+          skipped = test_case.nodes.any? { |node| node.name == 'skipped' }
+          result[:result] = 'skip' if skipped
+          failure =
+            test_case.nodes.select { |node| node.name == 'failure' }.first
+          if failure
+            result[:result] = 'fail'
+
+            # Needs to be double quotation marks to work properly
+            result[:backtrace] = failure.text.split("\n")
+            result[:image] = get_image_path(result[:backtrace])
+            result[:message] = failure.attributes[:message]
+          end
+        else
+          result[:result] = 'pass'
+        end
+        result
+      end
+    end
+
+    def get_image_path(backtrace)
+      backtrace.each do |text|
+        path = /^(\[Screenshot\]|\[Screenshot Image\]):\s([\S]*)$/.match(text)
+        next if path.nil?
+        path = path[-1]
+        next unless File.exist?(path)
+        return path
+      end
+      nil
+    end
+  end
+end

data/lib/blinka_reporter/config.rb

@@ -0,0 +1,37 @@
+require 'blinka_reporter/error'
+
+module BlinkaReporter
+  class Config
+    attr_reader(:commit, :host, :repository, :tag, :team_id, :team_secret)
+    DEFAULT_HOST = 'https://www.blinka.app'
+
+    def initialize(
+      tag:,
+      commit:,
+      repository:,
+      host: nil,
+      team_id:,
+      team_secret:
+    )
+      @commit = commit || find_commit
+      @host = host || DEFAULT_HOST
+      @repository = repository
+      @tag = tag
+      @team_id = team_id
+      @team_secret = team_secret
+    end
+
+    def validate_blinka
+      required = [@team_id, @team_secret, @repository]
+      if required.include?(nil) || required.include?('')
+        raise(BlinkaReporter::Error, <<~EOS)
+          Missing configuration, make sure to set --team-id, --team-secret, --repository
+        EOS
+      end
+    end
+
+    def find_commit
+      ENV.fetch('HEROKU_TEST_RUN_COMMIT_VERSION', `git rev-parse HEAD`.chomp)
+    end
+  end
+end

data/lib/blinka_reporter/error.rb

@@ -0,0 +1,3 @@
+module BlinkaReporter
+  class Error < StandardError; end
+end

data/lib/blinka_reporter/minitest_adapter.rb

@@ -0,0 +1,92 @@
+module BlinkaReporter
+  class MinitestAdapter
+    def initialize(test_result)
+      @test_result = test_result
+    end
+
+    def path
+      @path ||= source_location.first.gsub(Dir.getwd, '').delete_prefix('/')
+    end
+
+    def line
+      @line ||= source_location.last
+    end
+
+    # Handle broken API in Minitest between 5.10 and 5.11
+    # https://github.com/minitest-reporters/minitest-reporters/blob/e9092460b5a5cf5ca9eb375428217cbb2a7f6dbb/lib/minitest/reporters/default_reporter.rb#L159
+    def source_location
+      @source_location ||=
+        if @test_result.respond_to?(:klass)
+          @test_result.source_location
+        else
+          @test_result.method(@test_result.name).source_location
+        end
+    end
+
+    def kind
+      parts = self.path.gsub('test/', '').split('/')
+      parts.length > 1 ? parts.first : 'general'
+    end
+
+    def message
+      failure = @test_result.failure
+      return unless failure
+      "#{failure.error.class}: #{failure.error.message}"
+    end
+
+    def backtrace
+      return unless @test_result.failure
+      Minitest.filter_backtrace(@test_result.failure.backtrace)
+    end
+
+    def result
+      if @test_result.error?
+        :error
+      elsif @test_result.skipped?
+        :skip
+      elsif @test_result.failure
+        :fail
+      else
+        :pass
+      end
+    end
+
+    def time
+      @test_result.time
+    end
+
+    def name
+      @test_result.name
+    end
+
+    def image
+      return unless kind == 'system'
+
+      image_path =
+        if defined?(Capybara) && Capybara.respond_to?(:save_path) &&
+             Capybara.save_path.present?
+          "#{Capybara.save_path}/failures_#{name}.png"
+        else
+          "./tmp/screenshots/failures_#{name}.png"
+        end
+
+      return unless File.exist?(image_path)
+
+      image_path
+    end
+
+    def report
+      {
+        backtrace: backtrace,
+        message: message,
+        line: line,
+        image: image,
+        kind: kind,
+        name: name,
+        path: path,
+        result: result,
+        time: time
+      }.compact
+    end
+  end
+end

data/lib/blinka_reporter/tap.rb

@@ -0,0 +1,51 @@
+module BlinkaReporter
+  class Tap
+    # Based on https://github.com/kern/minitest-reporters/blob/master/lib/minitest/reporters/progress_reporter.rb
+    # Tries to adhere to https://testanything.org/tap-specification.html
+    TAP_COMMENT_PAD = 8
+    attr_reader(:data)
+
+    def self.report(data)
+      Tap.new(data).report
+    end
+
+    def initialize(data)
+      results = Array(data[:results])
+      return if results.size == 0
+
+      @data = <<~REPORT
+      TAP version 13
+      1..#{results.size}
+      #{test_results(results)}
+      REPORT
+    end
+
+    def test_results(results)
+      report = []
+      results.each_with_index do |test, index|
+        test_str = "#{test[:path]} - #{test[:name].tr('#', '_')}"
+        result = test[:result]
+        if result == 'pass'
+          report << "ok #{index + 1} - #{test_str}"
+        elsif result == 'skip'
+          report << "ok #{index + 1} # skip: #{test_str}"
+        elsif result == 'fail'
+          report << "not ok #{index + 1} - failed: #{test_str}"
+          test[:message].split('\n') do |line|
+            report << "##{' ' * TAP_COMMENT_PAD + line}"
+          end
+          report << '#'
+          Array(test[:backtrace]).each do |line|
+            report << "##{' ' * TAP_COMMENT_PAD + line}"
+          end
+          report << ''
+        end
+      end
+      report.join("\n")
+    end
+
+    def report
+      puts(@data)
+    end
+  end
+end

data/lib/blinka_reporter/version.rb

@@ -1,3 +1,3 @@
 module BlinkaReporter
-  VERSION = '0.5.2'.freeze
+  VERSION = '0.7.0'.freeze
 end

data/lib/blinka_reporter.rb

@@ -0,0 +1,4 @@
+require 'blinka_reporter/version'
+require 'blinka_reporter/cli'
+
+module BlinkaReporter; end

data/lib/minitest/blinka_plugin.rb

@@ -1,7 +1,7 @@
 require 'minitest'
 require 'json'
-require 'blinka_minitest'
-require 'blinka_client'
+require 'blinka_reporter/minitest_adapter'
+require 'blinka_reporter/client'
 
 module Minitest
   def self.plugin_blinka_init(options)
@@ -11,114 +11,46 @@ module Minitest
   def plugin_blinka_options(opts, options); end
 
   module BlinkaPlugin
-    REPORT_PATH = 'blinka_results.json'.freeze
-    TAP_COMMENT_PAD = 8
     class Reporter < Minitest::StatisticsReporter
       attr_accessor :tests
 
-      def initialize(io = $stdout, options = {})
-        super
-        self.tests = []
-      end
-
       def record(test)
         super
+        self.tests ||= []
         tests << test
       end
 
       def report
         super
 
-        tap_report if ENV['BLINKA_TAP']
-        if ENV['BLINKA_JSON'] || ENV['BLINKA_REPORT']
-          json_report(append: !ENV['BLINKA_APPEND'].nil?)
-        end
-        BlinkaClient.new.report if ENV['BLINKA_REPORT']
-      rescue BlinkaClient::BlinkaError => error
+        json_report
+      rescue BlinkaReporter::Error => error
         puts(error)
       end
 
       private
 
-      def json_report(append:)
+      def json_report
+        report_path = ENV['BLINKA_PATH']
+        return if report_path.nil? || report_path.eql?('')
+
         result = {
           total_time: total_time,
           nbr_tests: count,
           nbr_assertions: assertions,
-          commit: find_commit,
-          tag: ENV.fetch('BLINKA_TAG', ''),
           seed: options[:seed],
           results:
-            tests.map { |test_result| BlinkaMinitest.new(test_result).report }
+            tests.map do |test_result|
+              BlinkaReporter::MinitestAdapter.new(test_result).report
+            end
         }
-        result = append_previous(result) if append
 
-        File.open(REPORT_PATH, 'w+') do |file|
+        File.open(report_path, 'w+') do |file|
           file.write(JSON.pretty_generate(result))
         end
 
         puts
-        puts("Test results written to `#{REPORT_PATH}`")
-      end
-
-      # Based on https://github.com/kern/minitest-reporters/blob/master/lib/minitest/reporters/progress_reporter.rb
-      # Tries to adhere to https://testanything.org/tap-specification.html
-      def tap_report
-        puts
-        puts('TAP version 13')
-        puts("1..#{tests.length}")
-        tests.each_with_index do |test, index|
-          blinka = BlinkaMinitest.new(test)
-          test_str = "#{blinka.path} - #{test.name.tr('#', '_')}"
-          if test.passed?
-            puts "ok #{index + 1} - #{test_str}"
-          elsif test.skipped?
-            puts "ok #{index + 1} # skip: #{test_str}"
-          elsif test.failure
-            puts "not ok #{index + 1} - failed: #{test_str}"
-            blinka.message.each_line { |line| print_padded_comment(line) }
-
-            # test.failure.message.each_line { |line| print_padded_comment(line) }
-            unless test.failure.is_a?(MiniTest::UnexpectedError)
-              blinka.backtrace.each { |line| print_padded_comment(line) }
-            end
-            puts
-          end
-        end
-      end
-
-      def print_padded_comment(line)
-        puts "##{' ' * TAP_COMMENT_PAD + line}"
-      end
-
-      def find_commit
-        ENV.fetch(
-          'BLINKA_COMMIT',
-          ENV.fetch(
-            'HEROKU_TEST_RUN_COMMIT_VERSION',
-            `git rev-parse HEAD`.chomp
-          )
-        )
-      end
-
-      private
-
-      def parse_report
-        return unless File.exist?(REPORT_PATH)
-        JSON.parse(File.read(REPORT_PATH))
-      end
-
-      def append_previous(result)
-        previous = parse_report
-        return if previous.nil?
-        return if result[:commit] != previous['commit']
-        return if result[:tag] != previous['tag']
-
-        result[:total_time] += previous['total_time'] || 0
-        result[:nbr_tests] += previous['nbr_tests'] || 0
-        result[:nbr_assertions] += previous['nbr_assertions'] || 0
-        result[:results] += previous['results'] || []
-        result
+        puts("Test results written to `#{report_path}`")
       end
     end
   end