Skip to content
This repository


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP

a BDD testing framework for ruby that's mad at the world and plans to kick it's ass in 78 freakin lines of code

branch: master

Fetching latest commit…


Cannot retrieve the latest commit at this time

Octocat-spinner-32 lib
Octocat-spinner-32 samples
Octocat-spinner-32 README
Octocat-spinner-32 README.tmpl
Octocat-spinner-32 TODO
Octocat-spinner-32 gemspec.rb
Octocat-spinner-32 gen_readme.rb
Octocat-spinner-32 testy-0.5.0.gem

  a minimalist BDD testing framework for ruby that's mad at the world and
  plans to kick its ass by ruthlessly removing lines of testing framework

  Testy.testing 'your code' do
    test 'some behaviour' do |t|
      ultimate =
      t.check :name, :expect => 42, :actual => ultimate.answer

  git clone git://


  . testing should not require learning a framework.  ruby is a great
  framework so testy uses it instead, requiring programmers learn exactly 2
  new method calls

  . testing loc should not dwarf those of the application

  . testing framework loc should not dwarf those of the application

  . testing frameworks should *never* alter ruby built-ins nor add methods to
  Object, Kernel, .et al

  . the output of tests should be machine parsable for reporting and ci tools
  to easily integrate with

  . the output of tests should be beautiful so that humans can read it

  . the shape of the test file should not insult the programmer so that tests
  can double as sample code

  . the testing framework should never alter exception semantics

  . hi-jacking at_exit sucks ass

  . the exit status of running a test suite should indicate the degree of its
  failure state (testy returns the percent of failed tests using a non-zero
  exit status)

  . sample code should easily be able to double as a test suite, including
  its output

  . testing should improve your code and help your users, not make you want to
  kill yourself

  . using a format that aligns in terminal is sanity saving when comparing

  . testing frameworks should provide as few shortcuts for making brittle
  tightly coupled tests as possible

  . test suites should be able to be created, manipulated, have their output
  streamed to different ports, and even tested themselves - they should be
  plain ol objects under the hood

  <========< samples/a.rb >========>

  ~ > cat samples/a.rb

    # simple use of testy involves simply writing code, and recording the result
    # you expect against the actual result
    # notice that the output is very pretty and that the exitstatus is 0 when all
    # tests pass
      require 'testy'
      Testy.testing 'the kick-ass-ed-ness of testy' do
        test 'the ultimate answer to life' do |result|
          list = []
          list << 42
          result.check :a, :expect => 42, :actual => list.first
          list << 42.0
          result.check :b, 42.0, list.last

  ~ > ruby samples/a.rb #=> exitstatus=0

    the kick-ass-ed-ness of testy: 
      the ultimate answer to life: 
          a: 42
          b: 42.0

  <========< samples/b.rb >========>

  ~ > cat samples/b.rb

    # testy will handle unexpected results and exceptions thrown in your code in
    # exactly the same way - by reporting on them in a beautiful fashion and
    # continuing to run other tests.  notice, however, that an unexpected result
    # or raised exception will cause a non-zero exitstatus (the percent of tests
    # that failed) for the suite as a whole.  also note that previously
    # accumulated expect/actual pairs are still reported on in the error report.
      require 'testy'
      Testy.testing 'the exception handling of testy' do
        test 'raising an exception' do |result|
          list = []
          list << 42
          result.check :a, :expect => 42, :actual => list.first
        test 'returning unexpected results' do |result|
          result.check 'a', 42, 42
          result.check :b, :expect => 'forty-two', :actual => 42.0

  ~ > ruby samples/b.rb #=> exitstatus=100

    the exception handling of testy: 
      raising an exception: 
            class: NoMethodError
            message: undefined method `method_that_does_not_exist' for [42]:Array
            - samples/b.rb:18:in `call'
            - ./lib/testy.rb:130:in `run'
            - ./lib/testy.rb:113:in `instance_eval'
            - ./lib/testy.rb:113:in `run'
            - /opt/local/lib/ruby/site_ruby/1.8/orderedhash.rb:65:in `each'
            - /opt/local/lib/ruby/site_ruby/1.8/orderedhash.rb:65:in `each'
            - ./lib/testy.rb:108:in `run'
            - ./lib/testy.rb:78:in `call'
            - ./lib/testy.rb:78:in `context'
            - ./lib/testy.rb:102:in `run'
            - ./lib/testy.rb:167:in `testing'
            - samples/b.rb:10
            a: 42
            a: 42
      returning unexpected results: 
            a: 42
            b: forty-two
            a: 42
            b: 42.0

  <========< samples/c.rb >========>

  ~ > cat samples/c.rb

    # in some cases you may not even want to make test assertions and simply
    # provide example code which should run without error, with testy it's not
    # only easy to do this but the commanline supports --list to see which samples
    # can be run and running a single or multiple tests based on name or pattern.
    # notice that, when no assertions are made using 'result.check' the output of
    # the test becomes the expected *and* actual and is therefore shown in the
    # output as yaml.  of course, if your samples have errors they are reported in
    # the normal fashion and the tests will fail.
      require 'testy'
      Testy.testing 'some samplz for you' do
        test 'foo sample' do
          list = 1,2
          list.last + list.first
        test 'bar sample' do
          list = 1,2
          list.shift * list.pop
        test 'foobar sample' do
          list = 1,2
          eval(list.reverse.join) * 2
    # here are some examples of using the command line arguments on the above test
    # cfp:~/src/git/testy > ruby samples/c.rb --list
    # --- 
    # - foo sample
    # - bar sample
    # - foobar sample
    # cfp:~/src/git/testy > ruby samples/c.rb foobar
    # --- 
    # some samplz for you: 
    #   foobar sample: 
    #     success: 42
    # cfp:~/src/git/testy > ruby samples/c.rb foo
    # --- 
    # some samplz for you: 
    #   foo sample: 
    #     success: 3
    #   foobar sample: 
    #     success: 42
    # cfp:~/src/git/testy > ruby samples/c.rb bar
    # --- 
    # some samplz for you: 
    #   bar sample: 
    #     success: 2

  ~ > ruby samples/c.rb #=> exitstatus=0

    some samplz for you: 
      foo sample: 
        success: 3
      bar sample: 
        success: 2
      foobar sample: 
        success: 42

  <========< samples/d.rb >========>

  ~ > cat samples/d.rb

    # of course testy includes smartly inherited contexts and context sensitive
    # setup and teardown methods which stack as well.
      require 'testy'
      Testy.testing 'your bitchin lib' do
        context 'A' do
          setup{ @list = [40] }
          test 'foo' do
            @list << 2
            @list.first + @list.last
          test 'bar' do |t|
            t.check :list, @list, [40]
          context 'B' do
            setup{ @list << 2 }
            test(:bar){ @list.join.delete('0') }
    # the context name is applied to the test name, so you can selectively run
    # groups of tests from the command line
    # cfp:~/src/git/testy > ruby -I lib samples/d.rb 'A - B'
    # --- 
    # your bitchin lib: 
    #   A - B - bar: 
    #       success: "42"

  ~ > ruby samples/d.rb #=> exitstatus=0

    your bitchin lib: 
      A - foo: 
        success: 42
      A - bar: 
          - 40
      A - B - bar: 
        success: "42"
Something went wrong with that request. Please try again.