opal-minitest 0.0.1

data/opal/minitest/test.rb

@@ -0,0 +1,290 @@
+# OMT: removed
+#require "minitest" unless defined? Minitest::Runnable
+
+module Minitest
+  ##
+  # Subclass Test to create your own tests. Typically you'll want a
+  # Test subclass per implementation class.
+  #
+  # See Minitest::Assertions
+
+  class Test < Runnable
+    require "minitest/assertions"
+    include Minitest::Assertions
+
+    # OMT: modified
+    #PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, # :nodoc:
+    #                          Interrupt, SystemExit]
+    PASSTHROUGH_EXCEPTIONS = [SystemExit] # :nodoc:
+
+    # OMT: unsupported
+    #class << self; attr_accessor :io_lock; end
+    #self.io_lock = Mutex.new
+
+    ##
+    # Call this at the top of your tests when you absolutely
+    # positively need to have ordered tests. In doing so, you're
+    # admitting that you suck and your tests are weak.
+
+    def self.i_suck_and_my_tests_are_order_dependent!
+      class << self
+        undef_method :test_order if method_defined? :test_order
+        define_method :test_order do :alpha end
+      end
+    end
+
+    ##
+    # Make diffs for this Test use #pretty_inspect so that diff
+    # in assert_equal can have more details. NOTE: this is much slower
+    # than the regular inspect but much more usable for complex
+    # objects.
+
+    def self.make_my_diffs_pretty!
+      require "pp"
+
+      define_method :mu_pp do |o|
+        o.pretty_inspect
+      end
+    end
+
+    ##
+    # Call this at the top of your tests when you want to run your
+    # tests in parallel. In doing so, you're admitting that you rule
+    # and your tests are awesome.
+    # OMT: unsupported
+
+    #def self.parallelize_me!
+    #  include Minitest::Parallel::Test
+    #  extend Minitest::Parallel::Test::ClassMethods
+    #end
+
+    ##
+    # Returns all instance methods starting with "test_". Based on
+    # #test_order, the methods are either sorted, randomized
+    # (default), or run in parallel.
+
+    def self.runnable_methods
+      methods = methods_matching(/^test_/)
+      # OMT: added
+      methods.delete('test_order')
+
+      case self.test_order
+      when :random, :parallel then
+        max = methods.size
+        methods.sort.sort_by { rand max }
+      when :alpha, :sorted then
+        methods.sort
+      else
+        raise "Unknown test_order: #{self.test_order.inspect}"
+      end
+    end
+
+    ##
+    # Defines the order to run tests (:random by default). Override
+    # this or use a convenience method to change it for your tests.
+
+    def self.test_order
+      :random
+    end
+
+    ##
+    # The time it took to run this test.
+
+    attr_accessor :time
+
+    def marshal_dump # :nodoc:
+      super << self.time
+    end
+
+    def marshal_load ary # :nodoc:
+      self.time = ary.pop
+      super
+    end
+
+    ##
+    # Runs a single test with setup/teardown hooks.
+
+    def run
+      with_info_handler do
+        time_it do
+          capture_exceptions do
+            before_setup; setup; after_setup
+
+            self.send self.name
+          end
+
+          %w{ before_teardown teardown after_teardown }.each do |hook|
+            capture_exceptions do
+              self.send hook
+            end
+          end
+        end
+      end
+
+      self # per contract
+    end
+
+    ##
+    # Provides before/after hooks for setup and teardown. These are
+    # meant for library writers, NOT for regular test authors. See
+    # #before_setup for an example.
+
+    module LifecycleHooks
+
+      ##
+      # Runs before every test, before setup. This hook is meant for
+      # libraries to extend minitest. It is not meant to be used by
+      # test developers.
+      #
+      # As a simplistic example:
+      #
+      #   module MyMinitestPlugin
+      #     def before_setup
+      #       super
+      #       # ... stuff to do before setup is run
+      #     end
+      #
+      #     def after_setup
+      #       # ... stuff to do after setup is run
+      #       super
+      #     end
+      #
+      #     def before_teardown
+      #       super
+      #       # ... stuff to do before teardown is run
+      #     end
+      #
+      #     def after_teardown
+      #       # ... stuff to do after teardown is run
+      #       super
+      #     end
+      #   end
+      #
+      #   class MiniTest::Test
+      #     include MyMinitestPlugin
+      #   end
+
+      def before_setup; end
+
+      ##
+      # Runs before every test. Use this to set up before each test
+      # run.
+
+      def setup; end
+
+      ##
+      # Runs before every test, after setup. This hook is meant for
+      # libraries to extend minitest. It is not meant to be used by
+      # test developers.
+      #
+      # See #before_setup for an example.
+
+      def after_setup; end
+
+      ##
+      # Runs after every test, before teardown. This hook is meant for
+      # libraries to extend minitest. It is not meant to be used by
+      # test developers.
+      #
+      # See #before_setup for an example.
+
+      def before_teardown; end
+
+      ##
+      # Runs after every test. Use this to clean up after each test
+      # run.
+
+      def teardown; end
+
+      ##
+      # Runs after every test, after teardown. This hook is meant for
+      # libraries to extend minitest. It is not meant to be used by
+      # test developers.
+      #
+      # See #before_setup for an example.
+
+      def after_teardown; end
+    end # LifecycleHooks
+
+    def capture_exceptions # :nodoc:
+      begin
+        yield
+      rescue *PASSTHROUGH_EXCEPTIONS
+        raise
+      rescue Assertion => e
+        self.failures << e
+      rescue Exception => e
+        self.failures << UnexpectedError.new(e)
+      end
+    end
+
+    ##
+    # Did this run error?
+
+    def error?
+      self.failures.any? { |f| UnexpectedError === f }
+    end
+
+    ##
+    # The location identifier of this test.
+
+    def location
+      loc = " [#{self.failure.location}]" unless passed? or error?
+      "#{self.class}##{self.name}#{loc}"
+    end
+
+    ##
+    # Did this run pass?
+    #
+    # Note: skipped runs are not considered passing, but they don't
+    # cause the process to exit non-zero.
+
+    def passed?
+      not self.failure
+    end
+
+    ##
+    # Returns ".", "F", or "E" based on the result of the run.
+
+    def result_code
+      self.failure and self.failure.result_code or "."
+    end
+
+    ##
+    # Was this run skipped?
+
+    def skipped?
+      self.failure and Skip === self.failure
+    end
+
+    def time_it # :nodoc:
+      t0 = Time.now
+
+      yield
+    ensure
+      self.time = Time.now - t0
+    end
+
+    def to_s # :nodoc:
+      return location if passed? and not skipped?
+
+      failures.map { |failure|
+        "#{failure.result_label}:\n#{self.location}:\n#{failure.message}\n"
+      }.join "\n"
+    end
+
+    def with_info_handler &block # :nodoc:
+      t0 = Time.now
+
+      handler = lambda do
+        warn "\nCurrent: %s#%s %.2fs" % [self.class, self.name, Time.now - t0]
+      end
+
+      self.class.on_signal "INFO", handler, &block
+    end
+
+    include LifecycleHooks
+    include Guard
+    extend Guard
+  end # Test
+end

