Reusing minitest integration tests - ruby-on-rails

Question

I have three pages in Rails that all display the same header, and hence would require the exact same integration tests.
Instead of repeating myself and writing separate tests that look almost exactly the same, what's the best approach here? I've tried putting the shared assertions into a module but haven't been successful getting it to load into each test scenario.
UNDRY:
class IntegrationTest
describe "page one" do
before { visit page_one_path }
it "should have a home page link" do
page.find_link "Home"
end
end
describe "page two" do
before { visit page_two_path }
it "should have a home page link" do
page.find_link "Home"
end
end
describe "page three" do
before { visit page_three_path }
it "should have a home page link" do
page.find_link "Home"
end
end
end
Failed attempt at drying it out...
Module:
/lib/tests/shared_test.rb
module SharedTest
def test_header
it "should have a home page link" do
page.find_link "Home"
end
end
end
Test:
class IntegrationTest
include SharedTest
describe "page one" do
before { visit page_one_path }
test_header
end
describe "page two" do
before { visit page_two_path }
test_header
end
describe "page three" do
before { visit page_three_path }
test_header
end
end
I haven't quite figured out how to write modules yet so it's no surprise that this doesn't work. Can someone point me in the right direction?

Answer 1

The way to share tests between different describe blocks when using Minitest's spec DSL is to include the module in each describe block you want those tests to run in.
module SharedTest
def test_header
assert_link "Home"
end
end
class IntegrationTest < ActiveDispatch::IntegrationTest
describe "page one" do
include SharedTest
before { visit page_one_path }
end
describe "page two" do
include SharedTest
before { visit page_two_path }
end
describe "page three" do
include SharedTest
before { visit page_three_path }
end
end
One of the ways the Minitest's Test API is different than Minitest Spec DSL is in how they behave when being inherited. Consider the following:
class PageOneTest < ActiveDispatch::IntegrationTest
def setup
visit page_one_path
end
def test_header
assert_link "Home"
end
end
class PageTwoTest < PageOneTest
def setup
visit page_two_path
end
end
class PageThreeTest < PageOneTest
def setup
visit page_three_path
end
end
The PageTwoTest and PageThreeTest test classes inherit from PageOneTest, and because of that they all have the test_header method. Minitest will run all three tests. But, when implemented with the spec DSL the test_header method is not inherited.
class PageOneTest < ActiveDispatch::IntegrationTest
def setup
visit page_one_path
end
def test_header
assert_link "Home"
end
describe "page two" do
before { visit page_two_path }
end
describe "page three" do
before { visit page_three_path }
end
end
In this case, only one test is run. The test class created by describe "page two" will inherit from PageOneTest, but will have all of the test methods removed. Why? Because Minitest's spec DSL is based on RSpec, and this is the way that RSpec works. Minitest goes out of its way to nuke the test methods that are inherited when using the spec DSL. So the only way to share tests while using the spec DSL is to include the module in each describe block you want them to be in. All other non-test methods, including the before and after hooks, and the let accessors, will be inherited

Answer 2

Here's a clean way to reuse tests when using MiniTest's spec DSL - define the tests inside a function and call that function where you want to include your tests.
Example:
def include_shared_header_tests
it "should be longer than 5 characters" do
assert subject.length > 5
end
it "should have at least one capital letter" do
assert /[A-Z]/ =~ subject
end
end
# This block will pass
describe "A good header" end
subject { "I'm a great header!" }
include_shared_header_tests
end
# This block will fail
describe "A bad header" end
subject { "bad" }
include_shared_header_tests
end

Answer 3

If you want to continue to use the Spec style in the module, you can use the Module::included hook.
module SharedTests
def self.included spec
spec.class_eval do
# Your shared code here...
let(:foo) { 'foo' }
describe '#foo' do
it { foo.must_equal 'foo' }
end
end
end
end
class MyTest < Minitest::Spec
include SharedTests
end
class MyOtherTest < Minitest::Spec
include SharedTests
end
# It also works in nested describe blocks.
class YetAnotherTest < Minitest::Spec
describe 'something' do
describe 'when it acts some way' do
include SharedTests
end
end
end
Another approach to repetitive tests is iteration.
class IntegrationTest < Minitest::Spec
{
'page one' => :page_one_path,
'page two' => :page_two_path,
'page three' => :page_three_path,
}.each do |title, path|
describe title do
before { visit send(path) }
it 'should have a home page link' do
page.find_link 'Home'
end
end
end
end