IronRuby 0.5 was released yesterday. You can download it on codeplex. This post will explain how you setup your ironruby environment to use it for testing existing CLR based assemblies.  We’ll touch installing gems using rake and most importantly writing a test for a CLR based class where we’ll mock out the dependencies.

The first thing you need to do is download IronRuby. After downloading you can extract it to a location on your hard drive. I extracted mine to C:\ironruby

Now we need to add the path to ir.exe to our PATH variable so we can use it from the command-line. And that is all there is to it to install ironruby on your machine. Now we need to get the necessary gems onto our system. We’ll need bacon and caricature.

Open a console and type the following:

igem list will show you a list of the gems you have installed on your system.

igem install will fetch and install a gem on your system. To install the gems we’re going to need we need to execute the command

igem install bacon caricature

That will result in the following output:

+ C:\tools
» cmd
Microsoft Windows [Version 6.1.7100]
Copyright (c) 2009 Microsoft Corporation.  All rights reserved.

C:\tools>where ir
C:\ironruby\bin\ir.exe

C:\tools>exit
+ C:\tools
» igem list

*** LOCAL GEMS ***

+ C:\tools
» igem install bacon caricature
Successfully installed bacon-1.1.0
Successfully installed caricature-0.6.0
3 gems installed
Installing ri documentation for bacon-1.1.0...
Installing ri documentation for caricature-0.6.0...
Installing RDoc documentation for bacon-1.1.0...
Installing RDoc documentation for caricature-0.6.0...

If you would try to execute ibacon at this point that would work. We’ll need to create 2 small files to get ibacon to work.  In the bin directory of ironruby I created 2 files one called ibacon and the other one is ibacon.bat

ibacon

#!C:/ironruby/bin/ir.exe
#
# This file was generated by RubyGems.
#
# The application 'bacon' is installed as part of a gem, and
# this file is here to facilitate running it.
#

require 'rubygems'

version = ">= 0"

if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
  version = $1
  ARGV.shift
end

gem 'bacon', version
load 'bacon'

ibacon.bat

@ECHO OFF

@"ir.exe" "%~dpn0" %*

At this point you’re ready to start writing specs with bacon and caricature. Let’s look at an example I wrote for the controller factory for ironruby mvc.

We’re going to test the following C# code.

public interface IWeapon{
    int Attack(IWarrior warrior);
    int Damage();
}

public interface IWarrior
{
    int Id { get; }
    string Name { get; set; }
    bool IsKilledBy(IWeapon weapon);
    int Attack(IWarrior target, IWeapon weapon);
    int SurviveAttackWith(IWeapon weapon);
}

public class Sword : IWeapon
{

    public int Attack(IWarrior warrior){
        return warrior.SurviveAttackWith(this);
    }

    public int Damage(){
        return 4;
    }
}

I generally create a bacon_helper.rb file where I group my requires and helper functions etc. In the case of this test I have the following in the bacon_helper.rb:

# add some search paths to ironruby
# this first one adds the path with the assemblies
# this enables us not to have to specify a path to the assemblies everywhere.
$: << File.dirname(__FILE__) + "/bin"
# adds the path to the caricature library.
$: << File.dirname(__FILE__) + "/../lib"

# load the caricature library
require "caricature"
require 'caricature/clr'

# load the bacon library
require 'bacon'

# Add the .NET framework
require 'mscorlib'

# load the assembly with the C# code
load_assembly 'ClrModels'

At this point we’re ready to start writing the test. create a file called sword_spec.rb and we’ll add the following content to the file.

require File.dirname(__FILE__) + "/bacon_helper.rb"

describe "ClrModels::Sword" do

  before do
    @warrior = Caricature::Isolation.for ClrModels::IWarrior
  end

  it "should call survive_attack on the mock" do
    @warrior.when_receiving(:survive_attack_with).return(5)

    sword = ClrModels::Sword.new
    sword.attack(@warrior).should.equal 5

    @warrior.did_receive?(:survive_attack_with).should.be.successful
  end

  it "should return different results when expectation is defined with arguments" do
    sword1 = ClrModels::Sword.new
    sword2 = ClrModels::Sword.new

    @warrior.when_receiving(:survive_attack_with).return(5)
    @warrior.when_receiving(:survive_attack_with).with(sword2).return(15)

    sword1.attack(@warrior).should.equal 5
    sword2.attack(@warrior).should.equal 15

    @warrior.did_receive?(:survive_attack_with).with(sword2).should.be.successful
  end

