scarpe-components 0.1.0 → 0.3.0

data/lib/scarpe/components/minitest_import_runnable.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "json"
+require "json/add/exception"
+
+module Scarpe; module Components; end; end
+module Scarpe::Components::ImportRunnables
+  # Minitest Runnables are unusual - we expect to declare a class (like a Test) with
+  # a lot of methods to run. The ImportRunnable is a single Runnable. But whenever
+  # you tell it to import a JSON file, it will add all of the described tests to
+  # its runnable methods.
+  #
+  # Normally that means that your subclass tests will run up front and produce
+  # JSON files, then Minitest will autorun at the end and report all their
+  # results.
+  #
+  # It wouldn't really make sense to create these runnables during the testing
+  # phase, because Minitest has already decided what to run at that point.
+  class ImportRunnable #< Minitest::Runnable
+    # Import JSON from an exported Minitest run. Note that running this multiple
+    # times with overlapping class names may be really bad.
+    def self.import_json_data(data)
+      @imported_classes ||= {}
+      @imported_tests ||= {}
+
+      JSON.parse(data).each do |item|
+        klass = item["klass"]
+        meth = item["name"]
+        @imported_tests[klass] ||= {}
+        @imported_tests[klass][meth] = item
+      end
+
+      @imported_tests.each do |klass_name, test_method_hash|
+        klass = @imported_classes[klass_name]
+        unless klass
+          new_klass = Class.new(Minitest::Runnable)
+          @imported_classes[klass_name] = new_klass
+          ImportRunnable.const_set(klass_name, new_klass)
+          klass = new_klass
+
+          klass.define_singleton_method(:run_one_method) do |klass, method_name, reporter|
+            reporter.prerecord klass, method_name
+            imp = test_method_hash[method_name]
+
+            res = Minitest::Result.new imp["name"]
+            res.klass = imp["klass"]
+            res.assertions = imp["assertions"]
+            res.time = imp["time"]
+            res.failures = ImportRunnable.deserialize_failures imp["failures"]
+            res.metadata = imp["metadata"] if imp["metadata"]
+
+            # Record the synthetic result built from imported data
+            reporter.record res
+          end
+        end
+
+        # Update "runnables" method to reflect all current known runnable tests
+        klass_methods = test_method_hash.keys
+        klass.define_singleton_method(:runnable_methods) do
+          klass_methods
+        end
+      end
+    end
+
+    def self.json_to_err(err_json)
+      klass = begin
+        Object.const_get(err_json["json_class"])
+      rescue
+        nil
+      end
+      if klass && klass <= Minitest::Assertion
+        klass.json_create(err_json)
+      else
+        err = Exception.json_create(err_json)
+        Minitest::UnexpectedError.new(err)
+      end
+    end
+
+    def self.deserialize_failures(failures)
+      failures.map do |fail|
+        # Instantiate the Minitest::Assertion or Minitest::UnexpectedError
+        if fail[0] == "exception"
+          exc_json = JSON.parse(fail[1])
+          json_to_err exc_json
+        elsif fail[0] == "unexpected"
+          unexpected_json = JSON.parse(fail[1])
+          inner_json = JSON.parse(fail[2])
+          outer_err = json_to_err unexpected_json
+          inner_err = json_to_err inner_json
+          outer_err.error = inner_err
+        else
+          raise "Unknown exception data when trying to deserialize! #{fail.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/scarpe/components/minitest_result.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "json"
+#require "json/add/exception"
+
+module Scarpe; module Components; end; end
+
+# A MinitestResult imports a JSON file from a minitest_export_reporter.
+# But instead of creating a Minitest::Test to report the result, the
+# MinitestResult is just a queryable Ruby object.
+#
+# MinitestResult assumes there will be only one class and one method
+# in the JSON, which is true for Scarpe but not necessarily in general.
+class Scarpe::Components::MinitestResult
+  attr_reader :assertions
+  attr_reader :method_name
+  attr_reader :class_name
+
+  def initialize(filename)
+    data = JSON.parse File.read(filename)
+
+    unless data.size == 1
+      # We would want a different interface to support this in general. For now we don't
+      # need it to work in general.
+      raise "Scarpe::Components::MinitestResult only supports one class and method in results!"
+    end
+
+    item = data.first
+
+    @assertions = item["assertions"]
+    @method_name = item["name"]
+    @class_name = item["klass"]
+    @time = item["time"]
+    @metadata = item.key?("metadata") ? item["metadata"]: {}
+
+    @skip = false
+    @exceptions = []
+    @failures = []
+    item["failures"].each do |f|
+      # JSON.parse ignores json_class and won't create an arbitrary object. That's good
+      # because Minitest::UnexpectedError seems to load in a bad way, so we don't want
+      # it to auto-instantiate.
+      d = JSON.parse f[1]
+      msg = d["m"]
+      case d["json_class"]
+      when "Minitest::UnexpectedError"
+        @exceptions << msg
+      when "Minitest::Skip"
+        @skip = msg
+      when "Minitest::Assertion"
+        @failures << msg
+      else
+        raise Scarpe::InternalError, "Didn't expect type #{t.inspect} as exception type when importing Minitest tests!"
+      end
+    end
+  end
+
+  def error?
+    !@exceptions.empty?
+  end
+
+  def fail?
+    !@failures.empty?
+  end
+
+  def skip?
+    @skip ? true : false
+  end
+
+  def passed?
+    @exceptions.empty? && @failures.empty? && !@skip
+  end
+
+  def error_message
+    @exceptions[0]
+  end
+
+  def fail_message
+    @failures[0]
+  end
+
+  def skip_message
+    @skip
+  end
+end

