miniunit 1.1.0 → 1.2.0

metadata

@@ -1,66 +1,82 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: miniunit
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
-date: 2007-11-08 00:00:00 -08:00
-summary: miniunit is a completely minimial drop-in replacement for ruby's test/unit.
-require_paths: 
-- lib
-email: ryand-ruby@zenspider.com
-homepage: "    http://rubyforge.org/projects/bfts"
-rubyforge_project: bfts
-description: miniunit is a completely minimial drop-in replacement for ruby's test/unit. This is meant to be clean and easy to use both as a regular test writer and for language implementors that need a minimal set of methods to bootstrap a working unit test suite.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.2.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Ryan Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.3
+    version: 
+description: mini/test is a completely minimial drop-in replacement for ruby's test/unit. This is meant to be clean and easy to use both as a regular test writer and for language implementors that need a minimal set of methods to bootstrap a working unit test suite.  mini/spec is a functionally complete spec engine.  mini/mock, by Steven Baker, is a beautifully tiny mock object framework.
+email: 
+- ryand-ruby@zenspider.com
+executables: 
+- use_miniunit
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
 files: 
 - .autotest
 - History.txt
 - Manifest.txt
 - README.txt
 - Rakefile
+- bin/use_miniunit
+- lib/mini/mock.rb
+- lib/mini/spec.rb
+- lib/mini/test.rb
 - lib/test/unit.rb
+- lib/test/unit/assertions.rb
+- lib/test/unit/error.rb
 - lib/test/unit/testcase.rb
-- test/test_test_case.rb
-- test/test_test_unit.rb
-test_files: 
-- test/test_test_case.rb
-- test/test_test_unit.rb
+- test/test_mini_mock.rb
+- test/test_mini_spec.rb
+- test/test_mini_test.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/bfts
+post_install_message: 
 rdoc_options: 
 - --main
 - README.txt
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.3.0
-    version: 
+rubyforge_project: bfts
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: mini/test is a completely minimial drop-in replacement for ruby's test/unit
+test_files: 
+- test/test_mini_mock.rb
+- test/test_mini_spec.rb
+- test/test_mini_test.rb

data/test/test_test_case.rb

