minitest-utils-0.2.4/0000755000175000017500000000000012572143203015774 5ustar balasankarcbalasankarcminitest-utils-0.2.4/minitest-utils.gemspec0000644000175000017500000000153312572143203022335 0ustar balasankarcbalasankarcrequire './lib/minitest/utils/version' Gem::Specification.new do |spec| spec.name = 'minitest-utils' spec.version = Minitest::Utils::VERSION spec.authors = ['Nando Vieira'] spec.email = ['fnando.vieira@gmail.com'] spec.summary = 'Some utilities for your Minitest day-to-day usage.' spec.description = spec.summary spec.homepage = 'http://github.com/fnando/minitest-utils' spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) } spec.bindir = 'exe' spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) } spec.require_paths = ['lib'] spec.add_dependency 'minitest' spec.add_development_dependency 'bundler', '~> 1.9' spec.add_development_dependency 'rake', '~> 10.0' spec.add_development_dependency 'pry-meta' end minitest-utils-0.2.4/Gemfile0000644000175000017500000000014312572143203017265 0ustar balasankarcbalasankarcsource 'https://rubygems.org' # Specify your gem's dependencies in minitest-utils.gemspec gemspec minitest-utils-0.2.4/.gitignore0000644000175000017500000000012712572143203017764 0ustar balasankarcbalasankarc/.bundle/ /.yardoc /Gemfile.lock /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ minitest-utils-0.2.4/Rakefile0000644000175000017500000000030712572143203017441 0ustar balasankarcbalasankarcrequire 'bundler/gem_tasks' require 'rake/testtask' Rake::TestTask.new(:test) do |t| t.libs << 'test' t.test_files = FileList['test/**/*_test.rb'] t.verbose = true end task :default => :test minitest-utils-0.2.4/lib/0000755000175000017500000000000012572143203016542 5ustar balasankarcbalasankarcminitest-utils-0.2.4/lib/minitest/0000755000175000017500000000000012572143203020376 5ustar balasankarcbalasankarcminitest-utils-0.2.4/lib/minitest/utils.rb0000644000175000017500000000034612572143203022066 0ustar balasankarcbalasankarcmodule Minitest module Utils require 'minitest' require 'minitest/utils/version' require 'minitest/utils/reporter' require 'minitest/utils/extension' require 'minitest/utils/test_notifier_reporter' end end minitest-utils-0.2.4/lib/minitest/utils_plugin.rb0000644000175000017500000000051412572143203023441 0ustar balasankarcbalasankarcrequire 'minitest/utils' module Minitest def self.plugin_utils_init(options) reporters = Minitest.reporter.reporters reporters.clear reporters << Minitest::Utils::Reporter.new(options[:io], options) reporters << Minitest::Utils::TestNotifierReporter.new(options[:io], options) if defined?(TestNotifier) end end minitest-utils-0.2.4/lib/minitest/utils/0000755000175000017500000000000012572143203021536 5ustar balasankarcbalasankarcminitest-utils-0.2.4/lib/minitest/utils/version.rb0000644000175000017500000000007712572143203023554 0ustar balasankarcbalasankarcmodule Minitest module Utils VERSION = '0.2.4' end end minitest-utils-0.2.4/lib/minitest/utils/rails/0000755000175000017500000000000012572143203022650 5ustar balasankarcbalasankarcminitest-utils-0.2.4/lib/minitest/utils/rails/webmock.rb0000644000175000017500000000044112572143203024623 0ustar balasankarcbalasankarcrequire 'webmock/minitest' WebMock.disable_net_connect!(allow: %w[codeclimate.com]) def WebMock.requests @requests ||= [] end WebMock.after_request do |request, response| WebMock.requests << request end class ActiveSupport::TestCase setup do WebMock.requests.clear end end minitest-utils-0.2.4/lib/minitest/utils/rails/capybara.rb0000644000175000017500000000043512572143203024761 0ustar balasankarcbalasankarcrequire 'capybara/rails' class ActionDispatch::IntegrationTest include Capybara::DSL setup do Capybara.reset_sessions! Capybara.use_default_driver end def self.use_javascript! setup do Capybara.current_driver = Capybara.javascript_driver end end end minitest-utils-0.2.4/lib/minitest/utils/rails/locale.rb0000644000175000017500000000040612572143203024434 0ustar balasankarcbalasankarcclass ActionDispatch::IntegrationTest setup do Rails.application.routes.default_url_options[:locale] = I18n.locale Rails.configuration.action_mailer.default_url_options = Rails.application.routes.default_url_options if defined?(ActionMailer) end end minitest-utils-0.2.4/lib/minitest/utils/rails/database_cleaner.rb0000644000175000017500000000017412572143203026434 0ustar balasankarcbalasankarcclass ActiveSupport::TestCase setup do DatabaseCleaner.start end teardown do DatabaseCleaner.clean end end minitest-utils-0.2.4/lib/minitest/utils/rails/factory_girl.rb0000644000175000017500000000011112572143203025652 0ustar balasankarcbalasankarcclass ActiveSupport::TestCase include FactoryGirl::Syntax::Methods end minitest-utils-0.2.4/lib/minitest/utils/reporter.rb0000644000175000017500000001100512572143203023722 0ustar balasankarcbalasankarcmodule Minitest module Utils class Reporter < Minitest::StatisticsReporter COLOR_FOR_RESULT_CODE = { '.' => :green, 'E' => :red, 'F' => :red, 'S' => :yellow } COLOR = { red: 31, green: 32, yellow: 33, blue: 34 } def initialize(*) super @color_enabled = io.respond_to?(:tty?) && io.tty? end def record(result) super print_result_code(result.result_code) end def start super io.puts "Run options: #{options[:args]}" io.puts io.puts "# Running:" io.puts end def report super io.sync = true failing_results = results.reject(&:skipped?) skipped_results = results.select(&:skipped?) color = :green color = :yellow if skipped_results.any? color = :red if failing_results.any? if failing_results.any? || skipped_results.any? failing_results.each.with_index(1) {|result, index| display_failing(result, index) } skipped_results.each.with_index(failing_results.size + 1) {|result, index| display_skipped(result, index) } end io.print "\n\n" io.puts statistics io.puts color(summary, color) if failing_results.any? io.puts "\nFailed Tests:\n" failing_results.each {|result| display_replay_command(result) } io.puts "\n\n" end end private def statistics "Finished in %.6fs, %.4f runs/s, %.4f assertions/s." % [total_time, count / total_time, assertions / total_time] end def summary # :nodoc: [ pluralize('run', count), pluralize('assertion', assertions), pluralize('failure', failures), pluralize('error', errors), pluralize('skip', skips), ].join(', ') end def indent(text) text.gsub(/^/, ' ') end def display_failing(result, index) backtrace = backtrace(result.failure.backtrace) message = result.failure.message message = message.lines.tap(&:pop).join.chomp if result.error? str = "\n\n" str << color("%4d) %s" % [index, result_name(result.name)]) str << "\n" << color(indent(message), :red) str << "\n" << color(backtrace, :blue) io.print str end def display_skipped(result, index) location = location(result.failure.location) str = "\n\n" str << color("%4d) %s [SKIPPED]" % [index, result_name(result.name)], :yellow) str << "\n" << indent(color(location, :yellow)) io.print str end def display_replay_command(result) location = find_test_file(result) return if location.empty? command = %[rake TEST=#{location} TESTOPTS="--name=#{result.name}"] str = "\n" str << color(command, :red) io.print str end def find_test_file(result) filter_backtrace(result.failure.backtrace) .find {|line| line.match(%r((test|spec)/.*?_(test|spec).rb)) } .to_s .gsub(/:\d+.*?$/, '') end def backtrace(backtrace) backtrace = filter_backtrace(backtrace).map {|line| location(line, true) } return if backtrace.empty? indent(backtrace.join("\n")).gsub(/^(\s+)/, "\\1# ") end def location(location, include_line_number = false) regex = include_line_number ? /^([^:]+:\d+)/ : /^([^:]+)/ location = File.expand_path(location[regex, 1]) return location unless location.start_with?(Dir.pwd) location.gsub(%r[^#{Regexp.escape(Dir.pwd)}/], '') end def filter_backtrace(backtrace) Minitest.backtrace_filter.filter(backtrace) end def result_name(name) name .gsub(/^test(_\d+)?_/, '') .gsub(/_/, ' ') end def print_result_code(result_code) result_code = color(result_code, COLOR_FOR_RESULT_CODE[result_code]) io.print result_code end def color(string, color = :default) if color_enabled? color = COLOR.fetch(color, 0) "\e[#{color}m#{string}\e[0m" else string end end def color_enabled? @color_enabled end def pluralize(word, count) case count when 0 "no #{word}s" when 1 "1 #{word}" else "#{count} #{word}s" end end end end end minitest-utils-0.2.4/lib/minitest/utils/rails.rb0000644000175000017500000000116112572143203023174 0ustar balasankarcbalasankarcclass ActiveSupport::TestCase extend Minitest::Spec::DSL if defined?(Minitest::Spec::DSL) require 'minitest/utils/rails/webmock' if defined?(WebMock) require 'minitest/utils/rails/capybara' if defined?(Capybara) require 'minitest/utils/rails/factory_girl' if defined?(FactoryGirl) require 'minitest/utils/rails/database_cleaner' if defined?(DatabaseCleaner) def t(*args) I18n.t(*args) end def l(*args) I18n.l(*args) end end class ActionMailer::TestCase include Rails.application.routes.url_helpers def default_url_options Rails.configuration.action_mailer.default_url_options end end minitest-utils-0.2.4/lib/minitest/utils/test_notifier_reporter.rb0000644000175000017500000000062512572143203026666 0ustar balasankarcbalasankarcmodule Minitest module Utils class TestNotifierReporter < Minitest::StatisticsReporter def report super stats = TestNotifier::Stats.new(:minitest, { count: count, assertions: assertions, failures: failures, errors: errors }) TestNotifier.notify(status: stats.status, message: stats.message) end end end end minitest-utils-0.2.4/lib/minitest/utils/extension.rb0000644000175000017500000000232512572143203024101 0ustar balasankarcbalasankarcmodule Minitest module Utils module Assertions def assert(test, message = nil) message ||= "expected: truthy value\ngot: #{mu_pp(test)}" super(test, message) end def refute(test, message = nil) message ||= "expected: falsy value\ngot: #{mu_pp(test)}" super(test, message) end end end class Test include ::Minitest::Utils::Assertions def self.test(name, &block) test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym defined = method_defined? test_name raise "#{test_name} is already defined in #{self}" if defined if block_given? define_method(test_name, &block) else define_method(test_name) do flunk "No implementation provided for #{name}" end end end def self.setup(&block) mod = Module.new mod.module_eval do define_method :setup do super() instance_eval(&block) end end include mod end def self.teardown(&block) mod = Module.new mod.module_eval do define_method :teardown do super() instance_eval(&block) end end include mod end end end minitest-utils-0.2.4/test/0000755000175000017500000000000012572143203016753 5ustar balasankarcbalasankarcminitest-utils-0.2.4/test/test_helper.rb0000644000175000017500000000011412572143203021612 0ustar balasankarcbalasankarcrequire 'bundler/setup' require 'minitest/utils' require 'minitest/autorun' minitest-utils-0.2.4/test/minitest/0000755000175000017500000000000012572143203020607 5ustar balasankarcbalasankarcminitest-utils-0.2.4/test/minitest/utils_test.rb0000644000175000017500000000320112572143203023327 0ustar balasankarcbalasankarcrequire 'test_helper' class MinitestUtilsTest < Minitest::Test def capture_exception yield rescue Exception => exception exception end test 'defines method name' do assert MinitestUtilsTest.instance_methods.include?(:test_defines_method_name) end test 'improves assert message' do exception = capture_exception { assert nil } assert_equal "expected: truthy value\ngot: nil", exception.message end test 'improves refute message' do exception = capture_exception { refute 1234 } assert_equal "expected: falsy value\ngot: 1234", exception.message end test 'raises exception for duplicated method name' do assert_raises(RuntimeError) { Class.new(Minitest::Test) do test 'some test' test 'some test' end } end test 'flunks method without block' do test_case = Class.new(Minitest::Test) do test 'flunk test' end assert_raises(Minitest::Assertion) { test_case.new('test').test_flunk_test } end test 'defines setup steps' do setups = [] test_case = Class.new(Minitest::Test) do setup { setups << 1 } setup { setups << 2 } setup { setups << 3 } test('do something') {} end test_case.new(Minitest::AbstractReporter).run assert_equal [1, 2, 3], setups end test 'defines teardown steps' do teardowns = [] test_case = Class.new(Minitest::Test) do teardown { teardowns << 1 } teardown { teardowns << 2 } teardown { teardowns << 3 } test('do something') {} end test_case.new(Minitest::AbstractReporter).run assert_equal [1, 2, 3], teardowns end end minitest-utils-0.2.4/README.md0000644000175000017500000000673412572143203017265 0ustar balasankarcbalasankarc# Minitest::Utils Some utilities for your Minitest day-to-day usage. Includes: - A better reporter (see screenshot below) - A [TestNotifier](http://github.com/fnando/test_notifier) reporter - Some Rails niceties (set up FactoryGirl, WebMock and Capybara) - Add a `t` and `l` methods (i18n) ## Installation Add this line to your application's Gemfile: ```ruby gem 'minitest-utils' ``` And then execute: $ bundle Or install it yourself as: $ gem install minitest-utils ## Defining tests This gem adds the `Minitest::Test.test` method, so you can easy define your methods like the following: ```ruby class SampleTest < Minitest::Test test 'useless test' do assert true end end ``` This is equivalent to defining a method named `test_useless_test`. You can also skip the block, which will define a [flunk](https://github.com/seattlerb/minitest/blob/77120c5b2511c4665610cda06c8058c801b28e7f/lib/minitest/assertions.rb#L477-L480) call. You can also define `setup` and `teardown` steps. ```ruby class SampleTest < Minitest::Test setup do DB.connect end teardown do DB.disconnect end test 'useless test' do assert true end end ``` ## Screenshots ![](https://raw.githubusercontent.com/fnando/minitest-utils/master/screenshots/light-failing.png) ![](https://raw.githubusercontent.com/fnando/minitest-utils/master/screenshots/light-success.png) ![](https://raw.githubusercontent.com/fnando/minitest-utils/master/screenshots/dark-failing.png) ![](https://raw.githubusercontent.com/fnando/minitest-utils/master/screenshots/dark-success.png) ## Rails extensions minitest-utils sets up some things for your Rails application. Just load `minitest/utils/rails` to set up: - [Capybara](https://github.com/jnicklas/capybara): includes `Capybara::DSL`, sets default driver before every test, resets session and creates a helper method for setting JavaScript driver. - [FactoryGirl](https://github.com/thoughtbot/factory_girl): adds methods to `ActiveSupport::TestCase`. - [WebMock](https://github.com/bblimke/webmock): disables external requests (except for codeclimate) and tracks all requests on `WebMock.requests`. - locale routes: sets `Rails.application.routes.default_url_options[:locale]` with your current locale. - [DatabaseCleaner](https://github.com/DatabaseCleaner/database_cleaner): runs `DatabaseCleaner.start` and `DatabaseCleaner.clean` before and after every test respectively. - Other: `t` and `l` alias to I18n. ```ruby class SignupTest < ActionDispatch::IntegrationTtest use_javascript! #=> enables JavaScript driver end ``` Also, if you're using routes like `:locale` scope, you can load this file to automatically set your route's `:locale` param. ```ruby require 'minitest/utils/rails/locale' ``` ## Development After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing 1. Fork it ( https://github.com/fnando/minitest-utils/fork ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create a new Pull Request