Unit-testing frameworks for Ruby

Unit Testing

A unit is the smallest building block of a software. Such a unit can be: a class, a method, an interface etc. Unit testing is the process of validating such units of code.

Benefits

Some of the benefits are:

Proof of your code.
Better design - Thinking about the tests can help us to create small design elements, thereby improving the modularity and reusability of units.
Safety net on bugs - Unit tests will confirm that while refactoring no additional errors were introduced.
Relative cost - It helps to detect and remove defects in a more cost effective manner compared to the other stages of testing.
Individual tests - Enables us to test parts of a source code in isolation.
Less compile-build-debug cycles - Makes debugging more efficient by searching for bugs in the probable code areas.
Documentation - Designers can look at the unit test for a particular method and learn about its functionality.

Unit-testing frameworks

Unit Test Framework is a software tool to support writing and running unit test.

The above diagram shows the relationships of unit tests to production code. Application is built from objects linked together. The unit test uses this application's objects but exists inside the unit test framework.

List of most popular unit testing frameworks for Ruby

Simple application code in Ruby

Let us write a Calculator class in a file called calculator.rb. It has four methods addition, subtraction, multiplication and division. Later in the chapter we shall write tests in each of the above frameworks respectively.

class Calculator 
 
 attr_writer :number1 
 attr_writer :number2
 
 def initialize(number1,number2)
   @number1 = number1
   @number2 = number2
 end
#-----------Addition of two numbers----------------#
 def addition
   result = @number1 + @number2
   return result
 end
#----------Subtraction of two numbers--------------#
  def subtraction
    result= @number1 - @number2
    return result
  end
#----------Multiplication of two numbers------------#
  def multiplication
    result= @number1 * @number2
    return result
  end
#-----------Division of two numbers-------------------#
 def division
   result = @number1 / @number2
   return result
 end
end

Test::Unit

Features of Test::Unit

Assertions

An assertion statement specifies a condition that you expect to hold true at some particular point in your program. If that condition does not hold true, the assertion fails. An error is propagated with pertinent information so that you can go back and make your assertion succeed.

Test Fixture

A test fixture is used to initialize (and cleanup) the common objects for two or more tests. It eliminates unnecessary duplication.

Test Method

A test method is a definitive procedure that produces a test result.

Test Runners

To run the test class and view any failures that occur during the run we need a Test Runner. Examples -Test::Unit::UI::Console::TestRunner, Test::Unit::UI::GTK::TestRunner, etc.

Test Suite

A collection of tests which can be run.

Installing Test::Unit

Ruby 1.8 comes preinstalled with Test::Unit framework.

Usage

The general idea behind unit testing is that you write a test method that makes certain assertions about your code. The results of a run are gathered in a test result and displayed to the user through some UI. To write a test, follow these steps:

require ‘test/unit’ in your test script.
Create a class that subclasses Test::Unit::TestCase.
Add a method that begins with "test" to your class.
Make assertions in your test method.
Optionally define setup and/or teardown to set up and/or tear down your common test fixture.
Run your test as Test::Unit Test.

Example of a test class

 require "calculator"
 require "test/unit"

 class TC_Calculator < Test::Unit::TestCase
  
  
  def test_addition
    assert_equal(8,Calculator.new(3,4).addition)
   
  end
 
  def test_subtraction
   assert_same(1,Calculator.new(4,3).subtraction)
  end
 
  def test_multiplication
   assert_not_same(12,Calculator.new(3,4).multiplication)
  end
 
  def test_division
     assert_not_equal(5,Calculator.new(8,2).division)
  end
 end

If we run this test, here is how it'll look like -

Shoulda

Features of Shoulda

It is a library that allows us to write better and more understandable tests for your Ruby application.
It's like overdrive for Test::Unit and RSpec.
It allows us to set up contexts which equal the describe-blocks in RSpec. The context framework helps us avoid the tedious method-based style of Test::Unit.
It allows us to use the "it"-blocks from RSpec to define nice error-messages if a test fails.
Shoulda is simply an extension to Test::Unit. It works inside Test::Unit — you can even mix Shoulda tests with regular Test::Unit test methods.

Installing Shoulda

If your Environment path is set to " ...\Ruby\bin" then open command prompt and run gem install shoulda.

Usage

So here is our class "TC_Calculator_Shoulda" which inherits "Test::Unit::TestCase".

