blinka-reporter 0.5.1 → 0.6.1

data/lib/blinka_reporter/blinka.rb

@@ -0,0 +1,169 @@
+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')
+      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,36 @@
+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:
+          --tap: Flag for outputting test results in TAP-protocol, helpful on Heroku CI.
+          --blinka: Flag for reporting test results to blinka.app, requires setting environment:
+                    - BLINKA_TEAM_ID
+                    - BLINKA_TEAM_SECRET
+                    - BLINKA_REPOSITORY
+          --path <path>: Path to test results file, works for
+                  - ./blinka_results.json blinka json format [default]
+                  - ./rspec.xml from https://github.com/sj26/rspec_junit_formatter
+        EOS
+        return 0
+      end
+
+      tap = (argv.index('--tap') || -1) >= 0
+      blinka = (argv.index('--blinka') || -1) >= 0
+      path = argv_value_for(argv, '--path') || './blinka_results.json'
+      BlinkaReporter::Client.report(blinka: blinka, tap: tap, path: path)
+      0
+    end
+
+    def self.argv_value_for(argv, option_name)
+      return unless (index = argv.index(option_name))
+      argv[index + 1]
+    end
+  end
+end

data/lib/blinka_reporter/client.rb

@@ -0,0 +1,114 @@
+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 initialize
+      @config = BlinkaReporter::Config.new
+    end
+
+    def report(path: './blinka_results.json', blinka: false, tap: false)
+      unless File.exist?(path)
+        raise(
+          BlinkaReporter::Error,
+          "Could not find #{path}, was it generated when running the tests?"
+        )
+      end
+
+      data =
+        if path.end_with?('.xml')
+          self.class.parse_xml(path: path)
+        elsif path.end_with?('.json')
+          self.class.parse_json(path: path)
+        else
+          raise(
+            BlinkaReporter::Error,
+            "Unknown format of #{path}, needs to be .json or .xml"
+          )
+        end
+
+      BlinkaReporter::Tap.report(data) if tap
+      BlinkaReporter::Blinka.report(config: @config, data: data) if blinka
+      0
+    end
+
+    def self.report(path:, tap: false, blinka: false)
+      Client.new.report(path: path, tap: tap, blinka: blinka)
+    end
+
+    def self.parse_json(path:)
+      JSON.parse(File.open(path).read, symbolize_names: true)
+    end
+
+    def self.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 self.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 self.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 self.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,34 @@
+require 'blinka_reporter/error'
+
+module BlinkaReporter
+  class Config
+    attr_reader(:commit, :host, :repository, :tag, :team_id, :team_secret)
+
+    def initialize
+      @commit = find_commit
+      @host = ENV.fetch('BLINKA_HOST', 'https://www.blinka.app')
+      @repository = ENV.fetch('BLINKA_REPOSITORY', nil)
+      @tag = ENV.fetch('BLINKA_TAG', nil)
+      @team_id = ENV.fetch('BLINKA_TEAM_ID', nil)
+      @team_secret = ENV.fetch('BLINKA_TEAM_SECRET', nil)
+    end
+
+    def validate_blinka
+      if @team_id.nil? || @team_secret.nil? || @repository.nil?
+        raise(BlinkaReporter::Error, <<~EOS)
+          Missing configuration, make sure to set required environment variables:
+          - BLINKA_TEAM_ID
+          - BLINKA_TEAM_SECRET
+          - BLINKA_REPOSITORY
+          EOS
+      end
+    end
+
+    def find_commit
+      ENV.fetch(
+        'BLINKA_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.1'.freeze
+  VERSION = '0.6.1'.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)
@@ -12,7 +12,6 @@ module Minitest
 
   module BlinkaPlugin
     REPORT_PATH = 'blinka_results.json'.freeze
-    TAP_COMMENT_PAD = 8
     class Reporter < Minitest::StatisticsReporter
       attr_accessor :tests
 
@@ -29,12 +28,8 @@ module Minitest
       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(append: !ENV['BLINKA_APPEND'].nil?) if ENV['BLINKA_JSON']
+      rescue BlinkaReporter::Client::BlinkaReporter::Error => error
         puts(error)
       end
 
@@ -45,11 +40,11 @@ module Minitest
           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
 
@@ -61,63 +56,23 @@ module Minitest
         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))
+        JSON.parse(File.read(REPORT_PATH), symbolize_names: true)
       end
 
       def append_previous(result)
         previous = parse_report
         return if previous.nil?
-        return if result[:commit] != previous['commit']
-        return if result[:tag] != previous['tag']
+        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[: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
       end
     end

data/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "blinka_reporter",
+  "version": "0.0.1",
+  "author": "David Wessman <david@wessman.co>",
+  "license": "MIT",
+  "devDependencies": {
+    "@prettier/plugin-ruby": "^2.0.0",
+    "husky": "^7.0.4",
+    "lint-staged": "^12.3.4"
+  },
+  "scripts": {
+    "pretty": "./node_modules/.bin/prettier --write ."
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{md,rb,json,yml,gemspec}": "./node_modules/.bin/prettier --write"
+  }
+}