data/opal/minitest.rb

@@ -0,0 +1,251 @@
+# OMT: unsupported
+#require "optparse"
+#require "thread"
+#require "mutex_m"
+#require "minitest/parallel"
+
+##
+# :include: README.txt
+module Minitest
+  VERSION = "5.3.4.opal" # :nodoc:
+
+  @@installed_at_exit ||= false
+  @@after_run = []
+  @extensions = []
+
+  mc = (class << self; self; end)
+
+  ##
+  # Parallel test executor
+  # OMT: unsupported
+
+  #mc.send :attr_accessor, :parallel_executor
+  #self.parallel_executor = Parallel::Executor.new((ENV['N'] || 2).to_i)
+
+  ##
+  # Filter object for backtraces.
+
+  mc.send :attr_accessor, :backtrace_filter
+
+  ##
+  # Reporter object to be used for all runs.
+  #
+  # NOTE: This accessor is only available during setup, not during runs.
+
+  mc.send :attr_accessor, :reporter
+
+  ##
+  # Names of known extension plugins.
+  # OMT: unsupported
+
+  #mc.send :attr_accessor, :extensions
+
+  ##
+  # Registers Minitest to run at process exit
+  # OMT: unsupported
+
+#  def self.autorun
+#    at_exit {
+#      next if $! and not ($!.kind_of? SystemExit and $!.success?)
+#
+#      exit_code = nil
+#
+#      at_exit {
+#        @@after_run.reverse_each(&:call)
+#        exit exit_code || false
+#      }
+#
+#      exit_code = Minitest.run ARGV
+#    } unless @@installed_at_exit
+#    @@installed_at_exit = true
+#  end
+
+  ##
+  # A simple hook allowing you to run a block of code after everything
+  # is done running. Eg:
+  #
+  #   Minitest.after_run { p $debugging_info }
+
+  def self.after_run &block
+    @@after_run << block
+  end
+
+  # OMT: unsupported
+  #def self.init_plugins options # :nodoc:
+  #  self.extensions.each do |name|
+  #    msg = "plugin_#{name}_init"
+  #    send msg, options if self.respond_to? msg
+  #  end
+  #end
+
+  # OMT: unsupported
+  #def self.load_plugins # :nodoc:
+  #  return unless self.extensions.empty?
+
+  #  seen = {}
+
+  #  require "rubygems" unless defined? Gem
+
+  #  Gem.find_files("minitest/*_plugin.rb").each do |plugin_path|
+  #    name = File.basename plugin_path, "_plugin.rb"
+
+  #    next if seen[name]
+  #    seen[name] = true
+
+  #    require plugin_path
+  #    self.extensions << name
+  #  end
+  #end
+
+  ##
+  # This is the top-level run method. Everything starts from here. It
+  # tells each Runnable sub-class to run, and each of those are
+  # responsible for doing whatever they do.
+  #
+  # The overall structure of a run looks like this:
+  #
+  #   Minitest.autorun
+  #     Minitest.run(args)
+  #       Minitest.__run(reporter, options)
+  #         Runnable.runnables.each
+  #           runnable.run(reporter, options)
+  #             self.runnable_methods.each
+  #               self.run_one_method(self, runnable_method, reporter)
+  #                 Minitest.run_one_method(klass, runnable_method, reporter)
+  #                   klass.new(runnable_method).run
+
+  def self.run args = []
+    # OMT: removed
+    #self.load_plugins
+
+    options = process_args args
+
+    reporter = CompositeReporter.new
+    reporter << SummaryReporter.new(options[:io], options)
+    reporter << ProgressReporter.new(options[:io], options)
+
+    self.reporter = reporter # this makes it available to plugins
+    # OMT: removed
+    #self.init_plugins options
+    self.reporter = nil # runnables shouldn't depend on the reporter, ever
+
+    reporter.start
+    __run reporter, options
+    # OMT: removed
+    #self.parallel_executor.shutdown
+    reporter.report
+
+    # OMT: modified
+    #reporter.passed?
+    `window.OPAL_TEST_EXIT_STATUS = #{reporter.passed?}`
+  end
+
+  ##
+  # Internal run method. Responsible for telling all Runnable
+  # sub-classes to run.
+  #
+  # NOTE: this method is redefined in parallel_each.rb, which is
+  # loaded if a Runnable calls parallelize_me!.
+
+  def self.__run reporter, options
+    suites = Runnable.runnables.shuffle
+    parallel, serial = suites.partition { |s| s.test_order == :parallel }
+
+    # If we run the parallel tests before the serial tests, the parallel tests
+    # could run in parallel with the serial tests. This would be bad because
+    # the serial tests won't lock around Reporter#record. Run the serial tests
+    # first, so that after they complete, the parallel tests will lock when
+    # recording results.
+    serial.map { |suite| suite.run reporter, options } +
+      parallel.map { |suite| suite.run reporter, options }
+  end
+
+  def self.process_args args = [] # :nodoc:
+    options = {
+               :io => $stdout,
+              }
+    orig_args = args.dup
+
+    # OMT: unsupported
+#    OptionParser.new do |opts|
+#      opts.banner  = "minitest options:"
+#      opts.version = Minitest::VERSION
+#
+#      opts.on "-h", "--help", "Display this help." do
+#        puts opts
+#        exit
+#      end
+#
+#      opts.on "-s", "--seed SEED", Integer, "Sets random seed" do |m|
+#        options[:seed] = m.to_i
+#      end
+#
+#      opts.on "-v", "--verbose", "Verbose. Show progress processing files." do
+#        options[:verbose] = true
+#      end
+#
+#      opts.on "-n", "--name PATTERN","Filter run on /pattern/ or string." do |a|
+#        options[:filter] = a
+#      end
+#
+#      unless extensions.empty?
+#        opts.separator ""
+#        opts.separator "Known extensions: #{extensions.join(', ')}"
+#
+#        extensions.each do |meth|
+#          msg = "plugin_#{meth}_options"
+#          send msg, opts, options if self.respond_to?(msg)
+#        end
+#      end
+#
+#      begin
+#        opts.parse! args
+#      rescue OptionParser::InvalidOption => e
+#        puts
+#        puts e
+#        puts
+#        puts opts
+#        exit 1
+#      end
+#
+#      orig_args -= args
+#    end
+
+    unless options[:seed] then
+      srand
+      options[:seed] = srand % 0xFFFF
+      orig_args << "--seed" << options[:seed].to_s
+    end
+
+    srand options[:seed]
+
+    options[:args] = orig_args.map { |s|
+      s =~ /[\s|&<>$()]/ ? s.inspect : s
+    }.join " "
+
+    options
+  end
+
+  def self.filter_backtrace bt # :nodoc:
+    backtrace_filter.filter bt
+  end
+
+  ##
+  # OMT: section moved to core_classes.rb
+  ##
+
+  self.backtrace_filter = BacktraceFilter.new
+
+  def self.run_one_method klass, method_name # :nodoc:
+    result = klass.new(method_name).run
+    raise "#{klass}#run _must_ return self" unless klass === result
+    result
+  end
+end
+
+# OMT: added
+require "minitest/core_classes"
+
+require "minitest/test"
+# OMT: unsupported
+#require "minitest/unit" unless defined?(MiniTest) # compatibility layer only

