In /ruby you have a lot of flexibility in writing code, this includes possibility to not initialize an object.
I use this for testing my initializers, here are some examples how to do it.

Lets start with ruby class:

class TestMe
  attr_reader :value
  def initialize(value = nil)
    @value = value
  end
end

It’s a simple example where only initialize can set a value, usually you use more advanced code, but this is just a minimal example.

Now lets test it:

describe TestMe do
  subject do
    TestMe.allocate
  end

  it "has default value" do
    subject.send :initialize
    subject.value.must_equal nil
  end

  it "sets value" do
    subject.send :initialize, 3
    subject.value.must_equal 3
  end

end

For more real live examples of allocate check

• https://github.com/remote-exec/ruby-hooks/blob/master/test/ruby/hooks/hook_test.rb
• https://github.com/mpapis/contributors_stats/blob/master/test/contributors_stats/formatter_test.rb
• https://github.com/rvm/pluginator/blob/master/test/pluginator/autodetect_test.rb
• https://github.com/lsegal/yard/blob/master/spec/server/router_spec.rb

TF – Testing Framework

For some time I have been testing shell scripts using my own creation TF – Testing Framework.

I’m proud to present release 0.4.0 of it today. It includes:

• 2-4x speed improvement depending on used Ruby interpreter,
• add support for different shells via shebang
• improved validation of environment variables, including array variables testing and testing environment variable type,
• extended output matching allowing to separately match stdout and stderr,

Installation

Install using (ruby required):

gem install tf

Supported tests

The test can be negated by replacing = with !=:

• #status=<number> – check if command returned given status (0 is success)
• #match=/<regexp>/ – regexp match command output both stdout and stderr
• #match[stdout|stderr]=/<regexp>/ – regexp match command either stdout or stderr
• #env[<var_name>]=~/<regexp>/ – regexp match the given environment variable name
• #env[<var_name>]?=[array|string|nil] – verify type of the given environment variable name
• #env[<var_name><var_name>][]=<size> – verify size of the given environment variable name
• #env[<var_name>][]=/<regexp>/ – regexp match all of elements of the given environment variable name
• #env[<var_name>][<index>]=/<regexp>/ – regexp match given element of the given environment variable name

And here is very simple test:

true # status=0

false # status!=0

echo "Super" # match=~/^Super$/

rvm install 1.9.3 # match[stderr]!=/Error/; status=0

rvm alias create default 1.9.3 # status=0

TF is used for testing RVM, SM Framework and rubygems-bundler. Let me know if any other awesome projects use TF!

TF was earlier known as DTF – Deryl’s Testing Framework, but as original author Deryl wanted to go in a bit different direction (more validation related), I had to move code to this new repository and name.

This article is indirect translation of Cucumber – obsluga kilku sesji – polish version (from andrzejsliwa.com devblog).

Most of standard testing related tasks can be achieved in a simple way using the default steps from Cucumber. By assumption Cucumber is for functional testing, but it can also be used to implement integration test. This is especially useful when we want test interaction between users, when they should get on-line notifications – and this should be tested without login/logout functionality, like in shout box which was popular some time ago.

When using integration tests you could use block open_session:

def login(user)
  open_session do |sess|
    sess.extend(CustomDsl)
    u = users(user)
    sess.https!
    sess.post "/login", :username => u.username, :password => u.password
    assert_equal '/welcome', path
    sess.https!(false)
  end
end

But in the case of cucumber which is based on the steps it was necessary to find a solution that is suited to the form in which scenarios are created.

So I have asked my friend Andrzej Sliwa to write an example code, this is the example:

module ActionController
  module Integration
    class Session
      def switch_session_by_name(name)
        if @sessions_by_name.nil? 
          @sessions_by_name = { :default => @response.session.clone }
        end
        @sessions_by_name[name.to_sym] ||= @sessions_by_name[:default].clone
        @response.session = @sessions_by_name[name.to_sym]
      end
    end
  end
end

Given /^session name is "([^\"]*)"$/ do |name|
  switch_session_by_name(name)
end 

Use of this mechanism is trivially easy to perform the following step:

Given session name is "guest no 1 session"

g

In this case, a named session is created which is not dependent on others (including the default). Access to default session is called by using the default name:

Given session name is "default"

You can always get back to named session using the same name as before, the state of it will be persisted for you.

More details on Integration tests: http://guides.rubyonrails.org/testing.html#integration-testing-examples