@@ -1,321 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-$TESTING_TEST_UNIT = true
-
-require 'test/unit'
-
-# TODO: add message versions
-class TestTestCase < MiniTest::Unit::TestCase
-  def setup
-    util_test_suites.clear
-    @tc = MiniTest::Unit::TestCase.new
-    @zomg = "zomg ponies!"
-    @assertion_count = 1
-  end
-
-  def teardown
-    assert_equal @assertion_count, @tc._assertions if @tc._assertions
-    Object.send :remove_const, :ATestCase if defined? ATestCase
-  end
-
-  def test_class_inherited
-    util_test_case
-    assert util_test_suites[ATestCase]
-  end
-
-  def test_class_test_suites
-    util_test_case
-    assert_equal 1, MiniTest::Unit::TestCase.test_suites.size
-    assert_equal [ATestCase], MiniTest::Unit::TestCase.test_suites
-  end
-
-  def test_assert
-    @tc.assert true
-    @tc.assert true, "message"
-    @assertion_count = 2
-  end
-
-  def test_assert_triggered
-    util_assert_triggered "failed assertion (no message given)" do
-      @tc.assert false
-    end
-  end
-
-  def test_assert_triggered_message
-    util_assert_triggered @zomg do
-      @tc.assert false, @zomg
-    end
-  end
-
-  def test_assert_block
-    @tc.assert_block do
-      true
-    end
-  end
-
-  def test_assert_block_triggered
-    util_assert_triggered 'assert_block failed.' do
-      @tc.assert_block do
-        false
-      end
-    end
-  end
-
-  def test_assert_equal
-    @tc.assert_equal 1, 1
-  end
-
-  def test_assert_equal_triggered
-    util_assert_triggered "<1> expected but was\n<2>." do
-      @tc.assert_equal 1, 2
-    end
-  end
-
-  def test_assert_in_delta
-    @tc.assert_in_delta 0.0, 1.0 / 1000, 0.1
-  end
-
-  def test_assert_in_delta_triggered
-    util_assert_triggered 'Expected 0.0 to be within 1.0e-06 of 0.001' do
-      @tc.assert_in_delta 0.0, 1.0 / 1000, 0.000001
-    end
-  end
-
-  def test_assert_instance_of
-    @tc.assert_instance_of String, "blah"
-  end
-
-  def test_assert_instance_of_triggered
-    util_assert_triggered 'Expected "blah" to be an instance of Array' do
-      @tc.assert_instance_of Array, "blah"
-    end
-  end
-
-  def test_assert_kind_of
-    @tc.assert_kind_of String, "blah"
-  end
-
-  def test_assert_kind_of_triggered
-    util_assert_triggered 'Expected "blah" to be a kind of Array' do
-      @tc.assert_kind_of Array, "blah"
-    end
-  end
-
-  def test_assert_match
-    @tc.assert_match "blah blah blah", /\w+/
-  end
-
-  def test_assert_match_triggered
-    util_assert_triggered 'Expected /\d+/ to match "blah blah blah"' do
-      @tc.assert_match "blah blah blah", /\d+/
-    end
-  end
-
-  def test_assert_nil
-    @tc.assert_nil nil
-  end
-
-  def test_assert_nil_triggered
-    util_assert_triggered 'Expected 42 to be nil' do
-      @tc.assert_nil 42
-    end
-  end
-
-  def test_assert_no_match
-    @tc.assert_no_match "blah blah blah", /\d+/
-  end
-
-  def test_assert_no_match_triggered
-    util_assert_triggered 'Expected /\w+/ to not match "blah blah blah"' do
-      @tc.assert_no_match "blah blah blah", /\w+/
-    end
-  end
-
-  def test_assert_not_equal
-    @tc.assert_not_equal "blah", "yay"
-  end
-
-  def test_assert_not_equal_triggered
-    util_assert_triggered 'Expected "blah" to not be equal to "blah"' do
-      @tc.assert_not_equal "blah", "blah"
-    end
-  end
-
-  def test_assert_not_nil
-    @tc.assert_not_nil 42
-  end
-
-  def test_assert_not_nil_triggered
-    util_assert_triggered 'Expected nil to not be nil' do
-      @tc.assert_not_nil nil
-    end
-  end
-
-  def test_assert_not_same
-    @tc.assert_not_same 1, 2
-  end
-
-  # TODO: "with id <id>" crap from assertions.rb
-  def test_assert_not_same_triggered
-    util_assert_triggered 'Expected 1 to not be the same as 1' do
-      @tc.assert_not_same 1, 1
-    end
-  end
-
-  def test_assert_nothing_raised
-    @tc.assert_nothing_raised do
-      # do nothing
-    end
-  end
-
-  def test_assert_nothing_raised_triggered
-    expected = 'Exception raised:
-Class: <RuntimeError>
-Message: <"oops!">
----Backtrace---'
-
-    util_assert_triggered expected do
-      @tc.assert_nothing_raised do
-        raise "oops!"
-      end
-    end
-  end
-
-  def test_assert_operator
-    @tc.assert_operator 2, :>, 1
-  end
-
-  def test_assert_operator_triggered
-    util_assert_triggered "<2> expected to be\n:<\n<1>." do
-      @tc.assert_operator 2, :<, 1
-    end
-  end
-
-  def test_assert_raises
-    @tc.assert_raises RuntimeError do
-      raise "blah"
-    end
-  end
-
-  def test_assert_raises_triggered_none
-    e = @tc.assert_raises MiniTest::Assertion do
-      # do nothing
-    end
-
-    expected = "<MiniTest::Assertion> exception expected but none was thrown."
-
-    assert_equal expected, e.message
-    # @assertion_count = 2
-  end
-
-  def test_assert_raises_triggered_wrong
-    e = assert_raises(MiniTest::Assertion) do
-      @tc.assert_raises RuntimeError do
-        raise SyntaxError, "icky"
-      end
-    end
-
-    expected = "<RuntimeError> exception expected but was
-Class: <SyntaxError>
-Message: <\"icky\">
----Backtrace---"
-
-    assert_equal expected, e.message.sub(/(---Backtrace---).*/m, '\1')
-  end
-
-  def test_assert_respond_to
-    @tc.assert_respond_to "blah", :empty?
-  end
-
-  def test_assert_respond_to_triggered
-    util_assert_triggered 'Expected "blah" of type String to respond_to? :rawr!' do
-      @tc.assert_respond_to "blah", :rawr!
-    end
-  end
-
-  def test_assert_same
-    o = "blah"
-    @tc.assert_same 1, 1
-    @tc.assert_same :blah, :blah
-    @tc.assert_same o, o
-    @assertion_count = 3
-  end
-
-  def test_assert_same_triggered
-    util_assert_triggered 'Expected 2 to be the same as 1.' do
-      @tc.assert_same 1, 2
-    end
-
-    util_assert_triggered 'Expected "blah" to be the same as "blah".' do
-      s1 = "blah"
-      s2 = "blah"
-      @tc.assert_same s1, s2
-    end
-
-    @assertion_count = 2
-  end
-
-  def test_assert_send
-    o = [ 42 ]
-    @tc.assert_send([o, :clear])
-    assert_equal [], o
-  end
-
-  def test_assert_send_triggered
-    util_assert_triggered '<"blah"> expected to respond to
-<:empty?> with a true value.' do
-      o = "blah"
-      @tc.assert_send([o, :empty?])
-    end
-  end
-
-  def test_assert_throws
-    @tc.assert_throws(:blah) do
-      throw :blah
-    end
-  end
-
-  def test_assert_throws_triggered
-    util_assert_triggered '<:blah> should have been thrown.' do
-      @tc.assert_throws(:blah) do
-        # do nothing
-      end
-    end
-  end
-
-  def test_assert_throws_triggered_different
-    util_assert_triggered '<:blah> should have been thrown.' do
-      @tc.assert_throws(:blah) do
-        throw :not_blah
-      end
-    end
-  end
-
-  def test_flunk
-    util_assert_triggered 'Flunked' do
-      @tc.flunk
-    end
-  end
-
-  def test_flunk_message
-    util_assert_triggered @zomg do
-      @tc.flunk @zomg
-    end
-  end
-
-  def util_assert_triggered expected
-    e = assert_raises(MiniTest::Assertion) do
-      yield
-    end
-
-    assert_equal expected, e.message.sub(/(---Backtrace---).*/m, '\1')
-  end
-
-  def util_test_suites
-    MiniTest::Unit::TestCase.__send__(:class_variable_get, :@@test_suites)
-  end
-
-  def util_test_case
-    Object.const_set(:ATestCase, Class.new(MiniTest::Unit::TestCase))
-  end
-end