data/opal/opal/minitest/loader.rb.erb

@@ -0,0 +1,8 @@
+<% require_asset 'opal' %>
+<% require_asset 'minitest' %>
+
+<% Dir['test/{test_helper,**/*_test}.{rb,opal}'].each { |file|
+  require_asset file.sub(/^test\//, '').sub(/\.{rb,opal}$/, '')
+} %>
+
+Minitest.run

data/opal-minitest.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'opal/minitest/version'
+
+Gem::Specification.new do |s|
+  s.name         = 'opal-minitest'
+  s.version      = Opal::Minitest::VERSION
+  s.author       = 'Artur Ostrega'
+  s.email        = 'artur.mariusz.ostrega@gmail.com'
+  s.summary      = 'MiniTest for Opal'
+  s.description  = 'MiniTest test runner for Opal'
+
+  s.files = `git ls-files`.split("\n")
+
+  s.require_paths  = ['lib']
+
+  s.add_dependency 'opal', '~> 0.6.2'
+  s.add_dependency 'rake', '~> 10.3.2'
+  s.add_development_dependency 'minitest', '5.3.2'
+end
+

data/test/example_test.rb

@@ -0,0 +1,23 @@
+class ExampleTest < Minitest::Test
+  def test_passing_assert
+    assert true
+  end
+
+  def test_failing_assert
+    assert false, "intentional failure"
+  end
+
+  def test_skip
+    skip "intentional skip"
+  end
+
+  def test_capture_io
+    out, err = capture_io do
+      puts 'woo'
+      warn 'boo'
+    end
+
+    assert_match out, 'woo'
+    assert_match err, 'boo'
+  end
+end

data/vendor/runner.js

@@ -0,0 +1,23 @@
+// Headlessly open test loader and wait until tests finish.
+
+var url = phantom.args[0],
+    page = require('webpage').create();
+
+page.onConsoleMessage = function(msg) { console.log(msg) };
+
+page.open(url, function(loadStatus) {
+  if (loadStatus !== 'success') {
+    console.error("Cannot load: " + url);
+    phantom.exit(1);
+  }
+  var loop = setInterval(function() {
+    var exitStatus = page.evaluate(function() {
+      return window.OPAL_TEST_EXIT_STATUS;
+    });
+
+    if (exitStatus != null) {
+      clearInterval(loop);
+      phantom.exit(exitStatus);
+    }
+  }, 500);
+});