Add require"rubygems" and require "shoulda" to the script.
Set up a context.
Define a method starting with should “...” do and give a description to the method.
Make assertions in your method.

 require "rubygems"
 require "calculator"
 require "test/unit"
 require "shoulda"

 class TC_Calculator_Shoulda < Test::Unit::TestCase

  context "Calculate" do

   should "addition of two numbers " do
     assert_equal 8,Calculator.new(3,4).addition 
   end

   should "subtraction of two numbers " do
    assert_equal 1,Calculator.new(4,3).subtraction
   end

   should "multiplication of two numbers" do
    assert_equal 12,Calculator.new(3,4).multiplication
   end

   should "division of two numbers" do
    assert_equal 4,Calculator.new(12,3).division
   end

  end

 end

Let us run it as a "Ruby Application":

produces:

Loaded suite tc__calculator__shoulda
Started
F...
Finished in 0.064 seconds.
 1) Failure:
    test: Calculate should addition of two numbers . (TC_Calculator_Shoulda)
    <8> expected but was
    <7>.
4 tests, 4 assertions, 1 failures, 0 errors

RSpec

Features of RSpec

RSpec is a Behavior Driven Development tool for ruby.
It provides Domain-specific language for talking about what code should do (allows developers to write system requirements in a Ruby format).
An evolution from Test-driven development and Domain Driven Design.
RSpec drives the design.
The RSpec framework provides us a way to write specifications for our code that are executable well before you’ve written a line of application code.
These specs take us a step ahead of shoulda's nice and descriptive error messages. When run, these specs will output the system requirements that describe your application.

Too much theory up front can be dangerous, right? Let us immediately jump into working with RSpec. We'll cover some of the philosophy and core RSpec concepts along the way.

Examples can be pending.

Spec::Expectations - Object#should(matcher) and Object#should_not(matcher) Spec::Matchers - you can write your own Predicates: be_nil, be_empty, be_valid, be_instance_of etc. raise_error lambda { ... }.should change(Article, :count).from(3).to(5) team.should have(11).players, have_at_least, have_at_most, include(joe)

Installing RSpec

If your Environment path is set to " ...\Ruby\bin" then open command prompt and run gem install rspec.

Usage

Initial spec

You start by describing what your application, method or class should behave like. Let us create our first specification file:

require "calculator"
 describe "TheCalculator's", "basic calculating" do # The describe() method returns an ExampleGroup class (~ar to TestCase in Test::Unit)
  it "should add two numbers correctly" do Green
  it "should subtract two numbers correctly" do
  it "should multiply two numbers correctly" do
  it "should divide two numbers correctly" do
  #...
end

What do we have here? First, at line 2 we defined a context for our test, using RSpec's describe block. Furthermore we have four behaviors/expectations (it "should ..." -blocks), defining what we expect our system to behave like.

There are contexts (describe) with examples, before and after blocks. Specs are made up of contexts that contain expectations in the form of examples.

We can run this specification using the spec command:

$ spec unit_test.rb

produces:

****

Pending:

TheCalculator's basic calculating should add two numbers correctly (Not Yet Impl
emented)
./21file.rb:5

TheCalculator's basic calculating should subtract two numbers correctly (Not Yet
 Implemented)
./21file.rb:7

TheCalculator's basic calculating should multiply two numbers correctly (Not Yet
 Implemented)
./21file.rb:9

TheCalculator's basic calculating should divide two numbers correctly (Not Yet I
mplemented)
./21file.rb:11

Finished in 0.021001 seconds

4 examples, 0 failures, 4 pending

Establishing behavior

Isn't it cool? Executing the tests echoes our expectations back at us, telling us that each has yet to be implemented. This is forcing/establishing behavior. We know that all calculator's must perform the above functions. We don't know how we're going to design this yet, but the tests will derive our design.

Writing the application code

At the very end, you write the application code, and fire up the tests to check, if it behaves the way you wanted while writing the tests… but we're getting ahead of ourself.

Developing the code

Let's go a step further and associate code blocks with our expectations.

require "calculator"

 describe "TheCalculator's", "basic calculating" do
  before(:each) do
    @cal = Calculator.new(6,2)
  end

  it "should add two numbers correctly" do
    @cal.addition.should == 8
  end

  it "should subtract two numbers correctly" do
    @cal.subtraction.should == 4
  end

  it "should multiply two numbers correctly" do
    @cal.multiplication.should == 11
  end

  it "should divide two numbers correctly" do
    @cal.division.should == 3
  end

end

Note that creating a Calculator object for each of our expectations will create duplication in the specification. This can be fixed using a before stanza in the specification. It allows us to run code before expectations are executed.

Let us run it:

produces:

Spec::Expectations::ExpectationNotMetError:
expected: 11,
     got: 12 (using ==)
./unit_test.rb:17

Uh-oh! The third expectation did not meet. See how the error message uses the fact that the expectation knows both the expected and actual values.