data/lib/scarpe/{logger.rb → components/modular_logger.rb}

@@ -5,10 +5,12 @@ require "json"
 
 require "shoes/log"
 
-# Requirements: logging gem
+# Requires the logging gem
 
-class Scarpe
-  class LogImpl
+module Scarpe; end
+module Scarpe::Components; end
+module Scarpe
+  class Components::ModularLogImpl
     include Shoes::Log # for constants
 
     def logger_for_component(component)
@@ -30,7 +32,7 @@ class Scarpe
       when "fatal"
         :fatal
       else
-        raise "Don't know how to treat #{data.inspect} as a logger severity!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Don't know how to treat #{data.inspect} as a logger severity!"
       end
     end
 
@@ -43,7 +45,7 @@ class Scarpe
       when String
         Logging.appenders.file data, layout: @custom_log_layout
       else
-        raise "Don't know how to convert #{data.inspect} to an appender!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Don't know how to convert #{data.inspect} to an appender!"
       end
     end
 
@@ -62,7 +64,7 @@ class Scarpe
 
         logger.level = name_to_severity(level)
       else
-        raise "Don't know how to use #{data.inspect} to specify a logger!"
+        raise Shoes::Errors::InvalidAttributeValueError, "Don't know how to use #{data.inspect} to specify a logger!"
       end
     end
 
@@ -106,3 +108,6 @@ class Scarpe
     end
   end
 end
+
+#Shoes::Log.instance = Scarpe::Components::ModularLogImpl.new
+#Shoes::Log.configure_logger(Shoes::Log::DEFAULT_LOG_CONFIG)

data/lib/scarpe/components/print_logger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "shoes/log"
+require "json"
+
+module Scarpe; end
+module Scarpe::Components; end
+class Scarpe::Components::PrintLogImpl
+  include Shoes::Log # for constants
+
+  class PrintLogger
+    class << self
+      attr_accessor :silence
+    end
+
+    def initialize(component_name)
+      @comp_name = component_name
+    end
+
+    def error(msg)
+      puts "#{@comp_name} error: #{msg}" unless PrintLogger.silence
+    end
+
+    def warn(msg)
+      puts "#{@comp_name} warn: #{msg}" unless PrintLogger.silence
+    end
+
+    def debug(msg)
+      puts "#{@comp_name} debug: #{msg}" unless PrintLogger.silence
+    end
+
+    def info(msg)
+      puts "#{@comp_name} info: #{msg}" unless PrintLogger.silence
+    end
+  end
+
+  def logger_for_component(component)
+    PrintLogger.new(component.to_s)
+  end
+
+  def configure_logger(log_config)
+    # For now, ignore
+  end
+end
+
+#Shoes::Log.instance = Scarpe::PrintLogImpl.new
+#Shoes::Log.configure_logger(Shoes::Log::DEFAULT_LOG_CONFIG)