README

Path: README
Last Update: 2010-02-13 21:24:50 +0100

expectations

expectations is a lightweight unit testing framework. Tests (expectations) can be written as follows

  expect 2 do
    1 + 1
  end

  expect(1 + 1) == 2

  expect NoMethodError do
    Object.invalid_method_call
  end.

expectations is designed to encourage unit testing best practices such as

  - discourage setting more than one expectation at a time
  - promote maintainability by not providing a setup or teardown method
  - provide one syntax for setting up state based or behavior based expectation
  - focus on readability by providing no mechanism for describing an expectation other than the code in the expectation.

Works with ruby1.9.1, patches for 1.8 are welcome.

Mocking is done utilizing Mocha

by Jay Fields maintained by Holger Kohnen

Download and Installation

You can download expectations from here or install it with the following command.

 $ gem install expectations

License

You may use, copy and redistribute this library under the same terms as Ruby itself (see www.ruby-lang.org/en/LICENSE.txt).

TextMate

The following code can be used as a new command in TextMate for running an individual expectation.

  export LINE="$TM_LINE_NUMBER"
  export RUBYLIB="$TM_BUNDLE_SUPPORT/RubyMate${RUBYLIB:+:$RUBYLIB}"
  "${TM_RUBY:-ruby}" -- "$TM_BUNDLE_SUPPORT/RubyMate/run_script.rb"

Usage

expectations can be used for state based and behavior based testing.

        require File.dirname(__FILE__) + "/test_helper"

        Expectations do

          # State based expectation where a value equals another value
          expect 2 do
            1 + 1
          end

          # State based expectation where an exception is expected. Simply expect the Class of the intended exception
          expect NoMethodError do
            Object.no_method
          end

          # Behavior based test using a traditional mock
          expect mock.to.receive(:dial).with("2125551212").times(2) do |phone|
            phone.dial("2125551212")
            phone.dial("2125551212")
          end

          # Behavior based test using a stub
          expect stub.to.receive(:dial).with("2125551212").times(2) do |phone|
            phone.dial("2125551212")
            phone.dial("2125551212")
          end

          # Behavior based test using a stub_everything
          expect stub_everything.to.receive(:dial).with("2125551212").times(2) do |phone|
            phone.dial("2125551212")
            phone.dial("2125551212")
          end

          # Behavior based test on a concrete mock
          expect Object.to.receive(:deal) do
            Object.deal
          end

          # State based test utilizing a stub
          expect 2 do
            stub(:two => 2).two
          end

          # State based test matching a Regexp
          expect /a string/ do
            "a string"
          end

          # State based test checking if actual is in the expected Range
          expect 1..5 do
            3
          end

          # State based test to determine if the object is an instance of the module
          expect Enumerable do
            []
          end

          # State based test to determine if the object is an instance of the class
          expect String do
            "a string"
          end

          # State based test to determine if the modules are the same
          expect Enumerable do
            Enumerable
          end

          # State based test to determine if the classes are the same
          expect String do
            String
          end

          # State based test with XML strings, whitespace between tags is ignored
          expect xml("<a><foo>bar</foo></a>") do
            "<a>\n\t<foo>bar</foo>  \n</a>"
          end

          # State based test with XML strings, whitespace between tags is ignored
          expect xml(<<-eos) do
            <one>
            <two>
            <three>4</three>
            <five> 6 </five>
            </two>
            </one>
            eos
            "<one><two><three>4</three>
            <five> 6 </five>
            </two></one>"
          end

          # this is normally defined in the file specific to the class
          klass = Class.new do
            def save(arg)
              record.save(arg)
            end
          end
          # State based delegation test
          expect klass.new.to.delegate(:save).to(:record) do |instance|
            instance.save(1)
          end

          # this is normally defined in the file specific to the class
          klass = Class.new do
            attr_accessor :started
          end
          # State based fluent interface boolean test using to be
          expect klass.new.to.be.started do |process|
            process.started = true
          end

          # this is normally defined in the file specific to the class
          klass = Class.new do
            attr_accessor :finished
          end
          # State based fluent interface boolean test using to have
          expect klass.new.to.have.finished do |process|
            process.finished = true
          end

          expect Expectations::Results::Fulfilled do
            suite = Expectations::Suite.new
            suite.expect(NoMethodError) { Object.no_method }
            suite.execute(Silent).expectations.first
          end

          expect nil.to.be.nil?
          expect Object.not.to.be.nil?

          # Shorthand style expectations
          expect(1 + 1) == 2
          expect(1 + 2) != 2
          expect(1) < 2
          expect(2) > 1
          expect('foo bar') =~ /foo/

        end

Contributors

Matt Mower, Ola Bini, George Malamidis, Brian Guthrie, Philippe Hanrigou, Steve McLarnon, Rubikitch, Subhash Gupta, Holger Kohnen

[Validate]