In eclipse RSpec will generate a nice description text for you when an expectation is not met.

Cucumber

Features of Cucumber

Its a Behavior Driven Development(BDD) tool for Ruby.
It focuses on story styling plain English Text.
It follows GWT(Given,When,Then) pattern

Installing Cucumber

If your Environment path is set to " ...\Ruby\bin" then open command prompt and run gem install cucumber.

Usage

Let us first create a feature file to describe about our requirements

Feature: Addition
  In order perform addition of two numbers
  As a user
  I want the sum of two numbers

  
Scenario: Add two numbers
   Given I have entered <input1>
   And   I have entered <input2>
   When  I give add
   Then  The result should be <output>

Then we will create a ruby file to give a code implementation

require 'calculator'

Before do
 @input1=3
 @input2=4
end

Given /^I have entered <input(\d+)>$/ do |arg1|
   @calc = Calculator.new(@input1,@input2)
end

When /^I give add$/ do
  @result = @calc.addition
end

Then /^The result should be <output>$/ do
 puts @result
end

Now if we run the feature file we will get the following

Feature: Addition
  In order perform addition of two numbers
  As a user
  I want the sum of two numbers

  Scenario: Add two numbers            # calculator.feature:7
    Given I have entered <input1>      # addition.rb:8
    And I have entered <input2>        # addition.rb:8
    When I give add                    # addition.rb:12
7
    Then The result should be <output> # addition.rb:16

1 scenario (1 passed)
4 steps (4 passed)
0m0.010s

Comparison of Test::Unit, Shoulda, RSpec

Test::Unit	Shoulda	RSpec
Test::Unit is a testing framework provided by Ruby.It is based on Test Driven Development.	Shoulda is an extension to Test::Unit. It is basically Test::Unit with more capabilities and simpler readable syntax.	RSpec is a Behavior Driven Development framework provided by Ruby. Its an evolution from TDD and Domain Driven Design.
Test::Unit provides assertions,test methods like setup,teardown,test fixtures,test runners and test suites	Shoulda provide macros,helpers like context and should,matchers	RSpec provides a Domain Specific Language to express the behavior of code.Basically RSpec is TDD embraced with documentation.
Test::Unit does not allow nested setup and nested teardown though multiple setup methods and teardown methods are provided in Test::Unit 2.0	Shoulda allows nested contexts which helps to create different environment for different set of tests.	RSpec allows nested describe structure.
		Specifications are more documenting and communicate better than tests.

Conclusion

We like RSpec best since we enjoy its readability most. We love the pending keyword, which allows us to set up the tests to be written later on. I find it helps focus on exactly one test and one failure. Shoulda would be our second choice because the tests are just as readable as RSpec, even if the output takes some learning to read.

Comparison of run times

The following are the run times for these three frameworks testing the same calculator class with 4 succesful tests -

RSpec

Finished in 0.023002 seconds

4 examples, 0 failures

Shoulda

Finished in 0.002 seconds.

4 tests, 4 assertions, 0 failures, 0 errors

Test::unit

Finished in 0.001 seconds.

4 tests, 4 assertions, 0 failures, 0 errors

External Links

RSpec
RSpec Documentation

CSC/ECE 517 Fall 2010/ch1 1f TU

Contents

Unit-testing frameworks for Ruby

Unit Testing

Benefits

Unit-testing frameworks

List of most popular unit testing frameworks for Ruby

Test::Unit

Features of Test::Unit

Installing Test::Unit

Usage

Example of a test class

Shoulda

Features of Shoulda

Installing Shoulda

Usage

RSpec

Features of RSpec

Installing RSpec

Usage

Initial spec

Establishing behavior

Writing the application code

Developing the code

Cucumber

Features of Cucumber

Installing Cucumber

Usage

Comparison of Test::Unit, Shoulda, RSpec

Conclusion

Comparison of run times

External Links

Navigation menu

CSC/ECE 517 Fall 2010/ch1 1f TU

Unit-testing frameworks for Ruby

Unit Testing

Benefits

Unit-testing frameworks

List of most popular unit testing frameworks for Ruby

Test::Unit

Features of Test::Unit

Installing Test::Unit

Usage

Example of a test class

Shoulda

Features of Shoulda

Installing Shoulda

Usage

RSpec

Features of RSpec

Installing RSpec

Usage

Initial spec

Establishing behavior

Writing the application code

Developing the code

Cucumber

Features of Cucumber

Installing Cucumber

Usage

Comparison of Test::Unit, Shoulda, RSpec

Conclusion

Comparison of run times

External Links

Navigation menu

Search