* Don't eagerly require Rails' minitest plugin.

By making the Rails minitest behave like a standard minitest plugin
we're much more likely to not break when people use other minitest
plugins. Like minitest-focus and pride.

To do this, we need to behave like minitest: require files up front
and then perform the plugin behavior via the at_exit hook.
This also saves us a fair bit of wrangling with test file loading.

Finally, since the environment and warnings options have to be applied
as early as possible, and since minitest loads plugins at_exit, they
have to be moved to the test command.

* Don't expect the root method.

It's likely this worked because we eagerly loaded the Rails minitest plugin
and that somehow defined a root method on `Rails`.

* Assign a backtrace to failed exceptions.

Otherwise Minitest pukes when attempting to filter the backtrace (which
Rails' backtrace cleaner then removes).

Means the exception message test has to be revised too.

This is likely caused by the rails minitest plugin now being loaded for
these tests and assigning a default backtrace cleaner.

1 files changed, 140 insertions, 0 deletions

diff --git a/railties/lib/rails/test_unit/runner.rb b/railties/lib/rails/test_unit/runner.rb
new file mode 100644
index 0000000000..8018ef9d02
--- /dev/null
+++ b/railties/lib/rails/test_unit/runner.rb
@@ -0,0 +1,140 @@
+require "shellwords"
+require "method_source"
+require "rake/file_list"
+require "active_support/core_ext/module/attribute_accessors"
+
+module Rails
+  module TestUnit
+    class Runner
+      mattr_reader :filters, default: []
+
+      class << self
+        def options(opts)
+          opts.on("--warnings", "-w", "Run with Ruby warnings enabled") {}
+          opts.on("--environment", "-e", "Run tests in the ENV environment") {}
+        end
+
+        def parse_options(argv)
+          # Perform manual parsing and cleanup since option parser raises on unknown options.
+          env_index = argv.index("--environment") || argv.index("-e")
+          if env_index
+            argv.delete_at(env_index)
+            environment = argv.delete_at(env_index).strip
+          end
+          ENV["RAILS_ENV"] = environment || "test"
+
+          w_index = argv.index("--warnings") || argv.index("-w")
+          $VERBOSE = argv.delete_at(w_index) if w_index
+        end
+
+        def rake_run(argv = [])
+          ARGV.replace Shellwords.split(ENV["TESTOPTS"] || "")
+
+          run(argv)
+        end
+
+        def run(argv = [])
+          load_tests(argv)
+
+          require "active_support/testing/autorun"
+        end
+
+        def load_tests(argv)
+          patterns = extract_filters(argv)
+
+          tests = Rake::FileList[patterns.any? ? patterns : "test/**/*_test.rb"]
+          tests.exclude("test/system/**/*") if patterns.empty?
+
+          tests.to_a.each { |path| require File.expand_path(path) }
+        end
+
+        def compose_filter(runnable, filter)
+          if filters.any? { |_, lines| lines.any? }
+            CompositeFilter.new(runnable, filter, filters)
+          else
+            filter
+          end
+        end
+
+        private
+          def extract_filters(argv)
+            argv.select { |arg| arg =~ /^\w+\// }.map do |path|
+              case
+              when path =~ /(:\d+)+$/
+                file, *lines = path.split(":")
+                filters << [ file, lines ]
+                file
+              when Dir.exist?(path)
+                "#{path}/**/*_test.rb"
+              else
+                filters << [ path, [] ]
+                path
+              end
+            end
+          end
+      end
+    end
+
+    class CompositeFilter # :nodoc:
+      attr_reader :named_filter
+
+      def initialize(runnable, filter, patterns)
+        @runnable = runnable
+        @named_filter = derive_named_filter(filter)
+        @filters = [ @named_filter, *derive_line_filters(patterns) ].compact
+      end
+
+      # Minitest uses === to find matching filters.
+      def ===(method)
+        @filters.any? { |filter| filter === method }
+      end
+
+      private
+        def derive_named_filter(filter)
+          if filter.respond_to?(:named_filter)
+            filter.named_filter
+          elsif filter =~ %r%/(.*)/% # Regexp filtering copied from Minitest.
+            Regexp.new $1
+          elsif filter.is_a?(String)
+            filter
+          end
+        end
+
+        def derive_line_filters(patterns)
+          patterns.flat_map do |file, lines|
+            if lines.empty?
+              Filter.new(@runnable, file, nil) if file
+            else
+              lines.map { |line| Filter.new(@runnable, file, line) }
+            end
+          end
+        end
+    end
+
+    class Filter # :nodoc:
+      def initialize(runnable, file, line)
+        @runnable, @file = runnable, File.expand_path(file)
+        @line = line.to_i if line
+      end
+
+      def ===(method)
+        return unless @runnable.method_defined?(method)
+
+        if @line
+          test_file, test_range = definition_for(@runnable.instance_method(method))
+          test_file == @file && test_range.include?(@line)
+        else
+          @runnable.instance_method(method).source_location.first == @file
+        end
+      end
+
+      private
+        def definition_for(method)
+          file, start_line = method.source_location
+          end_line = method.source.count("\n") + start_line - 1
+
+          return file, start_line..end_line
+        end
+    end
+  end
+end