# # # minitest/{test,spec,mock,benchmark} # # home # : https://github.com/seattlerb/minitest # bugs # : https://github.com/seattlerb/minitest/issues # rdoc # : http://docs.seattlerb.org/minitest # vim # : https://github.com/sunaku/vim-ruby-minitest # emacs # : https://github.com/arthurnn/minitest-emacs # # # ## DESCRIPTION: # # minitest provides a complete suite of testing facilities supporting TDD, BDD, # mocking, and benchmarking. # # "I had a class with Jim Weirich on testing last week and we were # allowed to choose our testing frameworks. Kirk Haines and I were # paired up and we cracked open the code for a few test # frameworks... # # I MUST say that minitest is *very* readable / understandable # compared to the 'other two' options we looked at. Nicely done and # thank you for helping us keep our mental sanity." # # -- Wayne E. Seguin # # minitest/test is a small and incredibly fast unit testing framework. It # provides a rich set of assertions to make your tests clean and readable. # # minitest/spec is a functionally complete spec engine. It hooks onto # minitest/test and seamlessly bridges test assertions over to spec # expectations. # # minitest/benchmark is an awesome way to assert the performance of your # algorithms in a repeatable manner. Now you can assert that your newb co-worker # doesn't replace your linear algorithm with an exponential one! # # minitest/mock by Steven Baker, is a beautifully tiny mock (and stub) object # framework. # # minitest/pride shows pride in testing and adds coloring to your test output. I # guess it is an example of how to write IO pipes too. :P # # minitest/test is meant to have a clean implementation for language # implementors that need a minimal set of methods to bootstrap a working test # suite. For example, there is no magic involved for test-case discovery. # # "Again, I can't praise enough the idea of a testing/specing # framework that I can actually read in full in one sitting!" # # -- Piotr Szotkowski # # Comparing to rspec: # # rspec is a testing DSL. minitest is ruby. # # -- Adam Hawkins, "Bow Before MiniTest" # # minitest doesn't reinvent anything that ruby already provides, like: classes, # modules, inheritance, methods. This means you only have to learn ruby to use # minitest and all of your regular OO practices like extract-method refactorings # still apply. # # ## FEATURES/PROBLEMS: # # * minitest/autorun - the easy and explicit way to run all your tests. # * minitest/test - a very fast, simple, and clean test system. # * minitest/spec - a very fast, simple, and clean spec system. # * minitest/mock - a simple and clean mock/stub system. # * minitest/benchmark - an awesome way to assert your algorithm's # performance. # * minitest/pride - show your pride in testing! # * Incredibly small and fast runner, but no bells and whistles. # * Written by squishy human beings. Software can never be perfect. We will # all eventually die. # # # ## RATIONALE: # # See design_rationale.rb to see how specs and tests work in minitest. # # ## SYNOPSIS: # # Given that you'd like to test the following class: # # class Meme # def i_can_has_cheezburger? # "OHAI!" # end # # def will_it_blend? # "YES!" # end # end # # ### Unit tests # # Define your tests as methods beginning with `test_`. # # require "minitest/autorun" # # class TestMeme < Minitest::Test # def setup # @meme = Meme.new # end # # def test_that_kitty_can_eat # assert_equal "OHAI!", @meme.i_can_has_cheezburger? # end # # def test_that_it_will_not_blend # refute_match /^no/i, @meme.will_it_blend? # end # # def test_that_will_be_skipped # skip "test this later" # end # end # # ### Specs # # require "minitest/autorun" # # describe Meme do # before do # @meme = Meme.new # end # # describe "when asked about cheeseburgers" do # it "must respond positively" do # _(@meme.i_can_has_cheezburger?).must_equal "OHAI!" # end # end # # describe "when asked about blending possibilities" do # it "won't say no" do # _(@meme.will_it_blend?).wont_match /^no/i # end # end # end # # For matchers support check out: # # * https://github.com/wojtekmach/minitest-matchers # * https://github.com/rmm5t/minitest-matchers_vaccine # # # ### Benchmarks # # Add benchmarks to your tests. # # # optionally run benchmarks, good for CI-only work! # require "minitest/benchmark" if ENV["BENCH"] # # class TestMeme < Minitest::Benchmark # # Override self.bench_range or default range is [1, 10, 100, 1_000, 10_000] # def bench_my_algorithm # assert_performance_linear 0.9999 do |n| # n is a range value # @obj.my_algorithm(n) # end # end # end # # Or add them to your specs. If you make benchmarks optional, you'll need to # wrap your benchmarks in a conditional since the methods won't be defined. In # minitest 5, the describe name needs to match `/Bench(mark)?$/`. # # describe "Meme Benchmark" do # if ENV["BENCH"] then # bench_performance_linear "my_algorithm", 0.9999 do |n| # 100.times do # @obj.my_algorithm(n) # end # end # end # end # # outputs something like: # # # Running benchmarks: # # TestBlah 100 1000 10000 # bench_my_algorithm 0.006167 0.079279 0.786993 # bench_other_algorithm 0.061679 0.792797 7.869932 # # Output is tab-delimited to make it easy to paste into a spreadsheet. # # ### Mocks # # Mocks and stubs defined using terminology by Fowler & Meszaros at # http://www.martinfowler.com/bliki/TestDouble.html: # # "Mocks are pre-programmed with expectations which form a specification of the # calls they are expected to receive. They can throw an exception if they # receive a call they don't expect and are checked during verification to ensure # they got all the calls they were expecting." # # class MemeAsker # def initialize(meme) # @meme = meme # end # # def ask(question) # method = question.tr(" ", "_") + "?" # @meme.__send__(method) # end # end # # require "minitest/autorun" # # describe MemeAsker, :ask do # describe "when passed an unpunctuated question" do # it "should invoke the appropriate predicate method on the meme" do # @meme = Minitest::Mock.new # @meme_asker = MemeAsker.new @meme # @meme.expect :will_it_blend?, :return_value # # @meme_asker.ask "will it blend" # # @meme.verify # end # end # end # # #### Multi-threading and Mocks # # Minitest mocks do not support multi-threading. If it works, fine, if it # doesn't you can use regular ruby patterns and facilities like local variables. # Here's an example of asserting that code inside a thread is run: # # def test_called_inside_thread # called = false # pr = Proc.new { called = true } # thread = Thread.new(&pr) # thread.join # assert called, "proc not called" # end # # ### Stubs # # Mocks and stubs are defined using terminology by Fowler & Meszaros at # http://www.martinfowler.com/bliki/TestDouble.html: # # "Stubs provide canned answers to calls made during the test". # # Minitest's stub method overrides a single method for the duration of the # block. # # def test_stale_eh # obj_under_test = Something.new # # refute obj_under_test.stale? # # Time.stub :now, Time.at(0) do # stub goes away once the block is done # assert obj_under_test.stale? # end # end # # A note on stubbing: In order to stub a method, the method must actually exist # prior to stubbing. Use a singleton method to create a new non-existing method: # # def obj_under_test.fake_method # ... # end # # ### Running Your Tests # # Ideally, you'll use a rake task to run your tests, either piecemeal or all at # once. Both rake and rails ship with rake tasks for running your tests. BUT! # You don't have to: # # % ruby -Ilib:test test/minitest/test_minitest_test.rb # Run options: --seed 37685 # # # Running: # # ...................................................................... (etc) # # Finished in 0.107130s, 1446.8403 runs/s, 2959.0217 assertions/s. # # 155 runs, 317 assertions, 0 failures, 0 errors, 0 skips # # There are runtime options available, both from minitest itself, and also # provided via plugins. To see them, simply run with `--help`: # # % ruby -Ilib:test test/minitest/test_minitest_test.rb --help # minitest options: # -h, --help Display this help. # -s, --seed SEED Sets random seed. Also via env. Eg: SEED=n rake # -v, --verbose Verbose. Show progress processing files. # -n, --name PATTERN Filter run on /regexp/ or string. # -e, --exclude PATTERN Exclude /regexp/ or string from run. # # Known extensions: pride, autotest # -p, --pride Pride. Show your testing pride! # -a, --autotest Connect to autotest server. # # You can set up a rake task to run all your tests by adding this to your # Rakefile: # # require "rake/testtask" # # Rake::TestTask.new(:test) do |t| # t.libs << "test" # t.libs << "lib" # t.test_files = FileList["test/**/test_*.rb"] # end # # task :default => :test # # ## Writing Extensions # # To define a plugin, add a file named minitest/XXX_plugin.rb to your # project/gem. That file must be discoverable via ruby's LOAD_PATH (via rubygems # or otherwise). Minitest will find and require that file using Gem.find_files. # It will then try to call `plugin_XXX_init` during startup. The option # processor will also try to call `plugin_XXX_options` passing the OptionParser # instance and the current options hash. This lets you register your own # command-line options. Here's a totally bogus example: # # # minitest/bogus_plugin.rb: # # module Minitest # def self.plugin_bogus_options(opts, options) # opts.on "--myci", "Report results to my CI" do # options[:myci] = true # options[:myci_addr] = get_myci_addr # options[:myci_port] = get_myci_port # end # end # # def self.plugin_bogus_init(options) # self.reporter << MyCI.new(options) if options[:myci] # end # end # # ### Adding custom reporters # # Minitest uses composite reporter to output test results using multiple # reporter instances. You can add new reporters to the composite during the # init_plugins phase. As we saw in `plugin_bogus_init` above, you simply add # your reporter instance to the composite via `<<`. # # `AbstractReporter` defines the API for reporters. You may subclass it and # override any method you want to achieve your desired behavior. # # start # : Called when the run has started. # record # : Called for each result, passed or otherwise. # report # : Called at the end of the run. # passed? # : Called to see if you detected any problems. # # # Using our example above, here is how we might implement MyCI: # # # minitest/bogus_plugin.rb # # module Minitest # class MyCI < AbstractReporter # attr_accessor :results, :addr, :port # # def initialize options # self.results = [] # self.addr = options[:myci_addr] # self.port = options[:myci_port] # end # # def record result # self.results << result # end # # def report # CI.connect(addr, port).send_results self.results # end # end # # # code from above... # end # # ## FAQ # # ### What versions are compatible with what? Or what versions are supported? # # Minitest is a dependency of rails, which until fairly recently had an # overzealous backwards compatibility policy. As such, I'm stuck supporting # versions of ruby that are long past EOL. Once rails 5.2 is dropped (hopefully # April 2021), I get to drop a bunch of versions of ruby that I have to # currently test against. # # (As of 2021-01-31) # # Current versions of rails: (https://endoflife.date/rails) # # | rails | min ruby | rec ruby | minitest | status | # |-------+----------+----------+----------+----------| # | 7.0 | >= 2.7 | 3.0 | >= 5.1 | Future | # | 6.1 | >= 2.5 | 3.0 | >= 5.1 | Current | # | 6.0 | >= 2.5 | 2.6 | >= 5.1 | Security | # | 5.2 | >= 2.2.2 | 2.5 | ~> 5.1 | Security | EOL @railsconf 2021? # # Current versions of ruby: (https://endoflife.date/ruby) # # | ruby | Status | EOL Date | # |------+---------+------------| # | 3.0 | Current | 2024-03-31 | # | 2.7 | Maint | 2023-03-31 | # | 2.6 | Maint* | 2022-03-31 | # | 2.5 | EOL | 2021-03-31 | # | 2.4 | EOL | 2020-03-31 | # | 2.3 | EOL | 2019-03-31 | # | 2.2 | EOL | 2018-03-31 | # # See also: # # * https://www.fastruby.io/blog/ruby/rails/versions/compatibility-table.html # * https://jamesjeffersconsulting.com/ruby-rails-version-matrix/ # # # ### How to test SimpleDelegates? # # The following implementation and test: # # class Worker < SimpleDelegator # def work # end # end # # describe Worker do # before do # @worker = Worker.new(Object.new) # end # # it "must respond to work" do # _(@worker).must_respond_to :work # end # end # # outputs a failure: # # 1) Failure: # Worker#test_0001_must respond to work [bug11.rb:16]: # Expected # (Object) to respond to #work. # # Worker is a SimpleDelegate which in 1.9+ is a subclass of BasicObject. # Expectations are put on Object (one level down) so the Worker (SimpleDelegate) # hits `method_missing` and delegates down to the `Object.new` instance. That # object doesn't respond to work so the test fails. # # You can bypass `SimpleDelegate#method_missing` by extending the worker with # `Minitest::Expectations`. You can either do that in your setup at the instance # level, like: # # before do # @worker = Worker.new(Object.new) # @worker.extend Minitest::Expectations # end # # or you can extend the Worker class (within the test file!), like: # # class Worker # include ::Minitest::Expectations # end # # ### How to share code across test classes? # # Use a module. That's exactly what they're for: # # module UsefulStuff # def useful_method # # ... # end # end # # describe Blah do # include UsefulStuff # # def test_whatever # # useful_method available here # end # end # # Remember, `describe` simply creates test classes. It's just ruby at the end of # the day and all your normal Good Ruby Rules (tm) apply. If you want to extend # your test using setup/teardown via a module, just make sure you ALWAYS call # super. before/after automatically call super for you, so make sure you don't # do it twice. # # ### How to run code before a group of tests? # # Use a constant with begin...end like this: # # describe Blah do # SETUP = begin # # ... this runs once when describe Blah starts # end # # ... # end # # This can be useful for expensive initializations or sharing state. Remember, # this is just ruby code, so you need to make sure this technique and sharing # state doesn't interfere with your tests. # # ### Why am I seeing `uninitialized constant MiniTest::Test (NameError)`? # # Are you running the test with Bundler (e.g. via `bundle exec` )? If so, in # order to require minitest, you must first add the `gem 'minitest'` to your # Gemfile and run `bundle`. Once it's installed, you should be able to require # minitest and run your tests. # # ## Prominent Projects using Minitest: # # * arel # * journey # * mime-types # * nokogiri # * rails (active_support et al) # * rake # * rdoc # * ...and of course, everything from seattle.rb... # # # ## Developing Minitest: # # Minitest requires [Hoe](https://rubygems.org/gems/hoe). # # ### Minitest's own tests require UTF-8 external encoding. # # This is a common problem in Windows, where the default external Encoding is # often CP850, but can affect any platform. Minitest can run test suites using # any Encoding, but to run Minitest's own tests you must have a default external # Encoding of UTF-8. # # If your encoding is wrong, you'll see errors like: # # --- expected # +++ actual # @@ -1,2 +1,3 @@ # # encoding: UTF-8 # -"Expected /\\w+/ to not match \"blah blah blah\"." # +"Expected /\\w+/ to not match # encoding: UTF-8 # +\"blah blah blah\"." # # To check your current encoding, run: # # ruby -e 'puts Encoding.default_external' # # If your output is something other than UTF-8, you can set the RUBYOPTS env # variable to a value of '-Eutf-8'. Something like: # # RUBYOPT='-Eutf-8' ruby -e 'puts Encoding.default_external' # # Check your OS/shell documentation for the precise syntax (the above will not # work on a basic Windows CMD prompt, look for the SET command). Once you've got # it successfully outputing UTF-8, use the same setting when running rake in # Minitest. # # ### Minitest's own tests require GNU (or similar) diff. # # This is also a problem primarily affecting Windows developers. PowerShell has # a command called diff, but it is not suitable for use with Minitest. # # If you see failures like either of these, you are probably missing diff tool: # # 4) Failure: # TestMinitestUnitTestCase#test_assert_equal_different_long [D:/ruby/seattlerb/minitest/test/minitest/test_minitest_test.rb:936]: # Expected: "--- expected\n+++ actual\n@@ -1 +1 @@\n-\"hahahahahahahahahahahahahahahahahahahaha\"\n+\"blahblahblahblahblahblahblahblahblahblah\"\n" # Actual: "Expected: \"hahahahahahahahahahahahahahahahahahahaha\"\n Actual: \"blahblahblahblahblahblahblahblahblahblah\"" # # 5) Failure: # TestMinitestUnitTestCase#test_assert_equal_different_collection_hash_hex_invisible [D:/ruby/seattlerb/minitest/test/minitest/test_minitest_test.rb:845]: # Expected: "No visible difference in the Hash#inspect output.\nYou should look at the implementation of #== on Hash or its members.\n # {1=>#}" # Actual: "Expected: {1=>#}\n Actual: {1=>#}" # # If you use Cygwin or MSYS2 or similar there are packages that include a GNU # diff for Windows. If you don't, you can download GNU diffutils from # http://gnuwin32.sourceforge.net/packages/diffutils.htm (make sure to add it to # your PATH). # # You can make sure it's installed and path is configured properly with: # # diff.exe -v # # There are multiple lines of output, the first should be something like: # # diff (GNU diffutils) 2.8.1 # # If you are using PowerShell make sure you run diff.exe, not just diff, which # will invoke the PowerShell built in function. # # ## Known Extensions: # # capybara_minitest_spec # : Bridge between Capybara RSpec matchers and Minitest::Spec expectations # (e.g. `page.must_have_content("Title")`). # color_pound_spec_reporter # : Test names print Ruby Object types in color with your Minitest Spec style # tests. # minispec-metadata # : Metadata for describe/it blocks & CLI tag filter. E.g. `it "requires JS # driver", js: true do` & `ruby test.rb --tag js` runs tests tagged :js. # minispec-rails # : Minimal support to use Spec style in Rails 5+. # mini-apivore # : for swagger based automated API testing. # minitest-around # : Around block for minitest. An alternative to setup/teardown dance. # minitest-assert_errors # : Adds Minitest assertions to test for errors raised or not raised by # Minitest itself. # minitest-autotest # : autotest is a continuous testing facility meant to be used during # development. # minitest-bacon # : minitest-bacon extends minitest with bacon-like functionality. # minitest-bang # : Adds support for RSpec-style let! to immediately invoke let statements # before each test. # minitest-bisect # : Helps you isolate and debug random test failures. # minitest-blink1_reporter # : Display test results with a Blink1. # minitest-capistrano # : Assertions and expectations for testing Capistrano recipes. # minitest-capybara # : Capybara matchers support for minitest unit and spec. # minitest-chef-handler # : Run Minitest suites as Chef report handlers # minitest-ci # : CI reporter plugin for Minitest. # minitest-context # : Defines contexts for code reuse in Minitest specs that share common # expectations. # minitest-debugger # : Wraps assert so failed assertions drop into the ruby debugger. # minitest-display # : Patches Minitest to allow for an easily configurable output. # minitest-documentation # : Minimal documentation format inspired by rspec's. # minitest-doc_reporter # : Detailed output inspired by rspec's documentation format. # minitest-emoji # : Print out emoji for your test passes, fails, and skips. # minitest-english # : Semantically symmetric aliases for assertions and expectations. # minitest-excludes # : Clean API for excluding certain tests you don't want to run under certain # conditions. # minitest-fail-fast # : Reimplements RSpec's "fail fast" feature # minitest-filecontent # : Support unit tests with expectation results in files. Differing results # will be stored again in files. # minitest-filesystem # : Adds assertion and expectation to help testing filesystem contents. # minitest-firemock # : Makes your Minitest mocks more resilient. # minitest-focus # : Focus on one test at a time. # minitest-gcstats # : A minitest plugin that adds a report of the top tests by number of objects # allocated. # minitest-global_expectations # : Support minitest expectation methods for all objects # minitest-great_expectations # : Generally useful additions to minitest's assertions and expectations. # minitest-growl # : Test notifier for minitest via growl. # minitest-happy # : GLOBALLY ACTIVATE MINITEST PRIDE! RAWR! # minitest-have_tag # : Adds Minitest assertions to test for the existence of HTML tags, including # contents, within a provided string. # minitest-heat # : Reporting that builds a heat map of failure locations # minitest-hooks # : Around and before_all/after_all/around_all hooks # minitest-hyper # : Pretty, single-page HTML reports for your Minitest runs # minitest-implicit-subject # : Implicit declaration of the test subject. # minitest-instrument # : Instrument ActiveSupport::Notifications when test method is executed. # minitest-instrument-db # : Store information about speed of test execution provided by # minitest-instrument in database. # minitest-junit # : JUnit-style XML reporter for minitest. # minitest-keyword # : Use Minitest assertions with keyword arguments. # minitest-libnotify # : Test notifier for minitest via libnotify. # minitest-line # : Run test at line number. # minitest-logger # : Define assert_log and enable minitest to test log messages. Supports # Logger and Log4r::Logger. # minitest-macruby # : Provides extensions to minitest for macruby UI testing. # minitest-matchers # : Adds support for RSpec-style matchers to minitest. # minitest-matchers_vaccine # : Adds assertions that adhere to the matcher spec, but without any # expectation infections. # minitest-metadata # : Annotate tests with metadata (key-value). # minitest-mock_expectations # : Provides method call assertions for minitest. # minitest-mongoid # : Mongoid assertion matchers for Minitest. # minitest-must_not # : Provides must_not as an alias for wont in Minitest. # minitest-optional_retry # : Automatically retry failed test to help with flakiness. # minitest-osx # : Reporter for the Mac OS X notification center. # minitest-parallel_fork # : Fork-based parallelization # minitest-parallel-db # : Run tests in parallel with a single database. # minitest-power_assert # : PowerAssert for Minitest. # minitest-predicates # : Adds support for .predicate? methods. # minitest-profile # : List the 10 slowest tests in your suite. # minitest-rails # : Minitest integration for Rails 3.x. # minitest-rails-capybara # : Capybara integration for Minitest::Rails. # minitest-reporters # : Create customizable Minitest output formats. # minitest-rg # : Colored red/green output for Minitest. # minitest-rspec_mocks # : Use RSpec Mocks with Minitest. # minitest-server # : minitest-server provides a client/server setup with your minitest process, # allowing your test run to send its results directly to a handler. # minitest-sequel # : Minitest assertions to speed-up development and testing of Ruby Sequel # database setups. # minitest-shared_description # : Support for shared specs and shared spec subclasses # minitest-should_syntax # : RSpec-style `x.should == y` assertions for Minitest. # minitest-shouldify # : Adding all manner of shoulds to Minitest (bad idea) # minitest-snail # : Print a list of tests that take too long # minitest-spec-context # : Provides rspec-ish context method to Minitest::Spec. # minitest-spec-expect # : Expect syntax for Minitest::Spec (e.g. expect(sequences).to_include # :celery_man). # minitest-spec-magic # : Minitest::Spec extensions for Rails and beyond. # minitest-spec-rails # : Drop in Minitest::Spec superclass for ActiveSupport::TestCase. # minitest-sprint # : Runs (Get it? It's fast!) your tests and makes it easier to rerun # individual failures. # minitest-stately # : Find leaking state between tests # minitest-stub_any_instance # : Stub any instance of a method on the given class for the duration of a # block. # minitest-stub-const # : Stub constants for the duration of a block. # minitest-tags # : Add tags for minitest. # minitest-unordered # : Adds a new assertion to minitest for checking the contents of a # collection, ignoring element order. # minitest-vcr # : Automatic cassette managment with Minitest::Spec and VCR. # minitest_log # : Adds structured logging, data explication, and verdicts. # minitest_owrapper # : Get tests results as a TestResult object. # minitest_should # : Shoulda style syntax for minitest test::unit. # minitest_tu_shim # : Bridges between test/unit and minitest. # mongoid-minitest # : Minitest matchers for Mongoid. # mutant-minitest # : Minitest integration for mutant. # pry-rescue # : A pry plugin w/ minitest support. See pry-rescue/minitest.rb. # rematch # : Declutter your test files from large hardcoded data and update them # automatically when your code changes. # rspec2minitest # : Easily translate any RSpec matchers to Minitest assertions and # expectations. # # # ## Unknown Extensions: # # Authors... Please send me a pull request with a description of your minitest # extension. # # * assay-minitest # * detroit-minitest # * em-minitest-spec # * flexmock-minitest # * guard-minitest # * guard-minitest-decisiv # * minitest-activemodel # * minitest-ar-assertions # * minitest-capybara-unit # * minitest-colorer # * minitest-deluxe # * minitest-extra-assertions # * minitest-rails-shoulda # * minitest-spec # * minitest-spec-should # * minitest-sugar # * spork-minitest # # # ## Minitest related goods # # * minitest/pride fabric: # http://www.spoonflower.com/fabric/3928730-again-by-katie_allen # # # ## REQUIREMENTS: # # * Ruby 2.3+. No magic is involved. I hope. # # # ## INSTALL: # # sudo gem install minitest # # On 1.9, you already have it. To get newer candy you can still install the gem, # and then requiring "minitest/autorun" should automatically pull it in. If not, # you'll need to do it yourself: # # gem "minitest" # ensures you"re using the gem, and not the built-in MT # require "minitest/autorun" # # # ... usual testing stuffs ... # # DO NOTE: There is a serious problem with the way that ruby 1.9/2.0 packages # their own gems. They install a gem specification file, but don't install the # gem contents in the gem path. This messes up Gem.find_files and many other # things (gem which, gem contents, etc). # # Just install minitest as a gem for real and you'll be happier. # # ## LICENSE: # # (The MIT License) # # Copyright (c) Ryan Davis, seattle.rb # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the 'Software'), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. # module Minitest # # Registers Minitest to run at process exit # def self.autorun: () -> untyped # # 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: () ?{ () -> untyped } -> untyped def self.init_plugins: (untyped options) -> untyped def self.load_plugins: () -> (nil | untyped) # # 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) # klass.new(runnable_method).run # def self.run: (?untyped args) -> untyped # # Internal run method. Responsible for telling all Runnable sub-classes to run. # def self.__run: (untyped reporter, untyped options) -> untyped def self.process_args: (?untyped args) -> untyped def self.filter_backtrace: (untyped bt) -> untyped def self.run_one_method: (untyped klass, untyped method_name) -> untyped # :nodoc: def self.clock_time: () -> untyped def self.plugin_pride_options: (untyped opts, untyped _options) -> untyped def self.plugin_pride_init: (untyped options) -> (untyped | nil) attr_accessor self.parallel_executor: untyped attr_accessor self.backtrace_filter: untyped attr_accessor self.reporter: untyped attr_accessor self.extensions: untyped attr_accessor self.info_signal: untyped VERSION: String ENCS: true end