A Unit Testing Framework In 44 Lines Of Ruby

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

describe "some test" do 
  it "should be true" do 
    true.should == true
  end

  it "should show that an expression can be true" do
    (5 == 5).should == true
  end

  it "should be failing deliberately" do
    5.should == 6
  end
end```

As you can see it looks very much like a basic Rspec test, let's try and write some code to run this.

## Building A Basic Framework

The first thing we're going to need is the ability to define a new test using "_describe_". Since we want to be able to put a “"_describe_"” block anywhere (_e.g. its own file_), we're going to have to augment Ruby a little bit. **The "_puts_" method lives in the Kernel module and is therefore available anywhere (_since the Object class includes Kernel and every object in Ruby inherits from Object_), we will put describe inside Kernel to give it the same ability**:

```ruby
module Kernel
  def describe(description, &block)
    tests = Dsl.new.parse(description, block)
    tests.execute
  end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Dsl 
  def initialize
    @tests = {}
  end
  def parse(description, block)
    self.instance_eval(&block)
    Executor.new(description, @tests)
  end
  def it(description, &block)
    @tests[description] = block
  end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

self.instance_eval(&block)```

Our **Dsl** object has an "_it_" method which also takes a description and a block and since that is exactly what our describe block contains everything works well (_i.e. we're essentially making several method calls to the "it" method each time passing in a description and a block_). **We could define other methods on our Dsl object and those would become part of the "_language_" which will be available to us in the "_describe_" block**.

Our "_it_" method will be called once for every "_it_" block in the describe block, every time that happens we simply take the block that was passed in and store it in hash keyed on the description. When we're done, we simply create a new **Executor** object which we will use to iterate over our test blocks, call them and produce some results. The executor looks like this:

```ruby
class Executor
  def initialize(description, tests)
    @description = description
    @tests = tests
    @success_count = 0
    @failure_count = 0
  end
  def execute
    puts "#{@description}"
    @tests.each_pair do |name, block|
      print " - #{name}"
      result = self.instance_eval(&block)
      result ? @success_count += 1 : @failure_count += 1
      puts result ? " SUCCESS" : " FAILURE"
    end
    summary
  end
  def summary
    puts "\n#{@tests.keys.size} tests, #{@success_count} success, #{@failure_count} failure"
  end
end```

Our executor code is reasonably simple. We print out the description of our "_describe_" block we then go through all the "_it_" blocks we have stored and evaluate them in the context of the executor object. In our case there is no special reason for this, but it does mean that the executor object can also be a container for some methods that can be used as a "_language_" inside "_it_" blocks (_i.e. part of our dsl can be defined as method on the executor_). For example, we could define the following method on our executor:

```ruby
def should_be_five(x) 
  5 == x
end```

This method would then be available for us to use inside our "_it_" blocks, but for our simple test it is not necessary.

So, we evaluate our "_it_" blocks and store the result, which is simply going to be the return value of the last statement in the "_it_" block (_as per regular Ruby_). **In our case we want to make sure that the last statement always returns a boolean value (_to indicate success or failure of the test_), we can then use it to produce some meaningful output**.

We are missing one piece though, the "_should_" method, we had code like:

```ruby
true.should == true
5.should == 5```

It seems that every object has the "_should_" method available to it and that's exactly how it works:

```ruby
class Object
  def should
    self
  end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

module Kernel
  def describe(description, &block)
    tests = Dsl.new.parse(description, block)
    tests.execute
  end
end 
class Object
  def should
    self
  end
end
class Dsl 
  def initialize
    @tests = {}
  end
  def parse(description, block)
    self.instance_eval(&block)
    Executor.new(description, @tests)
  end
  def it(description, &block)
    @tests[description] = block
  end
end
class Executor
  def initialize(description, tests)
    @description = description
    @tests = tests
    @success_count = 0
    @failure_count = 0
  end
  def execute
    puts "#{@description}"
    @tests.each_pair do |name, block|
      print " - #{name}"
      result = self.instance_eval(&block)
      result ? @success_count += 1 : @failure_count += 1
      puts result ? " SUCCESS" : " FAILURE"
    end
    summary
  end
  def summary
    puts "\n#{@tests.keys.size} tests, #{@success_count} success, #{@failure_count} failure"
  end
end