rspec 0.6.4 → 0.7.0

data/test/spec/runner/spec_matcher_test.rb

@@ -1,47 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-module Spec
-  module Runner
-    class SpecMatcherTest < Test::Unit::TestCase
-      
-      def test_should_match_context_and_spec
-        matcher = SpecMatcher.new("a context with a spec", "a context")
-        assert matcher.matches?("with a spec")
-      end
-
-      def test_should_match_with_regexp_reserved_characters
-        matcher = SpecMatcher.new("a context with #[] a spec", "a context")
-        assert matcher.matches?("with #[] a spec")
-      end
-      
-      def test_should_not_match_wrong_context
-        matcher = SpecMatcher.new("another context with a spec", "a context")
-        assert !matcher.matches?("with a spec")
-      end
-     
-      def test_should_not_match_wrong_spec
-        matcher = SpecMatcher.new("a context with another spec", "a context")
-        assert !matcher.matches?("with a spec")
-      end
-      
-      def test_should_match_context_only
-        matcher = SpecMatcher.new("a context", "a context")
-        assert matcher.matches?("with a spec")
-      end
-      
-      def test_should_not_match_wrong_context_only
-        matcher = SpecMatcher.new("another context", "a context")
-        assert !matcher.matches?("with a spec")
-      end
-      
-      def test_should_match_spec_only
-        matcher = SpecMatcher.new("with a spec", "a context")
-        assert matcher.matches?("with a spec")
-      end
-      
-      def test_should_match_wrong_spec_only
-        matcher = SpecMatcher.new("with another spec", "a context")
-        assert !matcher.matches?("with a spec")
-      end
-    end
-  end
-end

data/test/spec/runner/specification_test.rb

@@ -1,121 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-module Spec
-  module Runner
-    class SpecificationTest < Test::Unit::TestCase
-      
-      def setup
-        @reporter = Spec::Mocks::Mock.new "reporter"
-      end
-
-      def test_should_run_spec_in_scope_of_execution_context
-        spec = Specification.new("should pass") do
-          self.should_not_be_an_instance_of Specification
-          self.should_be_an_instance_of ExecutionContext
-        end
-        @reporter.should_receive(:spec_started).with "should pass"
-        @reporter.should_receive(:spec_finished).with "should pass", nil, nil
-        spec.run @reporter
-      end
-
-      def test_should_add_itself_to_reporter_when_passes
-        spec = Specification.new("spec") {}
-        @reporter.should_receive(:spec_started).with "spec"
-        @reporter.should_receive(:spec_finished).with "spec", nil, nil
-        spec.run(@reporter)
-      end
-
-      def test_should_add_itself_to_reporter_when_fails
-        error = RuntimeError.new
-        spec = Specification.new("spec") { raise error }
-        @reporter.should_receive(:spec_started).with "spec"
-        @reporter.should_receive(:spec_finished).with "spec", error, "spec"
-        spec.run(@reporter)
-      end
-      
-      def test_should_add_itself_to_reporter_when_calling_run_dry
-        spec = Specification.new("spec") {}
-        @reporter.should_receive(:spec_started).with "spec"
-        @reporter.should_receive(:spec_finished).with "spec"
-        spec.run(@reporter, nil, nil, true)
-      end
-
-      def test_should_verify_mocks_after_teardown
-        spec = Specification.new("spec") do
-          mock = mock("a mock")
-          mock.should_receive(:poke)
-        end
-        @reporter.should_receive(:spec_started).with "spec"
-        @reporter.should_receive(:spec_finished) do |spec_name, error|
-          spec_name.should_equal "spec"
-          error.message.should_match(/expected 'poke' once, but received it 0 times/)
-        end
-        spec.run @reporter
-      end
-
-      def test_should_run_teardown_even_when_main_block_fails
-        spec = Specification.new("spec") do
-          raise "in body"
-        end
-        teardown = lambda do
-          raise "in teardown"
-        end
-        @reporter.should_receive(:spec_started).with "spec"
-        @reporter.should_receive(:spec_finished) do |spec, error, location|
-          spec.should_equal "spec"
-          location.should_equal "spec" 
-          error.message.should_equal "in body"
-        end
-        spec.run @reporter, nil, teardown
-      end
-      
-      def test_should_supply_setup_as_spec_name_if_failure_in_setup
-        spec = Specification.new("spec") do
-        end
-        setup = lambda do
-          raise "in setup"
-        end
-        @reporter.should_receive(:spec_started).with "spec"
-        @reporter.should_receive(:spec_finished) do |name, error, location|
-          name.should_equal "spec"
-          error.message.should_equal "in setup"
-          location.should_equal "setup"
-        end
-        spec.run @reporter, setup
-      end
-      
-      def test_should_supply_teardown_as_failure_location_if_failure_in_teardown
-        spec = Specification.new("spec") do
-        end
-        teardown = lambda do
-          raise "in teardown"
-        end
-        @reporter.should_receive(:spec_started).with "spec"
-        @reporter.should_receive(:spec_finished) do |name, error, location|
-          name.should_equal "spec"
-          error.message.should_equal "in teardown"
-          location.should_equal "teardown"
-        end
-        spec.run @reporter, nil, teardown
-      end
-      
-      def test_should_match_if_name_matches_end_of_input
-        spec = Specification.new("spec")
-        assert spec.matches_matcher?(SpecMatcher.new("context spec", "context"))
-      end
-      
-      def test_should_match_if_name_matches_entire_input
-        spec = Specification.new("spec")
-        assert spec.matches_matcher?(SpecMatcher.new("spec", "context"))
-      end
-      
-      def test_should_not_match_if_name_does_not_match
-        spec = Specification.new("otherspec")
-        assert !spec.matches_matcher?(SpecMatcher.new("context spec", "context"))
-      end
-      
-      def teardown
-        @reporter.__verify
-      end
-    end
-  end
-end

