mocha 0.12.8 → 0.13.0

data/lib/mocha/integration/mini_test/version_420_to_433.rb

@@ -1,70 +0,0 @@
-require 'mocha/integration/mini_test/assertion_counter'
-require 'mocha/expectation_error'
-
-module Mocha
-
-  module Integration
-
-    module MiniTest
-
-      module Version420To433
-        def self.included(mod)
-          $stderr.puts "Monkey patching MiniTest >= v4.2.0 <= v4.3.3" if $mocha_options['debug']
-        end
-        def run runner
-          trap "INFO" do
-            runner.report.each_with_index do |msg, i|
-              warn "\n%3d) %s" % [i + 1, msg]
-            end
-            warn ''
-            time = runner.start_time ? Time.now - runner.start_time : 0
-            warn "Current Test: %s#%s %.2fs" % [self.class, self.__name__, time]
-            runner.status $stderr
-          end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-          start_time = Time.now
-          assertion_counter = AssertionCounter.new(self)
-          result = ""
-          begin
-            begin
-              @passed = nil
-              self.before_setup
-              self.setup
-              self.after_setup
-              self.run_test self.__name__
-              mocha_verify(assertion_counter)
-              result = "." unless io?
-              time = Time.now - start_time
-              runner.record self.class, self.__name__, self._assertions, time, nil
-              @passed = true
-            rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-              raise
-            rescue Exception => e
-              @passed = false
-              time = Time.now - start_time
-              runner.record self.class, self.__name__, self._assertions, time, e
-              result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-            ensure
-              %w{ before_teardown teardown after_teardown }.each do |hook|
-                begin
-                  self.send hook
-                rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                  raise
-                rescue Exception => e
-                  @passed = false
-                  result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-                end
-              end
-              trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-            end
-          ensure
-            mocha_teardown
-          end
-          result
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/mocha/integration/mini_test/version_440.rb

@@ -1,70 +0,0 @@
-require 'mocha/integration/mini_test/assertion_counter'
-require 'mocha/expectation_error'
-
-module Mocha
-
-  module Integration
-
-    module MiniTest
-
-      module Version440
-        def self.included(mod)
-          $stderr.puts "Monkey patching MiniTest >= v4.4.0 <= v4.4.0" if $mocha_options['debug']
-        end
-        def run runner
-          trap "INFO" do
-            runner.report.each_with_index do |msg, i|
-              warn "\n%3d) %s" % [i + 1, msg]
-            end
-            warn ''
-            time = runner.start_time ? Time.now - runner.start_time : 0
-            warn "Current Test: %s#%s %.2fs" % [self.class, self.__name__, time]
-            runner.status $stderr
-          end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-          start_time = Time.now
-          assertion_counter = AssertionCounter.new(self)
-          result = ""
-          begin
-            begin
-              @passed = nil
-              self.before_setup
-              self.setup
-              self.after_setup
-              self.run_test self.__name__
-              mocha_verify(assertion_counter)
-              result = "." unless io?
-              time = Time.now - start_time
-              runner.record self.class, self.__name__, self._assertions, time, nil
-              @passed = true
-            rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-              raise
-            rescue Exception => e
-              @passed = ::MiniTest::Skip === e
-              time = Time.now - start_time
-              runner.record self.class, self.__name__, self._assertions, time, e
-              result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-            ensure
-              %w{ before_teardown teardown after_teardown }.each do |hook|
-                begin
-                  self.send hook
-                rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                  raise
-                rescue Exception => e
-                  @passed = false
-                  result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-                end
-              end
-              trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-            end
-          ensure
-            mocha_teardown
-          end
-          result
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/mocha/integration/test_unit/assertion_counter.rb

@@ -1,23 +0,0 @@
-module Mocha
-
-  module Integration
-
-    module TestUnit
-
-      class AssertionCounter
-
-        def initialize(test_result)
-          @test_result = test_result
-        end
-
-        def increment
-          @test_result.add_assertion
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/mocha/integration/test_unit/gem_version_230_to_253.rb