end

So now we’ve got 2 tests for our Sword class. The only thing that is left to do is to run the specs. You can do that by executing the ibacon command and passing it the file you want to test.

+ C:\dev\caricature
(master) » ibacon spec/sword_spec.rb
ClrModels::Sword
- should call survive_attack on the mock
- should return different results when expectation is defined with arguments

2 specifications (5 requirements), 0 failures, 0 errors

The last couple of days I’ve been getting Caricature to a more releasable state. The code got a thorough cleanup and refactor. Caricature now knows how to be a full mocking framework for Ruby classes and CLR classes that only interact with ruby objects. When I apply the 80/20 rule to caricature it’s definitely beta worthy.

I’m not a huge fan of the 80/20 rule unless all the features I want are in the 80 part. In that case for me it’s a 100 rule .

As for the latest changes:

Adding require ‘caricature’ only gives you ruby mocking. If you want to use it to mock CLR classes or interact with the CLR you’ll need to add an extra require statement: require ‘caricature/clr’. I’ve done it this way so that I can still add Java and MacRuby support later on.

By default caricature will always give you an instance of an isolation, but there are times that you’ll want to substitute the result of a class method invocation. So the API got expanded with 2 methods, when_class_receives and did_class_receive?  These methods enable you to setup substitutions for class method calls.

I’m still waiting for IronRuby 0.5 to be released to give you a blow-by-blow tutorial on how to setup your environment.

Basically you download the ironruby release from Codeplex

Then you make sure the path to ir.exe is in your PATH variable

After that you should be able to do igem list and get an empty result back.

now you need to install bacon you can do that by executing

igem install bacon

next you need the caricature gem

igem install caricature

You will also need rake to be installed to build the cs files included in the sources.

igem install rake

ok now you should be good to to

require 'rubygems'
require 'bacon'
require 'caricature'
require 'caricature/clr'

describe "when isolating Ruby classes with class members" do

  before do
    @dagger = Dagger.new
    @soldier = Caricature::Isolation.for(SoldierWithClassMembers)
  end

  it "should work without expectations" do
    result = @dagger.attack @soldier
    result.should.equal nil
    @soldier.did_receive?(:survive_attack_with).with(@dagger).should.be.successful
  end

  it "should work for expectations with an argument constraint" do
    @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
    @dagger.attack(@soldier).should.equal 5
    @soldier.did_receive?(:survive_attack_with).with(:any).should.be.successful
  end

end

you can get the gem from rubyforge 

Or from my github account: http://github.com/casualjim/caricature

As you may or may not know I’m in the process of building IronRubyMvc. At one point I did write a bunch of tests in for the code I had at that point. However that test code was written in C# with xunit and moq.  I wasn’t too happy about that so I deferred writing tests to a later date when I could use a Ruby library to write them.

That time has come, I can use bacon and it’s acceptable performance wise now, not stellar but workable. So when I started to port some of my previously written tests to bacon I ran into a road block. Mocking isn’t as straightforward as my optimistic self was expecting. This lead me to think about what exactly does a mocking framework do?

I’m pretty much a just stuff no fluff kind of guy when it comes to coding. So I tend to choose for solutions that have just the right amount of features and virtually no whistles and bells. I generally blame it on being slightly stupid so I can’t grok intensely complex solutions. Once you cross a treshold there  is no way in hell I will ever look at it again.

Anyway the no fluff approach to mocking would be to look at the core responsibilities of those frameworks, which are 2 as far as I can tell.

1. Generate a proxy for an object so you can intercept method calls
2. Allow for verificatons of those intercepted method calls to do things like how many times was this method called, was it called at all etc.

So I’m starting to implement a way to generate proxies today.. This should be a piece of cake with Ruby Then I’ll look at implementing some constraints and verifications.

Thinking about how to approach the API for defining the mocks has also been an interesting experience. From the get-go a Record/Replay/Verify model is out. But then it comes to the following part, when do you define the verifications.

Do you do that in the assertion fase, thus stubbing everything beforehand and just allowing the user to define return values when establishing the test context. Or do you define the verification (at least twice, ignore arguments etc) when you establish the test context.   My vote goes to the first option.

So a new project is born it’s called caricature and lives on github.  Which will try to implement the ideas set forward in this blog post for IronRuby.

http://github.com/casualjim/caricature