test-spec 0.2

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+setup.rb
+lib/test-spec.rb
+lib/test-spec/version.rb
+lib/test-spec/test/spec.rb
+lib/test-spec/test/spec/dox.rb
+lib/test-spec/test/spec/rdox.rb
+lib/test-spec/test/spec/should-output.rb

data/README.txt

@@ -0,0 +1,206 @@
+= test/spec, a BDD interface for Test::Unit
+
+Copyright (C) 2006  Christian Neukirchen <mailto:chneukirchen@gmail.com>
+
+
+== What is test/spec?
+
+test/spec layers an RSpec-inspired interface on top of Test::Unit, so
+you can mix TDD and BDD (Behavior-Driven Development).
+
+test/spec is a clean-room implementation that maps most kinds of
+Test::Unit assertions to a `should'-like syntax.
+
+Consider this Test::Unit test case:
+
+    class TestFoo < Test::Unit::TestCase
+      def test_should_bar
+        assert_equal 5, 2 + 3
+      end
+    end
+    
+In test/spec, it looks like this:
+    
+    require 'test/spec'
+    
+    context "Foo" do
+      specify "should bar" do
+        (2 + 3).should.equal 5
+      end
+    end
+
+test/spec does not include a mocking/stubbing-framework; use whichever
+you like to.  test/spec has been tested successfully with FlexMock and
+Mocha.
+
+test/spec has no dependencies outside Ruby 1.8.
+
+
+== Mixing test/spec and test/unit
+
+test/spec and Test::Unit contexts/test cases can be intermixed freely,
+run in the same test and live in the same files.  You can just add them
+to your Rake::TestTask, too.  test/spec allows you to leverage your
+full existing Test::Unit infrastructure.
+
+test/spec does not change Test::Unit with the exception of
+monkey-patching Test::Unit::TestSuite to order the test cases before
+running them.  (This should not do any harm, but if you know a way
+around it, please tell me.)
+
+test/spec adds two global methods, Object#should and Kernel.context.
+
+You can use <tt>assert_*</tt> freely in specify-blocks; Object#should
+works in plain Test::Unit test cases, too, but they will not be counted.
+
+
+== Wrapped assertions
+
++assert_equal+:: <tt>should.equal</tt>, <tt>should ==</tt>
++assert_not_equal+:: <tt>should.not.equal</tt>, <tt>should.not ==</tt>
++assert_same+:: <tt>should.be</tt>
++assert_not_same+:: <tt>should.not.be</tt>
++assert_nil+:: <tt>should.be.nil</tt>
++assert_not_nil+:: <tt>should.not.be.nil</tt>
++assert_in_delta+:: <tt>should.be.close</tt>
++assert_match+:: <tt>should.match</tt>, <tt>should =~</tt>
++assert_no_match+:: <tt>should.not.match</tt>, <tt>should.not =~</tt>
+
++assert_instance_of+:: <tt>should.be.an.instance_of</tt>
++assert_kind_of+:: <tt>should.be.a.kind_of</tt>
++assert_respond_to+:: <tt>should.respond_to</tt>
++assert_raise+:: <tt>should.raise</tt>
++assert_nothing_raised+:: <tt>should.not.raise</tt>
++assert_throws+:: <tt>should.throw</tt>
++assert_nothing_thrown+:: <tt>should.not.throw</tt>
+
++assert_block+:: <tt>should.satisfy</tt>
+
+(+a+, +an+ and +be+ without arguments are optional and no-ops.)
+
+
+== Additional assertions
+
+These assertions are not included in Test::Unit, but have been added
+to test/spec for convenience:
+
+* <tt>should.not.satisfy</tt>
+* <tt>should.include</tt>
+* <tt>a.should.</tt>_predicate_ (works like <tt>assert
+  a.</tt>_predicate_<tt>?</tt>)
+* <tt>a.should.be </tt>_operator_ (where _operator_ is one of <tt>></tt>, <tt>>=</tt>, <tt><</tt>, <tt><=</tt> or <tt>===</tt>)
+* <tt>should.output</tt> (require test/spec/should-output)
+
+If you write an useful general-purpose assertion, I'd like to hear of
+it and may add it to the test/spec distribution.
+
+
+== SpecDox and RDox
+
+test/spec adds two additional test runners to Test::Unit, based on the
+console runner but with a different output format.
+
+SpecDox, run with <tt>--runner=specdox</tt> (or <tt>-rs</tt>) looks
+like RSpec's output:
+
+    should.output
+    - works for print
+    - works for puts
+    - works with readline
+
+RDox, run with <tt>--runner=rdox</tt> (or <tt>-rr</tt>) can be
+included for RDoc documentation (e.g. see SPECS):
+
+    == should.output
+    * works for print
+    * works for puts
+    * works with readline
+
+SpecDox and RDox work for Test::Unit too:
+
+    $ ruby -r test/spec test/testunit/test_testresult.rb -rs
+    
+    Test::Unit::TC_TestResult
+    - fault notification
+    - passed?
+    - result changed notification
+    
+    Finished in 0.106647 seconds.
+    
+    3 specifications (30 requirements), 0 failures
+
+
+== specrb
+
+Since version 0.2, test/spec features a standalone test runner called
+specrb.  specrb is like an extended version of testrb, Test::Unit's
+test runner, but has additional options.  It can be used for
+plain Test::Unit suites, too.
+
+    $ specrb -a -s -n should.output
+    
+    should.output
+    - works for print
+    - works for puts
+    - works with readline
+    
+    Finished in 0.162571 seconds.
+    
+    3 specifications (6 requirements), 0 failures
+
+Run <tt>specrb --help</tt> for the usage.
+
+
+== History
+
+* September 29th, 2006: First public release 0.1.
+
+* October 18th, 2006: Second public release 0.2.
+  * Better, module-based implementation
+  * Official support for FlexMock and Mocha
+  * More robust Should#output
+  * Should#_operator_
+  * Nested contexts
+  * Standalone test/spec runner, specrb
+
+
+== Contact
+
+Please mail bugs, suggestions and patches to
+<mailto:chneukirchen@gmail.com>.
+
+Darcs repository ("darcs send" is welcome for patches):
+http://chneukirchen.org/repos/testspec
+
+
+== Thanks to
+
+* Eero Saynatkari for writing <tt>should.output</tt>.
+* Thomas Fuchs for script.aculo.us BDD testing which convinced me.
+* Dave Astels for BDD.
+* The RSpec team for API inspiration.
+* Nathaniel Talbott for Test::Unit.
+
+
+== Copying
+
+Copyright (C) 2006  Christian Neukirchen <http://purl.org/net/chneukirchen>
+
+test/spec is licensed under the same terms as Ruby itself.
+
+Please mail bugs, feature requests or patches to the mail addresses
+found above or use IRC[irc://freenode.net/#ruby-lang] to contact the
+developer.
+
+
+== Links
+
+Behavior-Driven Development:: <http://behaviour-driven.org/>
+RSpec:: <http://rspec.rubyforge.org/>
+script.aculo.us testing:: <http://mir.aculo.us/articles/2006/08/29/bdd-style-javascript-testing>
+
+FlexMock:: <http://onestepback.org/software/flexmock/>
+Mocha:: <http://mocha.rubyforge.org/>
+
+Christian Neukirchen:: <http://chneukirchen.org/>
+

data/Rakefile

@@ -0,0 +1,137 @@
+# Rakefile for testspec.  -*-ruby-*-
+# 
+# 
+# 
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'test-spec', 'version')
+
+AUTHOR = "Christian Neukirchen"  # can also be an array of Authors
+EMAIL = "chneukirchen@gmail.com"
+DESCRIPTION = "Behaviour Driven Development with Test::Unit"
+GEM_NAME = "test-spec" # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "test-spec" # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+RELEASE_TYPES = %w( gem ) # can use: gem, tar, zip
+
+
+NAME = "test-spec"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (TestSpec::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "test_spec documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/*_test.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  p.extra_deps = ['flexmock','>= 0.4.3'],['mocha','>= 0.3.2']
+  # == Optional
+  #p.changes        - A description of the release's latest changes.
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end
+
+
+desc "Run all the tests"
+task :default => [:test]
+
+desc "Do predistribution stuff"
+task :predist => [:chmod, :changelog, :rdoc]
+
+
+desc "Run all the tests"
+task :test => :chmod do
+  ruby "bin/specrb -Ilib:test -w #{ENV['TEST'] || '-a'} #{ENV['TESTOPTS']}"
+end
+
+desc "Make an archive as .tar.gz"
+task :dist => :test do
+  system "export DARCS_REPO=#{File.expand_path "."}; " +
+         "darcs dist -d testspec#{get_darcs_tree_version}"
+end
+
+desc "Make binaries executable"
+task :chmod do
+  Dir["bin/*"].each { |binary| File.chmod(0775, binary) }
+end
+
+desc "Generate a ChangeLog"
+task :changelog do
+  system "darcs changes --repo=#{ENV["DARCS_REPO"] || "."} >ChangeLog"
+end
+
+desc "Generate RDoc documentation"
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.rdoc_files.include 'README'
+  rdoc.rdoc_files.include 'ROADMAP'
+  rdoc.rdoc_files.include 'SPECS'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+task :rdoc => "SPECS"
+
+desc "Generate RDox"
+task "SPECS" do
+  ruby "bin/specrb -Ilib:test -a --rdox >SPECS"
+end
+
+begin
+  require 'rcov/rcovtask'
+  
+  Rcov::RcovTask.new do |t|
+    t.test_files = FileList['test/spec_*.rb'] + ['--', '-rs']   # evil
+    t.verbose = true     # uncomment to see the executed command
+    t.rcov_opts = ["--text-report", "--include-file", "^lib\\|^test"]
+  end
+rescue LoadError
+end
+
+
+# Helper to retrieve the "revision number" of the darcs tree.
+def get_darcs_tree_version
+  return ""  unless File.directory? "_darcs"
+
+  changes = `darcs changes`
+  count = 0
+  tag = "0.0"
+  
+  changes.each("\n\n") { |change|
+    head, title, desc = change.split("\n", 3)
+    
+    if title =~ /^  \*/
+      # Normal change.
+      count += 1
+    elsif title =~ /tagged (.*)/
+      # Tag.  We look for these.
+      tag = $1
+      break
+    else
+      warn "Unparsable change: #{change}"
+    end
+  }
+
+  "-" + tag + "." + count.to_s
+end
+
+          

data/lib/test-spec.rb

@@ -0,0 +1,2 @@
+Dir[File.join(File.dirname(__FILE__), 'test-spec/**/*.rb')].sort.each { |lib| require lib }
+require 'rubygems'

data/lib/test-spec/test/spec.rb

@@ -0,0 +1,368 @@
+#
+# test/spec -- a BDD interface for Test::Unit
+#
+# Copyright (C) 2006  Christian Neukirchen <mailto:chneukirchen@gmail.com>
+#
+# This work is licensed under the same terms as Ruby itself.
+#
+
+require 'test/unit'
+
+class Test::Unit::AutoRunner    # :nodoc:
+  RUNNERS[:specdox] = lambda {
+    require 'test/spec/dox'
+    Test::Unit::UI::SpecDox::TestRunner
+  }
+
+  RUNNERS[:rdox] = lambda {
+    require 'test/spec/rdox'
+    Test::Unit::UI::RDox::TestRunner
+  }
+end
+
+module Test                     # :nodoc:
+end
+
+module Test::Spec
+  VERSION = "0.1"
+  
+  CONTEXTS = {}
+
+  class DefinitionError < StandardError
+  end
+
+  class Should
+    include Test::Unit::Assertions
+
+    def initialize(object)
+      @object = object
+    end
+
+    $TEST_SPEC_TESTCASE = nil
+    def add_assertion
+      $TEST_SPEC_TESTCASE && $TEST_SPEC_TESTCASE.__send__(:add_assertion)
+    end
+
+
+    def an
+      self
+    end
+
+    def a
+      self
+    end
+
+    def not
+      ShouldNot.new(@object)
+    end
+
+
+    def satisfy(&block)
+      assert_block("satisfy block failed.") {
+        yield @object
+      }
+    end
+
+    def equal(value)
+      assert_equal value, @object
+    end
+    alias == equal
+
+    def close(value, delta)
+      assert_in_delta value, @object, delta
+    end
+    alias be_close close
+
+    def be(*value)
+      case value.size
+      when 0
+        self
+      when 1
+        assert_same value.first, @object
+      else
+        raise ArgumentError, "should.be needs zero or one argument"
+      end
+    end
+
+    def match(value)
+      assert_match value, @object
+    end
+    alias =~ match
+
+    def instance_of(klass)
+      assert_instance_of klass, @object
+    end
+    alias be_an_instance_of instance_of
+
+    def kind_of(klass)
+      assert_kind_of klass, @object
+    end
+    alias be_a_kind_of kind_of
+
+    def respond_to(method)
+      assert_respond_to @object, method
+    end
+
+    def _raise(*args)
+      args = [RuntimeError]  if args.empty?
+      assert_raise(*args, &@object)
+    end
+
+    def throw(*args)
+      assert_throws(*args, &@object)
+    end
+
+    def nil
+      assert_nil @object
+    end
+    alias be_nil nil
+
+
+    def include(value)
+      msg = build_message(nil, "<?> expected to include ?, but it didn't.",
+                          @object, value)
+      assert_block(msg) { @object.include?(value) }
+    end
+
+    def >(value)
+      assert_operator @object, :>, value
+    end
+
+    def >=(value)
+      assert_operator @object, :>=, value
+    end
+
+    def <(value)
+      assert_operator @object, :<, value
+    end
+
+    def <=(value)
+      assert_operator @object, :<=, value
+    end
+
+    def ===(value)
+      assert_operator @object, :===, value
+    end
+
+    def method_missing(name, *args)
+      # This will make raise call Kernel.raise, and self.raise call _raise.
+      return _raise(*args)  if name == :raise
+      
+      if @object.respond_to?("#{name}?")
+        assert @object.__send__("#{name}?", *args),
+               "#{name}? expected to be true."
+      else
+        super
+      end
+    end
+  end
+
+  class ShouldNot
+    include Test::Unit::Assertions
+
+    def initialize(object)
+      @object = object
+    end
+    
+    def equal(value)
+      assert_not_equal value, @object
+    end
+    alias == equal
+
+    def be(*value)
+      case value.size
+      when 0
+        self
+      when 1
+        assert_not_same value.first, @object
+      else
+        Kernel.raise ArgumentError, "should.be needs zero or one argument"
+      end
+    end
+
+    def match(value)
+      # Icky Regexp check
+      assert_no_match value, @object
+    end
+    alias =~ match
+
+    def _raise(*args)
+      assert_nothing_raised(*args, &@object)
+    end
+
+    def throw
+      assert_nothing_thrown(&@object)
+    end
+
+    def nil
+      assert_not_nil @object
+    end
+    alias be_nil nil 
+
+
+    def not
+      Should.new(@object)
+    end
+
+
+    def method_missing(name, *args)
+      # This will make raise call Kernel.raise, and self.raise call _raise.
+      return _raise(*args)  if name == :raise
+
+      if @object.respond_to?("#{name}?")
+        assert_block("#{name}? expected to be false.") {
+          not @object.__send__("#{name}?", *args)
+        }
+      else
+        super
+      end
+    end
+
+  end
+end
+
+class Test::Spec::TestCase
+  attr_reader :testcase
+  attr_reader :name
+  attr_reader :position
+
+  module InstanceMethods
+    def setup                 # :nodoc:
+      $TEST_SPEC_TESTCASE = self
+      super
+      self.class.setups.each { |s| instance_eval(&s) }
+    end
+    
+    def teardown              # :nodoc:
+      super
+      self.class.teardowns.each { |t| instance_eval(&t) }
+    end
+
+    def initialize(name)
+      super name
+
+      # Don't let the default_test clutter up the results and don't
+      # flunk if no tests given, either.
+      throw :invalid_test  if name == :default_test
+    end
+
+    def position
+      self.class.position
+    end
+
+    def context(*args)
+      raise Test::Spec::DefinitionError,
+        "context definition is not allowed inside a specify-block"
+    end
+  end
+
+  module ClassMethods
+    attr_accessor :count
+    attr_accessor :name
+    attr_accessor :position
+    attr_accessor :parent
+
+    attr_accessor :setups
+    attr_accessor :teardowns
+
+    def context(name, &block)
+      (Test::Spec::CONTEXTS[self.name + "\t" + name] ||=
+       Test::Spec::TestCase.new(name, self)).add(&block)
+    end
+    
+    def specify(specname, &block)
+      raise ArgumentError, "specify needs a block"  if block.nil?
+      
+      self.count += 1                 # Let them run in order of definition
+      
+      # TODO Changed by Jean-Michel
+      # define_method("test_%03d: %s" % [count, specname], &block)
+      define_method("test_spec {%s} %03d [%s]" % [name, count, specname], &block)
+    end
+    
+    def setup(&block)
+      setups << block
+    end
+    
+    def teardown(&block)
+      teardowns << block
+    end
+
+    def init(name, position, parent)
+      self.position = position
+      self.parent = parent
+      
+      if parent
+        self.name = parent.name + "\t" + name
+      else
+        self.name = name
+      end
+
+      self.count = 0
+      self.setups = []
+      self.teardowns = []
+    end
+  end
+
+  @@POSITION = 0
+
+  def initialize(name, parent=nil)
+    @testcase = Class.new(Test::Unit::TestCase) {
+      include InstanceMethods
+      extend ClassMethods
+    }
+
+    @@POSITION = @@POSITION + 1
+    @testcase.init(name, @@POSITION, parent)
+  end
+
+  def add(&block)
+    raise ArgumentError, "context needs a block"  if block.nil?
+
+    @testcase.class_eval(&block)
+    self
+  end
+end
+
+
+# Monkey-patch test/unit to run tests in an optionally specified order.
+module Test::Unit               # :nodoc:
+  class TestSuite               # :nodoc:
+    undef run
+    def run(result, &progress_block)
+      sort!
+      yield(STARTED, name)
+      @tests.each do |test|
+        test.run(result, &progress_block)
+      end
+      yield(FINISHED, name)
+    end
+    
+    def sort!
+      @tests = @tests.sort_by { |test|
+        test.respond_to?(:position) ? test.position : 0
+      }
+    end
+    
+    def position
+      @tests.first.respond_to?(:position) ? @tests.first.position : 0
+    end
+  end
+end
+
+
+# Global helpers
+
+class Object
+  def should
+    Test::Spec::Should.new(self)
+  end
+end
+
+module Kernel
+  def context(name, &block)
+    (Test::Spec::CONTEXTS[name] ||= Test::Spec::TestCase.new(name)).add(&block)
+  end
+
+  private :context
+end