paynow_sdk 0.1.4 → 0.1.6

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.0/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/reporters/default_reporter.rb

@@ -1,245 +0,0 @@
-module Minitest
-  module Reporters
-    # A reporter identical to the standard Minitest reporter except with more
-    # colors.
-    #
-    # Based upon Ryan Davis of Seattle.rb's Minitest (MIT License).
-    #
-    # @see https://github.com/seattlerb/minitest Minitest
-
-    class DefaultReporter < BaseReporter
-      include ANSI::Code
-      include RelativePosition
-
-      def initialize(options = {})
-        super
-        @detailed_skip = options.fetch(:detailed_skip, true)
-        @slow_count = options.fetch(:slow_count, 0)
-        @slow_suite_count = options.fetch(:slow_suite_count, 0)
-        @suite_times = []
-        @suite_start_times = {}
-        @fast_fail = options.fetch(:fast_fail, false)
-        @show_test_location = options.fetch(:location, false)
-        @options = options
-      end
-
-      def start
-        super
-        on_start
-      end
-
-      def on_start
-        puts
-        puts("# Running tests with run options %s:" % options[:args])
-        puts
-      end
-
-      def before_test(test)
-        super
-        print "\n#{test.class}##{test.name} " if options[:verbose]
-      end
-
-      def before_suite(suite)
-        @suite_start_times[suite] = Minitest::Reporters.clock_time
-        super
-      end
-
-      def after_suite(suite)
-        super
-        duration = suite_duration(suite)
-        @suite_times << [suite.name, duration]
-      end
-
-      def record(test)
-        super
-
-        on_record(test)
-      end
-
-      def on_record(test)
-        print "#{"%.2f" % test.time} = " if options[:verbose]
-
-        # Print the pass/skip/fail mark
-        print(if test.passed?
-          record_pass(test)
-        elsif test.skipped?
-          record_skip(test)
-        elsif test.failure
-          record_failure(test)
-        end)
-
-        # Print fast_fail information
-        if @fast_fail && (test.skipped? || test.failure)
-          print_failure(test)
-        end
-      end
-
-      def record_pass(record)
-        green(record.result_code)
-      end
-
-      def record_skip(record)
-        yellow(record.result_code)
-      end
-
-      def record_failure(record)
-        red(record.result_code)
-      end
-
-      def report
-        super
-        on_report
-      end
-
-      def on_report
-        status_line = "Finished tests in %.6fs, %.4f tests/s, %.4f assertions/s." %
-          [total_time, count / total_time, assertions / total_time]
-
-        puts
-        puts
-        puts colored_for(suite_result, status_line)
-        puts
-
-        unless @fast_fail
-          tests.reject(&:passed?).each do |test|
-            print_failure(test)
-          end
-        end
-
-        if @slow_count > 0
-          slow_tests = tests.sort_by(&:time).reverse.take(@slow_count)
-
-          puts
-          puts "Slowest tests:"
-          puts
-
-          slow_tests.each do |test|
-            puts "%.6fs %s#%s" % [test.time, test.name, test_class(test)]
-          end
-        end
-
-        if @slow_suite_count > 0
-          slow_suites = @suite_times.sort_by { |x| x[1] }.reverse.take(@slow_suite_count)
-
-          puts
-          puts "Slowest test classes:"
-          puts
-
-          slow_suites.each do |slow_suite|
-            puts "%.6fs %s" % [slow_suite[1], slow_suite[0]]
-          end
-        end
-
-        puts
-        print colored_for(suite_result, result_line)
-        puts
-      end
-
-      alias to_s report
-
-      def print_failure(test)
-        message = message_for(test)
-        unless message.nil? || message.strip == ''
-          puts
-          puts colored_for(result(test), message)
-          if @show_test_location
-            location = get_source_location(test)
-            puts "\n\n#{relative_path(location[0])}:#{location[1]}"
-          end
-
-        end
-      end
-
-      private
-
-      def relative_path(path)
-        Pathname.new(path).relative_path_from(Pathname.new(Dir.getwd))
-      end
-      
-      def get_source_location(result)
-        if result.respond_to? :klass
-          result.source_location
-        else
-          result.method(result.name).source_location
-        end
-      end
-
-      def color?
-        return @color if defined?(@color)
-        @color = @options.fetch(:color) do
-          io.tty? && (
-            ENV["TERM"] =~ /^screen|color/ ||
-            ENV["EMACS"] == "t"
-          )
-        end
-      end
-
-      def green(string)
-        color? ? ANSI::Code.green(string) : string
-      end
-
-      def yellow(string)
-        color? ? ANSI::Code.yellow(string) : string
-      end
-
-      def red(string)
-        color? ? ANSI::Code.red(string) : string
-      end
-
-      def colored_for(result, string)
-        case result
-        when :fail, :error; red(string)
-        when :skip; yellow(string)
-        else green(string)
-        end
-      end
-
-      def suite_result
-        case
-        when failures > 0; :fail
-        when errors > 0; :error
-        when skips > 0; :skip
-        else :pass
-        end
-      end
-
-      def location(exception)
-        last_before_assertion = ''
-        exception.backtrace.reverse_each do |s|
-          break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
-          last_before_assertion = s
-        end
-
-        last_before_assertion.sub(/:in .*$/, '')
-      end
-
-      def message_for(test)
-        e = test.failure
-
-        if test.skipped?
-          if @detailed_skip
-            "Skipped:\n#{test_class(test)}##{test.name} [#{location(e)}]:\n#{e.message}"
-          end
-        elsif test.error?
-          "Error:\n#{test_class(test)}##{test.name}:\n#{e.message}"
-        else
-          "Failure:\n#{test_class(test)}##{test.name} [#{test.failure.location}]\n#{e.class}: #{e.message}"
-        end
-      end
-
-      def result_line
-        '%d tests, %d assertions, %d failures, %d errors, %d skips' %
-          [count, assertions, failures, errors, skips]
-      end
-
-      def suite_duration(suite)
-        start_time = @suite_start_times.delete(suite)
-        if start_time.nil?
-          0
-        else
-          Minitest::Reporters.clock_time - start_time
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.0/vendor/cache/ruby/2.7.0/gems/minitest-reporters-1.4.2/lib/minitest/reporters/html_reporter.rb

