relevance-test-spec 0.4.0.5

data/test/helper.rb

@@ -0,0 +1,5 @@
+$: << File.dirname(__FILE__) + '/../lib/'
+require 'rubygems'
+require 'mocha'
+require 'redgreen' unless ENV["RUN_CODE_RUN"] || Object.const_defined?("TextMate")
+require 'test/spec'

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

data/test/spec_focused.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[helper]))
+
+describe "focused methods" do
+  it "context methods are extended on to the test case" do
+    spec = Test::Spec::TestCase.new('stub')
+    spec.testcase.should.respond_to :fcontext
+    spec.testcase.should.respond_to :fdescribe
+  end
+  
+  it "spec methods are extended on to the test case" do
+    spec = Test::Spec::TestCase.new('stub')
+    spec.testcase.should.respond_to :fspecify
+    spec.testcase.should.respond_to :fit
+  end
+  
+end
+
+describe "turning on focused mode" do
+  teardown do
+    Test::Spec::CONTEXTS.map { |k, v| v.ignore = false }
+  end
+  
+  it "sets ignore on all previous contexts" do
+    Kernel.module_eval do
+      describe("first context") { it("should never run") { assert 1 == 2 } }
+      fcontext("second context") { it("focuses on this spec") { assert 1 == 1} }
+    end
+    
+    Test::Spec::CONTEXTS["first context"].ignore?.should == true
+    Test::Spec::CONTEXTS["second context"].ignore?.should == false
+  end
+  
+  it "sets ignore on all previous specs" do
+    Kernel.module_eval do
+      describe("first context") { it("should never run") { assert 1 == 2 } }
+      context("second context") { 
+        it("this should be undefed") { raise }
+        fit("focuses on this spec") { assert 1 == 1} }
+    end
+    Test::Spec::CONTEXTS["first context"].ignore?.should == true
+    Test::Spec::CONTEXTS["second context"].ignore?.should == false
+  end
+  
+  it "undefs previous spec methods when focusing on a spec" do
+    Kernel.module_eval do
+      context("my context") { 
+        it("this should be undefed") { raise }
+        fit("focuses on this spec") { assert 1 == 1} }
+    end
+    Test::Spec::CONTEXTS["my context"].testcase.instance_methods.grep(/test_spec/).size.should == 1
+  end
+  
+end
+
+describe "focused context/describe blocks" do
+  setup do
+    @spec = Test::Spec::TestCase.new('stub')
+  end
+
+  it "turns on focused mode for top level contexts" do
+    Test::Spec.expects(:set_focused_mode).with(true).once
+    Kernel.fcontext("stub context") { "foo" }
+  end
+
+  it "turns on focused mode for nested contexts" do
+    Test::Spec.expects(:set_focused_mode).with(true).once
+    @spec.testcase.fcontext("stub context") { "foo" }
+  end
+  
+  it "sets all previous contexts to disabled" do
+    Test::Spec.expects(:ignore_previous_specs)
+    @spec.testcase.fcontext("stub context") { "foo" }
+  end
+  
+end

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 'mocha'
+rescue LoadError
+  context "mocha" 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 "mocha" 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
+