@@ -1,58 +0,0 @@
-require 'test/unit/testcase'
-require 'mocha/integration/test_unit/assertion_counter'
-require 'mocha/expectation_error'
-
-module Mocha
-
-  module Integration
-
-    module TestUnit
-
-      module GemVersion230To253
-        def self.included(mod)
-          $stderr.puts "Monkey patching Test::Unit gem >= v2.3.0 and <= v2.5.3" if $mocha_options['debug']
-        end
-        def run(result)
-          assertion_counter = AssertionCounter.new(result)
-          begin
-            @internal_data.test_started
-            @_result = result
-            yield(Test::Unit::TestCase::STARTED, name)
-            yield(Test::Unit::TestCase::STARTED_OBJECT, self)
-            begin
-              begin
-                run_setup
-                run_test
-                run_cleanup
-                mocha_verify(assertion_counter)
-                add_pass
-              rescue Mocha::ExpectationError => e
-                add_failure(e.message, e.backtrace)
-              rescue Exception
-                @internal_data.interrupted
-                raise unless handle_exception($!)
-              ensure
-                begin
-                  run_teardown
-                rescue Exception
-                  raise unless handle_exception($!)
-                end
-              end
-            ensure
-              mocha_teardown
-            end
-            @internal_data.test_finished
-            result.add_run
-            yield(Test::Unit::TestCase::FINISHED, name)
-            yield(Test::Unit::TestCase::FINISHED_OBJECT, self)
-          ensure
-            # @_result = nil # For test-spec's after_all :<
-          end
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/mocha/options.rb

@@ -1 +0,0 @@
-$mocha_options = (ENV['MOCHA_OPTIONS'] || '').split(',').inject({}) { |hash, key| hash[key] = true; hash }

data/test/acceptance/api_test.rb

@@ -1,139 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-require 'mocha_standalone'
-require 'simple_counter'
-
-class NotATestUnitAssertionFailedError < StandardError
-end
-
-class NotATestUnitTestCase
-
-  include Mocha::API
-
-  attr_reader :assertion_counter
-
-  def initialize
-    @assertion_counter = SimpleCounter.new
-  end
-
-  def run(test_method)
-    mocha_setup
-    begin
-      prepare
-      begin
-        send(test_method)
-        mocha_verify(@assertion_counter)
-      rescue Mocha::ExpectationError => e
-        new_error = NotATestUnitAssertionFailedError.new(e.message)
-        new_error.set_backtrace(e.backtrace)
-        raise new_error
-      ensure
-        cleanup
-      end
-    ensure
-      mocha_teardown
-    end
-  end
-
-  def prepare
-  end
-
-  def cleanup
-  end
-
-end
-
-class SampleTest < NotATestUnitTestCase
-
-  def mock_object_with_fulfilled_expectation
-    mockee = mock()
-    mockee.expects(:blah)
-    mockee.blah
-  end
-
-  def mock_object_with_unfulfilled_expectation
-    mockee = mock()
-    mockee.expects(:blah)
-  end
-
-  def mock_object_with_unexpected_invocation
-    mockee = mock()
-    mockee.blah
-  end
-
-  def real_object_with_fulfilled_expectation
-    stubbee = Class.new { define_method(:blah) {} }.new
-    stubbee.expects(:blah)
-    stubbee.blah
-  end
-
-  def real_object_with_unfulfilled_expectation
-    stubbee = Class.new { define_method(:blah) {} }.new
-    stubbee.expects(:blah)
-  end
-
-  def mock_object_with_matching_parameter
-    mockee = mock()
-    mockee.expects(:blah).with(has_key(:wibble))
-    mockee.blah(:wibble => 1)
-  end
-
-  def mock_object_with_non_matching_parameter
-    mockee = mock()
-    mockee.expects(:blah).with(has_key(:wibble))
-    mockee.blah(:wobble => 2)
-  end
-
-end
-
-require 'test/unit'
-
-class APITest < Test::Unit::TestCase
-
-  attr_reader :sample_test
-
-  include AcceptanceTest
-
-  def setup
-    @sample_test = SampleTest.new
-    setup_acceptance_test
-  end
-
-  def teardown
-    teardown_acceptance_test
-  end
-
-  def test_should_pass_mock_object_test
-    assert_nothing_raised { sample_test.run(:mock_object_with_fulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_fail_mock_object_test_due_to_unfulfilled_exception
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mock_object_with_unfulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_fail_mock_object_test_due_to_unexpected_invocation
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mock_object_with_unexpected_invocation) }
-    assert_equal 0, sample_test.assertion_counter.count
-  end
-
-  def test_should_pass_real_object_test
-    assert_nothing_raised { sample_test.run(:real_object_with_fulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_fail_real_object_test
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:real_object_with_unfulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_pass_mock_object_test_with_matching_parameter
-    assert_nothing_raised { sample_test.run(:mock_object_with_matching_parameter) }
-    assert_equal 1, sample_test.assertion_counter.count
-  end
-
-  def test_should_fail_mock_object_test_with_non_matching_parameter
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mock_object_with_non_matching_parameter) }
-  end
-
-end

