A better way of testing Rails application with minitest.

In this post I would like to share with you some of my work, that I have just done. And it is about a better way of testing Rails application with minitest.
In my previous post you can find my quick tutorial about how it is possible to use minitest with Rails. But following that post you can also find some inconvenience, with all that manual work around, that needs to be done. That was not good enough for me, so I moved the stuff forward into more cleaner solution.

The major improvements have been made for minitest-rails gem. Most of the modules inclusions have been moved from test helper into gem's lib.
The integration test generator with templates has been added. Models, controllers and integration tests should now work just fine, without any special care about stuff like subject, @controller, etc. to be explicitly defined. Also some Rails specific assertions (with new defined spec expectations) are now available with no effort.
Also, thanks to capybara_minitest_spec gem, it is now possible to use capybara within integration tests, with some extra spec expectations provided.
Everything now should be clean and simple.

While using either Test::Unit or RSpec, I usually used to get some help from shoulda-matchers gem. I would like to use those handy matchers with minitest, as well. I found  minitest-matchers gem makes this to be possible.
Using both gems together I was able to save tons of LOC again. But to have that, I needed few extra steps. To make it all to be available in one go, I have created gem called minitest-rails-shoulda.

Please note, that all my work on those gems is a kind of "not necessary get to know how it works, but just make it work" and it may need some code improvements. Also, it has not been merged into upstream repositories yet. That means those new features are not included in currently released gems. That is why I am using my forks from github in this post. This may change in the future and if so, expect this post to be updated. But until then, remember - you are using this stuff on your own risk;)

OK, let me show you at last how I test Rails application using minitest.
Just to let you know, in case you want to follow this post, that I was using ruby 1.9.3p0 and Rails 3.1.3 to go through.

1. Application Setup

First. Create a brand new rails application.

$ rails new TestApp -T

Option -T skips test unit as we don't want to use it.

Add to our Gemfile

group :test, :development do
  gem 'minitest-rails',
      :git => "git@github.com/rawongithub/minitest-rails.git",
      :branch => "gemspec"
end
group :test do
  gem 'minitest-rails-shoulda',
      :git => "git@github.com/rawongithub/minitest-rails-shoulda.git"  
  gem 'capybara_minitest_spec'
end

This should match the following dependent gems to be installed automatically:

• minitest
• minitest-rails
• minitest-matchers
• shoulda-matchers

Don't forget to run bundler against our new Gemfile content:

$ bundle install

Note: You may need to run this either with --without assets option or add gem 'therubyracer' into assets group of your Gemfile.

Run the minitest installation generator:

$ rails generate mini_test:install

This should create minitest_helper.rb file within test directory

Edit our test/minitest_helper.rb to look like this:

require "minitest/autorun"
require "minitest/rails"
require "minitest/pride" # let's have awesome colorful output;)

ENV["RAILS_ENV"] = "test"
require File.expand_path('../../config/environment', __FILE__)

class MiniTest::Rails::Spec
  # Add methods to be used by all specs here
end

class MiniTest::Rails::Model
  # make fixtures available within models spec
  include MiniTest::Rails::Fixtures
end

class MiniTest::Rails::Controller
  # Add methods to be used by controller specs here
end

class MiniTest::Rails::Helper
  # Add methods to be used by helper specs here
end

class MiniTest::Rails::Mailer
  # Add methods to be used by mailer specs here
end

class MiniTest::Rails::Integration
  # Add methods to be used by integration specs here
end

Make minitest generators to use spec syntax and fixtures. Add this to our config/application.rb:

config.generators do |g|
  g.test_framework :mini_test, :spec => true, :fixture => true
  g.integration_tool :mini_test
end

2. Testing Models

Generate a sample model:

$ rails generate model User name:string

This should create files:
test/fixtures/users.yml
test/models/user_test.rb
db/migrate/[timestamp]_create_users.rb

Create database unless exists, run migrations and prepare database for test environment:

$ rake db:create
$ rake db:migrate
$ rake db:test:prepare

Edit test/fixtures/users.yml with sample data:

tester:
  name: "Tester"

Put some sample tests into test/models/user_test.rb:

require "minitest_helper"
describe User do
  fixtures :users
  let(:tester) { users(:tester) }
  context "database" do
    it { must have_db_column(:name).of_type(:string) }
  end
  context "instance methods" do
    it "#name returns name" do
      tester.name.must_equal "Tester"
    end
  end
end

And here we are. We can now run our model tests:

$ rake test:models

3. Testing Controllers

Generate sample controller and view:

$ rails generate controller Website index

This should create some files. We need one of them only for now.
Edit test/controllers/website_controller_test.rb with sample test:

require "minitest_helper"
describe WebsiteController do
  context "index action" do
    before do
      get :index
    end
    it { must_respond_with :success }
    it "must render index view" do
      must_render_template :index
    end
  end
end

Run controllers tests and watch how they pass.

$ rake test:controllers

4. Integration Tests

Generate an integration test

$ rails generate integration_test Website

This should create test/integration/website_test.rb

Edit test/integration/website_test.rb with sample test:

require "minitest_helper"
describe "Website Integration Test" do
  context "website#index" do
    before do
      get "/website/index"
    end
    it { must_respond_with :success }
    #capybara usage example
    it "website index page must be accessible" do
      visit website_index_path
      page.must_have_content("Website#index")
    end
  end
end

Note: To make it work we need to keep naming convention for #describe argument:
"<Name> Integration Test"

Finally, run integration tests.

$ rake test:integration

5. Summary

As you can see testing Rails application with minitest can be very straightforward with minimum effort.
Although there is a lot of work to be done yet, what we have so far should be enough to start using this lightweight and modern testing framework with Rails.
Thanks for reading, and please give me a feedback.