data/test/test_test_unit.rb

@@ -1,75 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-require 'stringio'
-
-$TESTING_MINIUNIT = true
-
-require 'test/unit'
-
-class TestTestUnit < MiniTest::Unit::TestCase
-
-  def setup
-    MiniTest::Unit::TestCase.reset
-    @tu = MiniTest::Unit.new
-    MiniTest::Unit.output = StringIO.new("")
-    assert_equal [0, 0], @tu.run_test_suites
-  end
-
-  def teardown
-    MiniTest::Unit.output = $stdout
-  end
-
-  def test_class_puke_with_assertion_failed
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace ["unhappy"]
-    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-  end
-
-  def test_class_puke_with_failure_and_flunk_in_backtrace
-    exception = begin
-                  MiniTest::Unit::TestCase.new.flunk
-                rescue MiniTest::Assertion => failure
-                  failure
-                end
-    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
-    assert !@tu.report.any?{|line| line =~ /in .flunk/}
-  end
-
-  def test_class_puke_with_non_failure_exception
-    exception = Exception.new("Oh no again!")
-    assert_equal 'E', @tu.puke('SomeClass', 'method_name', exception)
-    assert_equal 1, @tu.errors
-    assert_match(/^Exception.*Oh no again!/m, @tu.report.first)
-  end
-
-  def test_class_run_test_suites
-    create_a_test_case_named("ATestCase")
-    assert_equal [1, 1], @tu.run_test_suites
-  end
-
-  def test_class_autotest_failing
-    create_a_test_case_named("FailingTest", :failing => true)
-    @tu.autotest
-    assert_equal(1, @tu.report.size)
-    assert_match(/test_failure/, @tu.report.first)
-  end
-
-  def test_class_autotest_passing
-    create_a_test_case_named("PassingTest")
-    @tu.autotest
-    assert_equal([], @tu.report)
-  end
-
-  def create_a_test_case_named(name, options = {})
-    eval <<-CODE
-      class #{name} < MiniTest::Unit::TestCase
-        def test_something
-          assert true
-        end
-        #{if options[:failing]; "def test_failure; assert false; end"; end}
-      end
-    CODE
-  end
-end