data/test/acceptance/minitest_test.rb

@@ -1,162 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-
-if defined?(MiniTest)
-  $stderr.puts "TODO: Running suite with MiniTest, running the MiniTestAdapterTest results in an error so skipping it for now."
-else
-  begin
-    require 'rubygems'
-    gem 'minitest'
-  rescue Gem::LoadError
-    # MiniTest gem not available
-  end
-
-  begin
-    require 'minitest/unit'
-  rescue LoadError
-    # MiniTest not available
-  end
-
-  if defined?(MiniTest)
-
-    # monkey-patch MiniTest now that it has hopefully been loaded
-    require 'mocha/integration/mini_test'
-
-    class MiniTestSampleTest < MiniTest::Unit::TestCase
-
-      def test_mocha_with_fulfilled_expectation
-        mockee = mock()
-        mockee.expects(:blah)
-        mockee.blah
-      end
-
-      def test_mocha_with_unfulfilled_expectation
-        mockee = mock()
-        mockee.expects(:blah)
-      end
-
-      def test_mocha_with_unexpected_invocation
-        mockee = mock()
-        mockee.blah
-      end
-
-      def test_stubba_with_fulfilled_expectation
-        stubbee = Class.new { define_method(:blah) {} }.new
-        stubbee.expects(:blah)
-        stubbee.blah
-      end
-
-      def test_stubba_with_unfulfilled_expectation
-        stubbee = Class.new { define_method(:blah) {} }.new
-        stubbee.expects(:blah)
-      end
-
-      def test_mocha_with_matching_parameter
-        mockee = mock()
-        mockee.expects(:blah).with(has_key(:wibble))
-        mockee.blah(:wibble => 1)
-      end
-
-      def test_mocha_with_non_matching_parameter
-        mockee = mock()
-        mockee.expects(:blah).with(has_key(:wibble))
-        mockee.blah(:wobble => 2)
-      end
-
-    end
-
-    class MiniTestTest < Test::Unit::TestCase
-
-      def setup
-        @output = StringIO.new
-        MiniTest::Unit.output = @output
-        @runner = MiniTest::Unit.new
-      end
-
-      attr_reader :runner
-
-      def test_should_pass_mocha_test
-        run_test_method :test_mocha_with_fulfilled_expectation
-
-        assert_equal 0, runner.failures
-        assert_equal 0, runner.errors
-        assert_equal 1, runner.assertion_count
-      end
-
-      def test_should_fail_mocha_test_due_to_unfulfilled_expectation
-        run_test_method :test_mocha_with_unfulfilled_expectation
-
-        assert_equal 1, runner.failures
-        assert_equal 0, runner.errors
-        assert_equal 1, runner.assertion_count
-        assert_not_all_expectation_were_satisfied
-      end
-
-      def test_should_fail_mocha_test_due_to_unexpected_invocation
-        run_test_method :test_mocha_with_unexpected_invocation
-
-        assert_equal 1, runner.failures
-        assert_equal 0, runner.errors
-        assert_equal 0, runner.assertion_count
-        assert_unexpected_invocation
-      end
-
-      def test_should_pass_stubba_test
-        run_test_method :test_stubba_with_fulfilled_expectation
-
-        assert_equal 0, runner.failures
-        assert_equal 0, runner.errors
-        assert_equal 1, runner.assertion_count
-      end
-
-      def test_should_fail_stubba_test_due_to_unfulfilled_expectation
-        run_test_method :test_stubba_with_unfulfilled_expectation
-
-        assert_equal 1, runner.failures
-        assert_equal 0, runner.errors
-        assert_equal 1, runner.assertion_count
-        assert_not_all_expectation_were_satisfied
-      end
-
-      def test_should_pass_mocha_test_with_matching_parameter
-        run_test_method :test_mocha_with_matching_parameter
-
-        assert_equal 0, runner.failures
-        assert_equal 0, runner.errors
-        assert_equal 1, runner.assertion_count
-      end
-
-      def test_should_fail_mocha_test_with_non_matching_parameter
-        run_test_method :test_mocha_with_non_matching_parameter
-
-        assert_equal 1, runner.failures
-        assert_equal 0, runner.errors
-        assert_equal 0, runner.assertion_count # unexpected invocation occurs before expectation is verified
-        assert_unexpected_invocation
-      end
-
-      private
-
-      def run_test_method(method_name)
-        run_method = (MiniTest::Unit::VERSION >= "2.1.0") ? :_run : :run
-        runner.send(run_method, ["-n", method_name.to_s])
-      end
-
-      def output
-        @output.rewind
-        @output.read
-      end
-
-      def assert_unexpected_invocation
-        assert_match Regexp.new('unexpected invocation'), output, "MiniTest output:\n#{output}"
-      end
-
-      def assert_not_all_expectation_were_satisfied
-        assert_match Regexp.new('not all expectations were satisfied'), output, "MiniTest output:\n#{output}"
-      end
-
-    end
-
-  else
-    $stderr.puts "MiniTest is not available, so MiniTestAdapterTest has not been run."
-  end
-end

