InfoQ

News

Matrix Your Rails Functional Tests

Posted by Sebastien Auvray on Apr 19, 2007

Community
Ruby
Topics
Software Testing ,
Unit Testing
Tags
ZenTest ,
Testing
Ryan Davis added a new way to test multiple edge cases in his latest test suite release: ZenTest 3.5.0. The way he suggests to make it clearer is by using a matrix. Let's imagine you have rights properties to test in your application (with orthogonal states: readable vs unreadable, ...). You would basically end with the following 4 methods:
def test_edit_user_readable
    some_setup_to_initialize_user_readable_context
    some_action_here_edit
    some_assertion_error_read
end

def test_edit_user_writable
    some_setup_to_initialize_user_writable_context
    some_action_here_edit
    some_assertion_edit
end

def test_view_user_readable
    some_setup_to_initialize_user_readable_context
    some_action_here_view
    some_other_assertion_view
end

def test_view_user_writable
    some_setup_to_initialize_user_writable_context
    some_action_here_view
    some_other_assertion_view
end
You can easily see that some pieces of this code (setups, actions) can be factored. But Ryan went a step further by reorganizing it into a matrix where the column headers represent the different setup cases, the row headers represent the action applied and the intersection defines the expected result for a given action and setup context.

The 4 test cases will look like this:
setups   :user_readable, :user_writable
matrix :edit, :error_read, :edit
matrix :view, :view, :view
ZenTest will stores off the edge case through the setups method and the matrix method will create a test method for every applicable result:
def test_#{action}_#{setup}
    matrix_setup_configuration #{setup}.split(//) # global setup
    matrix_setup_#{action} #{setup}, #{expected} # action setup + execution
    matrix_test_#{expected}, #{setup} # expected verification
end
So at the end the setup configuration will be factored at one place taking into parameters the different edge cases, the actions and assertions will also be put apart.

Ryan Davis gives a clear visual example of test cases before and after matrixization:

Before After

Click the images to see the code in more detail.


The test matrix model is another demonstration of the DRY (Don't Repeat Yourself) process philosophy. It also easily makes it possible for non-developer to read and add tests by only modifying the matrix.

No comments

Watch Thread Reply

Educational Content

Brian Marick on 4 Challenges and 5 Guiding Values of Agile Software Development

Brian Marick takes us through a quick tour of the most important values and challenges to adopting Agile successfully (they aren't the typical challenges and values we hear in the community).

Are You a Software Architect?

The line between development and architecture is tricky. Does it exist at all? Is an ivory tower actually needed? There's a balance in the middle, but how do you move from developer to architect?

Agile – A Way of Life and Pragmatic Use of Authority

The word 'authority' sometimes produces an allergic response in hard-line agilists. Freedom and authority – both are bad if misused and both are good if used in right spirit for a noble cause.

Getting Started with Grails, Second Edition

"Getting Started with Grails" brings you up to speed on this modern web framework. Companies as varied as LinkedIn, Wired, and Taco Bell are all using Grails. Are you ready to get started as well?

Using ITIL V3 as a Foundation for SOA Governance

Those familiar with only ITIL V2 often scoff at the thought that ITIL could serve as a governance framework for SOA. With ITIL V3, the focus of the framework shifted towards service-orientation.

Adrian Colyer on AspectJ, tc Server and dm Server

SpringSource CTO Adrian Colyer discusses AspectJ, SpringSource's dm Server and tc Server products, OSGi and Scrum.

Adam Wiggins on Heroku

Heroku's Adam Wiggins talks about Rails, Background Jobs, Add-Ons, Ruby, and how Heroku manages to work around Ruby's inefficiencies using Erlang and other languages.

SOA as an Architectural Pattern: Best Practices in Software Architecture

For Grady Booch the foundation of a good architecture is patterns, SOA being just one of many patterns. In this Second Life presentation, Booch attempts to bring more clarity on what architecture is.