@@ -1,224 +0,0 @@
-require 'builder'
-require 'fileutils'
-require 'erb'
-
-module Minitest
-  module Reporters
-    # A reporter for generating HTML test reports
-    # This is recommended to be used with a CI server, where the report is kept as an artifact and is accessible via
-    # a shared link
-    #
-    # The reporter sorts the results alphabetically and then by results
-    # so that failing and skipped tests are at the top.
-    #
-    # When using Minitest Specs, the number prefix is dropped from the name of the test so that it reads well
-    #
-    # On each test run all files in the reports directory are deleted, this prevents a build up of old reports
-    #
-    # The report is generated using ERB. A custom ERB template can be provided but it is not required
-    # The default ERB template uses JQuery and Bootstrap, both of these are included by referencing the CDN sites
-    class HtmlReporter < BaseReporter
-      # The title of the report
-      attr_reader :title
-
-      # The number of tests that passed
-      def passes
-        count - failures - errors - skips
-      end
-
-      # The percentage of tests that passed, calculated in a way that avoids rounding errors
-      def percent_passes
-        100 - percent_skipps - percent_errors_failures
-      end
-
-      # The percentage of tests that were skipped
-      def percent_skipps
-        (skips / count.to_f * 100).to_i
-      end
-
-      # The percentage of tests that failed
-      def percent_errors_failures
-        ((errors + failures) / count.to_f * 100).to_i
-      end
-
-      # Trims off the number prefix on test names when using Minitest Specs
-      def friendly_name(test)
-        groups = test.name.scan(/(test_\d+_)(.*)/i)
-        return test.name if groups.empty?
-        "it #{groups[0][1]}"
-      end
-
-      # The constructor takes a hash, and uses the following keys:
-      # :title - the title that will be used in the report, defaults to 'Test Results'
-      # :reports_dir - the directory the reports should be written to, defaults to 'test/html_reports'
-      # :erb_template - the path to a custom ERB template, defaults to the supplied ERB template
-      # :mode - Useful for debugging, :terse suppresses errors and is the default, :verbose lets errors bubble up
-      # :output_filename - the report's filename, defaults to 'index.html'
-      def initialize(args = {})
-        super({})
-
-        defaults = {
-          :title           => 'Test Results',
-          :erb_template    => "#{File.dirname(__FILE__)}/../templates/index.html.erb",
-          :reports_dir     => 'test/html_reports',
-          :mode            => :safe,
-          :output_filename => 'index.html',
-        }
-
-        settings = defaults.merge(args)
-
-        @mode = settings[:mode]
-        @title = settings[:title]
-        @erb_template = settings[:erb_template]
-        @output_filename = settings[:output_filename]
-        reports_dir = settings[:reports_dir]
-
-        @reports_path = File.absolute_path(reports_dir)
-      end
-
-      def start
-        super
-
-        puts "Emptying #{@reports_path}"
-        FileUtils.mkdir_p(@reports_path)
-        File.delete(html_file) if File.exist?(html_file)
-      end
-
-      # Called by the framework to generate the report
-      def report
-        super
-
-        begin
-          puts "Writing HTML reports to #{@reports_path}"
-          erb_str = File.read(@erb_template)
-          renderer = ERB.new(erb_str)
-
-          tests_by_suites = tests.group_by { |test| test_class(test) } # taken from the JUnit reporter
-
-          suites = tests_by_suites.map do |suite, tests|
-            suite_summary = summarize_suite(suite, tests)
-            suite_summary[:tests] = tests.sort { |a, b| compare_tests(a, b) }
-            suite_summary
-          end
-
-          suites.sort! { |a, b| compare_suites(a, b) }
-
-          result = renderer.result(binding)
-          File.open(html_file, 'w') do |f|
-            f.write(result)
-          end
-
-        # rubocop:disable Lint/RescueException
-        rescue Exception => e
-          puts 'There was an error writing the HTML report'
-          puts 'This may have been caused by cancelling the test run'
-          puts 'Use mode => :verbose in the HTML reporters constructor to see more detail' if @mode == :terse
-          puts 'Use mode => :terse in the HTML reporters constructor to see less detail' if @mode != :terse
-          raise e if @mode != :terse
-        end
-        # rubocop:enable Lint/RescueException
-      end
-
-      private
-
-      def html_file
-        "#{@reports_path}/#{@output_filename}"
-      end
-
-      def compare_suites_by_name(suite_a, suite_b)
-        suite_a[:name] <=> suite_b[:name]
-      end
-
-      def compare_tests_by_name(test_a, test_b)
-        friendly_name(test_a) <=> friendly_name(test_b)
-      end
-
-      # Test suites are first ordered by evaluating the results of the tests, then by test suite name
-      # Test suites which have failing tests are given highest order
-      # Tests suites which have skipped tests are given second highest priority
-      def compare_suites(suite_a, suite_b)
-        return compare_suites_by_name(suite_a, suite_b) if suite_a[:has_errors_or_failures] && suite_b[:has_errors_or_failures]
-        return -1 if suite_a[:has_errors_or_failures] && !suite_b[:has_errors_or_failures]
-        return 1 if !suite_a[:has_errors_or_failures] && suite_b[:has_errors_or_failures]
-
-        return compare_suites_by_name(suite_a, suite_b) if suite_a[:has_skipps] && suite_b[:has_skipps]
-        return -1 if suite_a[:has_skipps] && !suite_b[:has_skipps]
-        return 1 if !suite_a[:has_skipps] && suite_b[:has_skipps]
-
-        compare_suites_by_name(suite_a, suite_b)
-      end
-
-      # Tests are first ordered by evaluating the results of the tests, then by tests names
-      # Tess which fail are given highest order
-      # Tests which are skipped are given second highest priority
-      def compare_tests(test_a, test_b)
-        return compare_tests_by_name(test_a, test_b) if test_fail_or_error?(test_a) && test_fail_or_error?(test_b)
-
-        return -1 if test_fail_or_error?(test_a) && !test_fail_or_error?(test_b)
-        return 1 if !test_fail_or_error?(test_a) && test_fail_or_error?(test_b)
-
-        return compare_tests_by_name(test_a, test_b) if test_a.skipped? && test_b.skipped?
-        return -1 if test_a.skipped? && !test_b.skipped?
-        return 1 if !test_a.skipped? && test_b.skipped?
-
-        compare_tests_by_name(test_a, test_b)
-      end
-
-      def test_fail_or_error?(test)
-        test.error? || test.failure
-      end
-
-      # based on analyze_suite from the JUnit reporter
-      def summarize_suite(suite, tests)
-        summary = Hash.new(0)
-        summary[:name] = suite.to_s
-        tests.each do |test|
-          summary[:"#{result(test)}_count"] += 1
-          summary[:assertion_count] += test.assertions
-          summary[:test_count] += 1
-          summary[:time] += test.time
-        end
-        summary[:has_errors_or_failures] = (summary[:fail_count] + summary[:error_count]) > 0
-        summary[:has_skipps] = summary[:skip_count] > 0
-        summary
-      end
-
-      # based on message_for(test) from the JUnit reporter
-      def message_for(test)
-        suite = test.class
-        name = test.name
-        e = test.failure
-
-        if test.passed?
-          nil
-        elsif test.skipped?
-          "Skipped:\n#{name}(#{suite}) [#{location(e)}]:\n#{e.message}\n"
-        elsif test.failure
-          "Failure:\n#{name}(#{suite}) [#{location(e)}]:\n#{e.message}\n"
-        elsif test.error?
-          "Error:\n#{name}(#{suite}):\n#{e.message}"
-        end
-      end
-
-      # taken from the JUnit reporter
-      def location(exception)
-        last_before_assertion = ''
-        exception.backtrace.reverse_each do |s|
-          break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
-          last_before_assertion = s
-        end
-        last_before_assertion.sub(/:in .*$/, '')
-      end
-
-      def total_time_to_hms
-        return ('%.2fs' % total_time) if total_time < 1
-
-        hours = (total_time / (60 * 60)).round
-        minutes = ((total_time / 60) % 60).round.to_s.rjust(2, '0')
-        seconds = (total_time % 60).round.to_s.rjust(2, '0')
-
-        "#{hours}h#{minutes}m#{seconds}s"
-      end
-    end
-  end
-end