data/test/unit/object_test.rb

@@ -1,92 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/object'
-require 'mocha/mockery'
-require 'mocha/mock'
-require 'method_definer'
-
-class ObjectTest < Test::Unit::TestCase
-
-  include Mocha
-
-  def test_should_build_mocha_referring_to_self
-    instance = Object.new
-    mocha = instance.mocha
-    assert_not_nil mocha
-    assert mocha.is_a?(Mock)
-    assert_equal instance.mocha_inspect, mocha.mocha_inspect
-  end
-
-  def test_should_reuse_existing_mocha
-    instance = Object.new
-    mocha_1 = instance.mocha
-    mocha_2 = instance.mocha
-    assert_equal mocha_1, mocha_2
-  end
-
-  def test_should_reset_mocha
-    instance = Object.new
-    assert_nil instance.reset_mocha
-  end
-
-  def test_should_build_any_instance_object
-    klass = Class.new
-    any_instance = klass.any_instance
-    assert_not_nil any_instance
-    assert any_instance.is_a?(Class::AnyInstance)
-  end
-
-  def test_should_return_same_any_instance_object
-    klass = Class.new
-    any_instance_1 = klass.any_instance
-    any_instance_2 = klass.any_instance
-    assert_equal any_instance_1, any_instance_2
-  end
-
-  def test_should_use_stubba_instance_method_for_object
-    assert_equal Mocha::InstanceMethod, Object.new.stubba_method
-  end
-
-  def test_should_use_stubba_module_method_for_module
-    assert_equal Mocha::ModuleMethod, Module.new.stubba_method
-  end
-
-  def test_should_use_stubba_class_method_for_class
-    assert_equal Mocha::ClassMethod, Class.new.stubba_method
-  end
-
-  def test_should_use_stubba_class_method_for_any_instance
-    assert_equal Mocha::AnyInstanceMethod, Class::AnyInstance.new(nil).stubba_method
-  end
-
-  def test_should_stub_self_for_object
-    object = Object.new
-    assert_equal object, object.stubba_object
-  end
-
-  def test_should_stub_self_for_module
-    mod = Module.new
-    assert_equal mod, mod.stubba_object
-  end
-
-  def test_should_stub_self_for_class
-    klass = Class.new
-    assert_equal klass, klass.stubba_object
-  end
-
-  def test_should_stub_relevant_class_for_any_instance
-    klass = Class.new
-    any_instance = Class::AnyInstance.new(klass)
-    assert_equal klass, any_instance.stubba_object
-  end
-
-  def test_nobody_expects_the_spanish_inquisition
-    object = Object.new
-    assert_raise(Mocha::ExpectationError) { object.expects(:the_spanish_inquisition) }
-  end
-
-  def test_should_alias_object_method
-    klass = Class.new { def self.method_x; end }
-    assert_equal klass._method(:method_x), klass.method(:method_x)
-  end
-
-end