nullstyle-test-spec 0.4.1

data/lib/test/spec/dox.rb

@@ -0,0 +1,148 @@
+require 'test/unit/ui/console/testrunner'
+
+module Test::Unit::UI           # :nodoc:
+  module SpecDox                # :nodoc:
+    class TestRunner < Test::Unit::UI::Console::TestRunner
+      protected
+      def setup_mediator
+        @mediator = create_mediator(@suite)
+      end
+
+      def add_fault(fault)
+        if fault.kind_of? Test::Spec::Disabled
+          @disabled += 1
+          output_no_nl " (disabled)"
+        elsif fault.kind_of? Test::Spec::Empty
+          @empty += 1
+          output_no_nl " (empty)"
+        else
+          @faults << fault
+          word = fault.class.name[/(.*::)?(.*)/, 2].upcase
+          output_no_nl " (#{word} - #{@faults.size})"
+        end
+      end
+      
+      def started(result)
+        @result = result
+        @context = nil
+        @contexts = []
+        @disabled = 0
+        @empty = 0
+        indent 0
+      end
+      
+      def finished(elapsed_time)
+        nl
+        output "Finished in #{elapsed_time} seconds."
+        @faults.each_with_index do |fault, index|
+          nl
+          output("%3d) %s" % [index + 1, fault.long_display])
+        end
+        nl
+        output_result
+      end
+
+      def output_result
+        if @disabled > 0
+          disabled = ", #{@disabled} disabled"
+        else
+          disabled = ""
+        end
+
+        if @empty > 0
+          empty = ", #{@empty} empty"
+        else
+          empty = ""
+        end
+
+        r = ("%d specifications#{disabled}#{empty} " +
+             "(%d requirements), %d failures") % [
+               @result.run_count, @result.assertion_count, @result.failure_count]
+        r << ", #{@result.error_count} errors"  if @result.error_count > 0
+        output r
+      end
+      
+      def test_started(name)
+        return  if special_test? name
+
+        contextname, @specname = unmangle name
+        return  if contextname.nil? || @specname.nil?
+
+        if @context != contextname
+          @context = contextname
+
+          @old_contexts = @contexts
+          @contexts = @context.split("\t")
+
+          common = 0
+          @contexts.zip(@old_contexts) { |a, b|
+            break  if a != b
+            common += 1
+          }
+
+          nl  if common == 0
+
+          @contexts[common..-1].each_with_index { |head, i|
+            indent common + i
+            output_heading head
+          }
+        end
+        
+        @assertions = @result.assertion_count
+        @prevdisabled = @disabled
+        output_item @specname
+      end
+      
+      def test_finished(name)
+        return  if special_test? name
+
+        # Did any assertion run?
+        if @assertions == @result.assertion_count && @prevdisabled == @disabled
+          add_fault Test::Spec::Empty.new(@specname)
+        end
+
+        # Don't let empty contexts clutter up the output.
+        nl  unless name =~ /\Adefault_test\(/
+      end
+
+      def output_no_nl(something, level=NORMAL)
+        @io.write(something) if (output?(level))
+        @io.flush
+      end
+
+      def output_item(item)
+        output_no_nl "#{@prefix}- #{item}"
+      end
+
+      def output_heading(heading)
+        output "#{@prefix}#{heading}"
+      end
+
+      def unmangle(name)
+        if name =~ /\Atest_spec \{(.*?)\} \d+ \[(.*)\]/
+          contextname = $1
+          specname = $2
+        elsif name =~ /test_(.*?)\((.*)\)$/
+          specname = $1
+          contextname = $2
+
+          contextname.gsub!(/^Test\B|\BTest$/, '')
+          specname.gsub!(/_/, ' ')
+        else
+          contextname = specname = nil
+        end
+
+        [contextname, specname]
+      end
+
+      def indent(depth)
+        @indent = depth
+        @prefix = "  " * depth
+      end
+
+      def special_test?(name)
+        name =~ /\Atest_spec \{.*?\} (-1 BEFORE|AFTER) ALL\(/
+      end
+    end
+  end
+end

data/lib/test/spec/rdox.rb

@@ -0,0 +1,25 @@
+require 'test/spec/dox'
+
+module Test::Unit::UI           # :nodoc:
+  module RDox                   # :nodoc:
+    class TestRunner < Test::Unit::UI::SpecDox::TestRunner
+      def output_heading(heading)
+        output "#{@headprefix} #{heading}"
+      end
+      
+      def output_item(item)
+        output_no_nl "* #{item}"
+      end
+      
+      def finished(elapsed_time)
+        nl
+        output_result
+      end
+
+      def indent(depth)
+        @prefix = ""
+        @headprefix = "==" + "=" * depth
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# Code adapted from rs, written by Eero Saynatkari.
+require 'fileutils'
+require 'tmpdir'
+
+class Test::Spec::Should
+  # Captures output from the IO given as
+  # the second argument (STDIN by default)
+  # and matches it against a String or 
+  # Regexp given as the first argument.
+  def output(expected, to = STDOUT)
+    # Store the old stream
+    old_to = to.dup
+
+    # Obtain a filehandle to replace (works with Readline)
+    to.reopen File.open(File.join(Dir.tmpdir, "should_output_#{$$}"), "w+")
+    
+    # Execute
+    @object.call
+
+    # Restore
+    out = to.dup
+    to.reopen old_to
+
+    # Grab the data
+    out.rewind
+    output = out.read
+
+    # Match up
+    case expected
+      when Regexp
+        output.should.match expected
+      else
+        output.should.equal expected
+    end                               # case expected
+
+  # Clean up
+  ensure
+    out.close
+
+    # STDIO redirection will break else
+    begin
+      to.seek 0, IO::SEEK_END
+    rescue Errno::ESPIPE
+    rescue Errno::EPIPE
+    end
+
+    FileUtils.rm_f out.path
+  end                                 # output
+end                                   # Test::Spec::Should

data/lib/test/spec/version.rb

@@ -0,0 +1,8 @@
+# To load it externally, without activating Test::Unit.
+
+module Test
+  module Spec
+    VERSION = "0.4"
+  end
+end
+

data/test-spec.gemspec

@@ -0,0 +1,55 @@
+Gem::Specification.new do |s|
+  s.name = "test-spec"
+  s.version = "0.4.1"
+  s.date = "2008-04-30"
+  s.summary = "a Behaviour Driven Development interface for Test::Unit"
+  s.email = "chneukirchen@gmail.com"
+  s.homepage = "http://test-spec.rubyforge.org"
+  
+  s.description = <<EOF
+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.
+EOF
+
+  s.has_rdoc = true
+  s.authors = ["Christian Neukirchen"]
+  
+  s.files = [
+    "Manifest.txt", 
+    "README", 
+    "Rakefile", 
+    "test-spec.gemspec", 
+    "lib/test/spec.rb",
+    "lib/test/spec/dox.rb",
+    "lib/test/spec/rdox.rb",
+    "lib/test/spec/should-output.rb",
+    "lib/test/spec/version.rb",
+    "test/spec_dox.rb",
+    "test/spec_flexmock.rb",
+    "test/spec_mocha.rb",
+    "test/spec_nestedcontexts.rb",
+    "test/spec_new_style.rb",
+    "test/spec_should-output.rb",
+    "test/spec_testspec.rb",
+    "test/spec_testspec_order.rb",
+    "test/test_testunit.rb",
+  ]
+  
+  s.test_files = [
+    "test/spec_dox.rb",
+    "test/spec_flexmock.rb",
+    "test/spec_mocha.rb",
+    "test/spec_nestedcontexts.rb",
+    "test/spec_new_style.rb",
+    "test/spec_should-output.rb",
+    "test/spec_testspec.rb",
+    "test/spec_testspec_order.rb",
+    "test/test_testunit.rb",  
+  ]
+  
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["Manifest.txt", "README"]
+end

data/test/spec_dox.rb

@@ -0,0 +1,39 @@
+require 'test/spec'
+
+require 'test/spec/dox'
+
+context "SpecDox" do
+  setup do
+    r = Test::Unit::UI::SpecDox::TestRunner.new(nil)
+    @unmangler = r.method(:unmangle)
+  end
+  
+  specify "can unmangle Test::Unit names correctly" do
+    @unmangler["test_foo_bar(TestFoo)"].should.equal ["Foo", "foo bar"]
+    @unmangler["test_foo_bar(FooTest)"].should.equal ["Foo", "foo bar"]
+    @unmangler["test_he_he(Foo)"].should.equal ["Foo", "he he"]
+    @unmangler["test_heh(Foo)"].should.equal ["Foo", "heh"]
+
+    @unmangler["test_heh(Test::Unit::TC_Assertions)"].
+      should.equal ["Test::Unit::TC_Assertions", "heh"]
+
+    @unmangler["test_heh(Foo::Bar::Test)"].
+      should.equal ["Foo::Bar::Test", "heh"]
+  end
+
+  specify "can unmangle Test::Spec names correctly" do
+    @unmangler["test_spec {context} 007 [whee]()"].
+      should.equal ["context", "whee"]
+    @unmangler["test_spec {a bit longish context} 069 [and more text]()"].
+      should.equal ["a bit longish context", "and more text"]
+    @unmangler["test_spec {special chars !\"/&%$} 2 [special chars !\"/&%$]()"].
+      should.equal ["special chars !\"/&%$", "special chars !\"/&%$"]
+    @unmangler["test_spec {[]} 666666 [{}]()"].
+      should.equal ["[]", "{}"]
+  end
+
+  specify "has sensible fallbacks" do
+    @unmangler["weird"].should.equal [nil, nil]
+  end
+end
+  

data/test/spec_flexmock.rb

@@ -0,0 +1,214 @@
+# Adapted from flexmock (http://onestepback.org/software/flexmock).
+#
+# Copyright 2006 by Jim Weirich (jweirich@one.net).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+
+
+require 'test/spec'
+
+begin
+  require 'flexmock'
+rescue LoadError
+  context "flexmock" do
+    specify "can not be found.  BAIL OUT!" do
+    end
+  end
+else
+
+context "flexmock" do
+  include FlexMock::TestCase
+    
+  setup do
+    @mock = FlexMock.new
+  end
+
+  specify "should handle" do
+    args = nil
+    @mock.mock_handle(:hi) { |a, b| args = [a,b] }
+    @mock.hi(1,2)
+    args.should.equal [1,2]
+  end
+
+  specify "should handle without a block" do
+    lambda {
+      @mock.mock_handle(:blip)
+      @mock.blip
+    }.should.not.raise
+  end
+
+  specify "should handle with a block" do
+    called = false
+    @mock.mock_handle(:blip) { |block| block.call }
+    @mock.blip { called = true }
+    called.should.be true
+  end
+
+  specify "should have a return value" do
+    @mock.mock_handle(:blip) { 10 }
+    @mock.blip.should.equal 10
+  end
+
+  specify "should handle missing methods" do
+    ex = lambda {
+      @mock.not_defined
+    }.should.raise(NoMethodError)
+    ex.message.should.match(/not_defined/)
+  end
+
+  specify "should ignore missing methods" do
+    lambda {
+      @mock.mock_ignore_missing
+      @mock.blip
+    }.should.not.raise
+  end
+
+  specify "should count correctly" do
+    @mock.mock_handle(:blip, 3)
+    @mock.blip
+    @mock.blip
+    @mock.blip
+    lambda { @mock.mock_verify }.should.not.raise Test::Unit::AssertionFailedError
+  end
+
+  specify "should raise on bad counts" do
+    @mock.mock_handle(:blip, 3)
+    @mock.blip
+    @mock.blip
+    lambda { @mock.mock_verify }.should.raise Test::Unit::AssertionFailedError
+  end
+
+  specify "should handle undetermined counts" do
+    lambda {
+      FlexMock.use('fs') { |m|
+        m.mock_handle(:blip)
+        m.blip
+        m.blip
+        m.blip
+      }
+    }.should.not.raise Test::Unit::AssertionFailedError
+  end
+
+  specify "should handle zero counts" do
+    lambda {
+      FlexMock.use { |m|
+        m.mock_handle(:blip, 0)
+        m.blip
+      }
+    }.should.raise Test::Unit::AssertionFailedError
+  end
+
+  specify "should have file IO with use" do
+    file = FlexMock.use do |m|
+      filedata = ["line 1", "line 2"]
+      m.mock_handle(:gets, 3) { filedata.shift }
+      count_lines(m).should.equal 2
+    end
+  end
+
+  def count_lines(stream)
+    result = 0
+    while line = stream.gets
+      result += 1
+    end
+    result    
+  end
+
+  specify "should have use" do
+    lambda {
+      FlexMock.use do |m|
+	m.mock_handle(:blip, 2)
+	m.blip
+      end
+    }.should.raise Test::Unit::AssertionFailedError
+  end
+
+  specify "should handle failures during use" do
+    ex = lambda {
+      FlexMock.use do |m|
+	m.mock_handle(:blip, 2)
+	xyz
+      end
+    }.should.raise NameError
+    ex.message.should.match(/undefined local variable or method/)
+  end
+
+  specify "should deal with sequential values" do
+    values = [1,4,9,16]
+    @mock.mock_handle(:get) { values.shift }
+    @mock.get.should.equal 1
+    @mock.get.should.equal 4
+    @mock.get.should.equal 9
+    @mock.get.should.equal 16
+  end
+  
+  specify "respond_to? should return false for non handled methods" do
+    @mock.should.not.respond_to :blah
+  end
+
+  specify "respond_to? should return true for explicit methods" do
+    @mock.mock_handle(:xyz)
+    @mock.should.respond_to :xyz
+  end
+
+  specify "respond_to? should return true when ignoring_missing" do
+    @mock.mock_ignore_missing
+    @mock.should.respond_to :yada
+  end
+  
+  specify "respond_to? should return true for missing_methods when should_ignore_missing" do
+    @mock.should_ignore_missing
+    @mock.should.respond_to :yada
+  end
+
+  specify "should raise error on unknown method proc" do
+    lambda {
+      @mock.method(:xyzzy)
+    }.should.raise NameError
+  end
+
+  specify "should return callable proc on method" do
+    got_it = false
+    @mock.mock_handle(:xyzzy) { got_it = true }
+    method_proc = @mock.method(:xyzzy)
+    method_proc.should.not.be.nil
+    method_proc.call
+    got_it.should.be true
+  end
+
+  specify "should return do nothing proc for missing methods" do
+    @mock.mock_ignore_missing
+    method_proc = @mock.method(:plugh)
+    method_proc.should.not.be.nil
+    lambda { method_proc.call }.should.not.raise
+  end
+end
+
+
+class TemperatureSampler
+  def initialize(sensor)
+    @sensor = sensor
+  end
+
+  def average_temp
+    total = (0...3).collect { @sensor.read_temperature }.inject { |i, s| i + s }
+    total / 3.0
+  end
+end
+
+context "flexmock" do
+  include FlexMock::TestCase
+
+  specify "works with test/spec" do
+    sensor = flexmock("temp")
+    sensor.should_receive(:read_temperature).times(3).and_return(10, 12, 14)
+
+    sampler = TemperatureSampler.new(sensor)
+    sampler.average_temp.should.equal 12
+  end
+end
+
+end                             # if not rescue LoadError