data/test/spec/test_to_spec/ruby_to_ruby_test.rb

@@ -1,79 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-require 'spec/test_to_spec/ruby2ruby'
-
-R2r2r = RubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRubyToRuby")
-eval R2r2r
-
-class RubyToRubyToRuby
-  class<<self
-    eval RubyToRuby.translate(class<<RubyToRuby;self;end, :translate)
-  end
-  eval RubyToRuby.translate(RubyToRuby, :initialize)
-end
-
-class R2RTest < Test::Unit::TestCase
-
-  def test_self_translation
-    r2r2r2 = RubyToRubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRubyToRuby")
-    r2r2r2r = RubyToRubyToRuby.translate(RubyToRubyToRuby)
-    # File.open('1','w'){|f| f.write r2r2r}
-    # File.open('2','w'){|f| f.write r2r2r2}
-    # File.open('3','w'){|f| f.write r2r2r2r}
-    assert_equal(R2r2r,r2r2r2)
-    assert_equal(R2r2r,r2r2r2r)
-  end
-  
-  def hairy_method(z,x=10,y=20*z.abs,&blok)
-    n = 1 + 2 * 40.0 / (z - 2)
-    retried = false
-    begin
-      raise ArgumentError, n if retried
-      n -= yield x,y,z,[z,x,y].map(&blok)
-      n /= 1.1 until n < 500
-      n = "hop hop #{"%.4f" % n}"
-      raise n
-    rescue RuntimeError => e
-      raise if n != e.message
-      n = lambda{|i| 
-        lambda{|j| "#{i} #{z+2*2} #{j.message.reverse}"
-        }
-      }[n].call(e)
-      unless retried
-        retried = true
-        retry
-      end
-    rescue ArgumentError => e
-      e.message  
-    rescue
-    end
-  ensure
-    x << "ensure a-working"
-  end
-  
-  def foobar a, &block; block.call(a) end
-  def k; foobar [1,2,3].each { |x| x*2 } do |x| x*2 end end
-
-  def test_block_predecence_escape
-    eval RubyToRuby.translate(self.class, :k).sub(" k"," l")
-    assert_equal(k, l)
-  end
-       
-  def test_hairy_method
-    eval RubyToRuby.translate(self.class, :hairy_method).sub(" h", " f")
-    
-    blk = lambda{|x,y,z,arr| 
-      unless y
-        x.to_i*2
-      else
-        x.to_i*y*z*arr.inject(1){|s,i| s+i}
-      end
-    }
-    x1 = ""
-    x2 = ""
-    res = [hairy_method(-5,x1,&blk), fairy_method(-5,x2,&blk)]
-    assert_equal(res.first, res.last)
-    assert_equal(x1, x2)
-    assert_equal("ensure a-working", x1)
-  end
-  
-end

data/test/spec/test_to_spec/sexp_transformer_assertion_test.rb

