test-spec 0.2 → 0.3.0

data/lib/{test-spec/test → test}/spec/dox.rb

@@ -6,22 +6,24 @@ module Test::Unit::UI           # :nodoc:
       protected
       def setup_mediator
         @mediator = create_mediator(@suite)
-        suite_name = @suite.to_s
-        if ( @suite.kind_of?(Module) )
-          suite_name = @suite.name
-        end
       end
 
       def add_fault(fault)
-        @faults << fault
-        word = fault.class.name[/(.*::)?(.*)/, 2].upcase
-        output_no_nl " (#{word} - #{@faults.size})"
+        if fault.kind_of? Test::Spec::Disabled
+          @disabled += 1
+          output_no_nl " (disabled)"
+        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
         indent 0
       end
       
@@ -37,7 +39,13 @@ module Test::Unit::UI           # :nodoc:
       end
 
       def output_result
-        r = "%d specifications (%d requirements), %d failures" % [
+        if @disabled > 0
+          disabled = ", #{@disabled} disabled"
+        else
+          disabled = ""
+        end
+
+        r = "%d specifications#{disabled} (%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

data/lib/{test-spec/test → test}/spec/rdox.rb

@@ -1,5 +1,4 @@
-# commented coz Dr Nic magic works quite well for require!
-# require 'test/spec/dox'
+require 'test/spec/dox'
 
 module Test::Unit::UI           # :nodoc:
   module RDox                   # :nodoc:

data/lib/{test-spec/test → test}/spec/should-output.rb

@@ -1,5 +1,6 @@
 # Code adapted from rs, written by Eero Saynatkari.
 require 'fileutils'
+require 'tmpdir'
 
 class Test::Spec::Should
   # Captures output from the IO given as
@@ -11,8 +12,8 @@ class Test::Spec::Should
     old_to = to.dup
 
     # Obtain a filehandle to replace (works with Readline)
-    to.reopen File.open("/tmp/should_output_#{$$}", "w+")
-
+    to.reopen File.open(File.join(Dir.tmpdir, "should_output_#{$$}"), "w+")
+    
     # Execute
     @object.call
 

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,210 @@
+# 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
+  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
+    @mock.mock_verify
+  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
+    FlexMock.use('fs') { |m|
+      m.mock_handle(:blip)
+      m.blip
+      m.blip
+      m.blip
+    }
+  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

data/test/spec_mocha.rb

@@ -0,0 +1,118 @@
+# Adapted from mocha (http://mocha.rubyforge.org/).
+#
+# Copyright (C) 2006 Revieworld Ltd.
+#
+# You may use, copy and redistribute this library under the same terms
+# as Ruby itself (see www.ruby-lang.org/en/LICENSE.txt) or under the
+# MIT license (see MIT-LICENSE file).
+
+require 'test/spec'
+
+$: << "/home/chris/src/mocha-0.3.2/lib"
+
+begin
+  require 'mocha'
+rescue LoadError
+  context "mocha" do
+    specify "can not be found.  BAIL OUT!" do
+    end
+  end
+else
+
+context "mocha" do
+  specify "works with test/spec" do
+    object = mock()
+    object.expects(:expected_method).with(:p1, :p2).returns(:result)
+    object.expected_method(:p1, :p2).should.equal :result
+  end
+end
+
+class Enterprise
+  def initialize(dilithium)
+    @dilithium = dilithium
+  end
+
+  def go(warp_factor)
+    warp_factor.times { @dilithium.nuke(:anti_matter) }
+  end
+end
+
+context "mocha" do
+  specify "works with test/spec and Enterprise example" do
+    dilithium = mock()
+    dilithium.expects(:nuke).with(:anti_matter).at_least_once  # auto-verified at end of test
+    enterprise = Enterprise.new(dilithium)
+    enterprise.go(2)
+  end
+end
+
+end                             # if not rescue LoadError
+
+
+begin
+  require 'stubba'
+rescue LoadError
+  context "stubba" do
+    specify "can not be found.  BAIL OUT!" do
+    end
+  end
+else
+
+class Order
+  attr_accessor :shipped_on
+
+  def total_cost
+    line_items.inject(0) { |total, line_item| total + line_item.price } + shipping_cost
+  end
+
+  def total_weight
+    line_items.inject(0) { |total, line_item| total + line_item.weight }
+  end
+
+  def shipping_cost
+    total_weight * 5 + 10
+  end
+
+  class << self
+
+    def find_all
+      # Database.connection.execute('select * from orders...
+    end
+
+    def number_shipped_since(date)
+      find_all.select { |order| order.shipped_on > date }.size
+    end
+
+    def unshipped_value
+      find_all.inject(0) { |total, order| order.shipped_on ? total : total + order.total_cost }
+    end
+
+  end
+
+end
+
+context "stubba" do
+  specify "works with test/spec and instance method stubbing" do
+    order = Order.new
+    order.stubs(:total_weight).returns(10)
+    order.shipping_cost.should.equal 60
+  end
+
+  specify "works with test/spec and class method stubbing" do
+    now = Time.now; week_in_secs = 7 * 24 * 60 * 60
+    order_1 = Order.new; order_1.shipped_on = now - 1 * week_in_secs
+    order_2 = Order.new; order_2.shipped_on = now - 3 * week_in_secs
+    Order.stubs(:find_all).returns([order_1, order_2])
+    Order.number_shipped_since(now - 2 * week_in_secs).should.equal 1
+  end
+
+  specify "works with test/spec and global instance method stubbing" do
+    Order.stubs(:find_all).returns([Order.new, Order.new, Order.new])
+    Order.any_instance.stubs(:shipped_on).returns(nil)
+    Order.any_instance.stubs(:total_cost).returns(10)
+    Order.unshipped_value.should.equal 30
+  end
+end
+
+end                             # if not rescue LoadError
+

data/test/spec_nestedcontexts.rb

@@ -0,0 +1,26 @@
+require 'test/spec'
+
+context "Empty context" do
+  # should.not.raise
+end
+
+context "Outer context" do
+  context "Inner context" do
+    specify "is nested" do
+    end
+    specify "has multiple empty specifications" do
+    end
+  end
+  context "Second Inner context" do
+    context "Inmost context" do
+      specify "works too!" do
+      end
+      specify "whoo!" do
+      end
+    end
+    specify "is indented properly" do
+    end
+    specify "still runs in order of definition" do
+    end
+  end
+end