@@ -1,207 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-require 'test/unit'
-require 'rubygems'
-require 'parse_tree'
-require 'spec/test_to_spec/sexp_transformer'
-
-module Spec
-  module TestToSpec
-    # This Test::Unit class verifies that the core Test::Unit assertions
-    # can be translated to RSpec.
-    # The various test_assert_* methods must follow a rigorous form - 
-    #
-    # The first statement must be a Test::Unit assertion, and the second
-    # statement its expected RSpec translation.
-    #
-    # For each of the test_assert_* method, a test_assert_*_translation
-    # method is dynamically added, which will test that the translation
-    # of the 1st statement is effectively equal to the second one.
-    class SexpTransformerAssertionTest < Test::Unit::TestCase
-      def setup
-        @t = SexpTransformer.new
-      end
-      
-      def test_assert
-        assert(:foo == :foo)
-        (:foo == :foo).should_be true
-      end
-
-      def test_assert_with_message
-        assert(:foo == :foo, "msg")
-        (:foo == :foo).should_be true
-      end
-
-      def test_assert_nil
-        assert_nil([].index(5))
-        ([].index(5)).should_be nil
-      end
-
-      def test_assert_nil_with_message
-        assert_nil([].index(5), "msg")
-        ([].index(5)).should_be nil
-      end
-
-      def test_assert_not_nil
-        assert_not_nil([5].index(5))
-        ([5].index(5)).should_not_be nil
-      end
-
-      def test_assert_not_nil_with_message
-        assert_not_nil(3, "msg")
-        3.should_not_be nil
-      end
-
-      def test_assert_equal
-        assert_equal(2, 1+1)
-        (1+1).should_equal 2
-      end
-
-      def test_assert_equal_with_message
-        assert_equal(2, 1+1, "1+1 should equal 2")
-        (1+1).should_equal 2
-      end
-
-      def test_assert_equal_with_each
-        [0,1,2].each_with_index do |b, c|
-          assert_equal c, b
-        end
-        [0,1,2].each_with_index do |b, c|
-          b.should_equal c
-        end
-      end
-
-      def test_assert_not_equal
-        assert_not_equal(2+3, 1)
-        1.should_not_equal 2+3
-      end
-
-      def test_assert_not_equal_with_message
-        assert_not_equal(2+3, 1, "msg")
-        1.should_not_equal 2+3
-      end
-
-      def test_assert_same
-        assert_same(2, 1+1)
-        (1+1).should_be 2
-      end
-
-      def test_assert_same_with_msg
-        assert_same(2, 1+1, "msg")
-        (1+1).should_be 2
-      end
-
-      def test_assert_not_same
-        assert_not_same(2+3, 1)
-        1.should_not_be 2+3
-      end
-
-      def test_assert_not_same_with_message
-        assert_not_same(2+3, 1, "msg")
-        1.should_not_be 2+3
-      end
-
-      def test_assert_instance_of
-        assert_instance_of Fixnum, 2
-        2.should_be_instance_of Fixnum
-      end
-
-      def test_assert_kind_of
-        assert_kind_of Fixnum, 2
-        2.should_be_kind_of Fixnum
-      end
-
-      def test_assert_match
-        assert_match(/foo/, 'foo')
-        'foo'.should_match(/foo/)
-      end
-
-      def test_assert_no_match
-        assert_no_match(/foo/, 'bar')
-        'bar'.should_not_match(/foo/)
-      end
-
-      def test_assert_respond_to
-        assert_respond_to 2, :to_f
-        2.should_respond_to :to_f
-      end
-      
-      def test_assert_respond_to_with_message
-        assert_respond_to 2, :to_f, "msg"
-        2.should_respond_to :to_f
-      end
-      
-      def test_assert_in_delta
-        assert_in_delta 123.5, 123.45, 0.1
-        123.45.should_be_close 123.5, 0.1
-      end
-
-      def test_assert_in_delta_with_message
-        assert_in_delta 123.5, 123.45, 0.1, "123.45 should be close to 123.5"
-        123.45.should_be_close 123.5, 0.1
-      end
-      
-      def test_assert_raise
-        assert_raise(ZeroDivisionError){ 1/0 }
-        lambda {1/0}.should_raise(ZeroDivisionError)
-      end
-      
-      def test_assert_raise_with_message
-        assert_raise(ZeroDivisionError, "msg"){ 1/0 }
-        lambda {1/0}.should_raise(ZeroDivisionError)
-      end
-      
-      def test_assert_raises
-        assert_raises(ZeroDivisionError){ 1/0 }
-        lambda {1/0}.should_raise(ZeroDivisionError)
-      end
-      
-      def test_assert_nothing_raised
-        assert_nothing_raised{ 0/1 }
-        lambda {0/1}.should_not_raise
-      end
-
-      def test_assert_throws
-        assert_throws(:foo){ throw :foo }
-        lambda {throw :foo}.should_throw(:foo)
-      end
-
-      def test_assert_nothing_thrown
-        assert_nothing_thrown{ 0/1 }
-        lambda {0/1}.should_not_throw
-      end
-      
-      def test_assert_block
-        assert_block{:foo != :bar}
-        lambda{:foo != :bar}.should_be true
-      end
-
-      # Returns the body of one of my methods as a Sexp
-      def self.body(sym)
-        t = ParseTree.new.parse_tree_for_method(self, sym)
-        t[2][1][2..-1]
-      end
-
-      # Verifies that the 1st statement in test method +m+ is properly translated
-      # to the 2nd statement.
-      def should_translate(m)
-        body = self.class.body(m)
-        assert_equal 2, body.length
-        test_unit_sexp = body[0]
-        rspec_sexp = body[1]
-        translation = @t.process(test_unit_sexp)
-        verify_sexp_equal(rspec_sexp, translation)
-      end
-      
-      # Dynamically define extra test methods
-      methods = self.instance_methods(false).reject do |m| 
-        m == "test_translations" || !(m =~ /^test_assert/)
-      end
-      methods.each do |m|
-        define_method "#{m}_translation" do
-          should_translate(m)
-        end
-      end
-
-    end
-  end
-end