flexmock 1.3.3 → 2.0.0.rc1

data/test/spys_test.rb

@@ -1,215 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/test_setup'
-
-class TestSpys < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  class FooBar
-    def foo
-      :foofoo
-    end
-    def bar
-    end
-  end
-
-  def setup
-    super
-    @spy = flexmock(:on, FooBar)
-  end
-
-  def test_spy_detects_simple_call
-    @spy.foo
-    assert_spy_called @spy, :foo
-  end
-
-  def test_spy_detects_simple_call_ignoring_args
-    @spy.foo(1)
-    assert_spy_called @spy, :foo, :_
-  end
-
-  def test_spy_rejects_a_never_made_call
-    @spy.foo
-    assert_spy_not_called @spy, :bar
-  end
-
-  def test_spy_detects_call_with_literal_arg
-    @spy.foo(1)
-    assert_spy_called @spy, :foo, 1
-  end
-
-  def test_spy_detects_call_with_class_arg
-    @spy.foo(1)
-    assert_spy_called @spy, :foo, Integer
-  end
-
-  def test_spy_rejects_call_with_non_matching_literal_arg
-    @spy.foo(2)
-    assert_spy_not_called @spy, :foo, 1
-  end
-
-  def test_spy_detects_call_with_multiple_arguments
-    @spy.foo(1, "HI", :foo)
-    assert_spy_called @spy, :foo, /1/, "HI", Symbol
-  end
-
-  def test_spy_detects_multiple_calls_with_different_arguments
-    @spy.foo(1)
-    @spy.foo(1)
-    assert_spy_called @spy, {:times => 2}, :foo, 1
-  end
-
-  def test_spy_rejects_if_times_options_not_matching
-    @spy.foo(1)
-    @spy.foo(1)
-    assert_spy_not_called @spy, {:times => 1}, :foo, 1
-  end
-
-  def test_spy_detects_a_block
-    @spy.foo { }
-    assert_spy_called @spy, :foo, Proc
-  end
-
-  def test_spy_rejects_a_block
-    @spy.foo { }
-    assert_spy_not_called @spy, {:with_block => false}, :foo
-  end
-
-  def test_spy_detects_a_missing_block
-    @spy.foo
-    assert_spy_called @spy, {:with_block => false}, :foo
-  end
-
-  def test_spy_rejects_a_missing_block
-    @spy.foo
-    assert_spy_not_called @spy, :foo, Proc
-  end
-
-  def test_spy_ignores_block
-    @spy.foo { }
-    assert_spy_called @spy, :foo, Proc
-  end
-
-  def test_spy_accepts_correct_additional_validations
-    @spy.foo(2)
-    is_even = proc { |n| assert_equal 0, n%2 }
-    assert_spy_called @spy, { :and => is_even }, :foo, Integer
-  end
-
-  def test_spy_accepts_multiple_additional_validations_first_failing
-    @spy.foo(4)
-    is_two  = proc { |n| assert_equal 2, n }
-    is_even = proc { |n| assert_equal 0, n%2 }
-    assert_failed(/2.*expected but was.*4/mi) do
-      assert_spy_called @spy, { :and => [is_two, is_even] }, :foo, Integer
-    end
-  end
-
-  def test_spy_accepts_multiple_additional_validations_second_failing
-    @spy.foo(4)
-    is_even = proc { |n| assert_equal 0, n%2 }
-    is_two  = proc { |n| assert_equal 2, n }
-    assert_failed(/2.*expected but was.*4/mi) do
-      assert_spy_called @spy, { :and => [is_even, is_two] }, :foo, Integer
-    end
-  end
-
-  def test_spy_rejects_incorrect_additional_validations
-    @spy.foo(3)
-    is_even = proc { |n| assert_equal 0, n%2 }
-    assert_failed(/0.*expected but was.*1/mi) do
-      assert_spy_called @spy, { :and => is_even }, :foo, Integer
-    end
-  end
-
-  def test_spy_selectively_applies_additional_validations
-    @spy.foo(2)
-    @spy.foo(3)
-    @spy.foo(4)
-    is_even = proc { |n| assert_equal 0, n%2 }
-    assert_failed(/0.*expected but was.*1/mi) do
-      assert_spy_called @spy, { :and => is_even, :on => 2 }, :foo, Integer
-    end
-  end
-
-  def assert_failed(message_pattern)
-    failed = false
-    begin
-      yield
-    rescue assertion_failed_error => ex
-      failed = true
-      assert_match message_pattern, ex.message
-    end
-    assert(failed, "Expected block to fail")
-  end
-
-  def test_spy_methods_can_be_stubbed
-    @spy.should_receive(:foo).and_return(:hi)
-    result = @spy.foo
-    assert_equal result, :hi
-    assert_spy_called @spy, :foo
-  end
-
-  def test_spy_cannot_see_normal_methods
-    foo = FooBar.new
-    flexmock(foo)
-    assert_equal :foofoo, foo.foo
-    assert_spy_not_called foo, :foo
-  end
-
-  def test_spy_cannot_see_normal_methods2
-    foo = FooBar.new
-    flexmock(foo).should_receive(:foo).pass_thru
-    assert_equal :foofoo, foo.foo
-    assert_spy_called foo, :foo
-  end
-
-  def test_calling_non_spy_base_methods_is_an_error
-    assert_raise(NoMethodError) do
-      @spy.baz
-    end
-  end
-
-  def test_cant_put_expectations_on_non_base_class_methodsx
-    ex = assert_raise(NoMethodError) do
-      @spy.should_receive(:baz).and_return(:bar)
-    end
-    assert_match(/cannot stub.*defined.*base.*class/i, ex.message)
-    assert_match(/method: +baz/i, ex.message)
-    assert_match(/base class: +TestSpys::FooBar/i, ex.message)
-  end
-
-  def test_cant_put_expectations_on_non_base_class_methods_unless_explicit
-    @spy.should_receive(:baz).explicitly.and_return(:bar)
-    @spy.baz
-    assert_spy_called @spy, :baz
-  end
-
-  def test_ok_to_use_explicit_even_when_its_not_needed
-    @spy.should_receive(:foo).explicitly.and_return(:bar)
-    @spy.foo
-    assert_spy_called @spy, :foo
-  end
-
-  def test_can_spy_on_partial_mocks
-    @foo = FooBar.new
-    @spy = flexmock(@foo)
-    @foo.should_receive(:foo => :baz)
-    result = @foo.foo
-    assert_equal :baz, result
-    assert_spy_called @foo, :foo
-  end
-
-  def test_can_spy_on_class_defined_methods
-    flexmock(FooBar).should_receive(:new).and_return(:dummy)
-    FooBar.new
-    assert_spy_called FooBar, :new
-  end
-
-  def test_can_spy_on_regular_mocks
-    mock = flexmock("regular mock")
-    mock.should_receive(:foo => :bar)
-    mock.foo
-    assert_spy_called mock, :foo
-  end
-end

data/test/symbol_extensions_test.rb

@@ -1,8 +0,0 @@
-require 'test/test_setup'
-
-class SymbolEtentensionsTest < Test::Unit::TestCase
-  def test_as_name_converts_appropriatly
-    method_name_class = self.class.instance_methods.first.class
-    assert_equal method_name_class, :some_name.flexmock_as_name.class
-  end
-end

data/test/test_class_extensions.rb

@@ -1,34 +0,0 @@
-require 'test/test_setup'
-
-class ClassExtensionsTest < Test::Unit::TestCase
-
-  class Dog
-    def wag
-    end
-
-    def method_missing(sym, *args, &block)
-      if sym == :bark
-        :woof
-      else
-        super
-      end
-    end
-
-    def responds_to?(sym)
-      sym == :bark || super
-    end
-  end
-
-  def test_class_directly_defines_method
-    assert Dog.flexmock_defined?(:wag)
-  end
-
-  def test_class_indirectly_defines_method
-    assert ! Dog.flexmock_defined?(:bark)
-  end
-
-  def test_class_does_not_define_method
-    assert ! Dog.flexmock_defined?(:jump)
-  end
-
-end

data/test/test_setup.rb

@@ -1,92 +0,0 @@
-require 'test/unit'
-require 'fileutils'
-
-require 'flexmock'
-require 'test/redirect_error'
-
-class FlexMock
-  module TestCase
-    def assertion_failed_error
-      FlexMock.framework_adapter.assertion_failed_error
-    end
-
-    # Assertion helper used to assert validation failure.  If a
-    # message is given, then the error message should match the
-    # expected error message.
-    def assert_failure(options={}, &block)
-      message = options[:message]
-      ex = assert_raises(assertion_failed_error) { yield }
-      if message
-        case message
-        when Regexp
-          assert_match message, ex.message
-        when String
-          assert ex.message.index(message), "Error message '#{ex.message}' should contain '#{message}'"
-        end
-      end
-      ex
-    end
-
-    # Similar to assert_failure, but assumes that a mock generated
-    # error object is return, so additional tests on the backtrace are
-    # added.
-    def assert_mock_failure(options={}, &block)
-      ex = assert_failure(options, &block)
-      file = eval("__FILE__", block.binding)
-      assert_matching_line(ex, file, options)
-    end
-
-    # Assert that there is a line matching file in the backtrace.
-    # Options are:
-    #
-    #     deep: true -- matching line can be anywhere in backtrace,
-    #                   otherwise it must be the first.
-    #
-    #     line: n    -- Add a line number to the match
-    #
-    def assert_matching_line(ex, file, options)
-      line = options[:line]
-      search_all = options[:deep]
-      if line
-        loc_re = /#{Regexp.quote(file)}:#{line}/
-      else
-        loc_re = Regexp.compile(Regexp.quote(file))
-      end
-
-
-      if search_all
-        bts = ex.backtrace.join("\n")
-        assert_with_block("expected a backtrace line to match #{loc_re}\nBACKTRACE:\n#{bts}") {
-          ex.backtrace.any? { |bt| loc_re =~ bt }
-        }
-      else
-        assert_match(loc_re, ex.backtrace.first)
-      end
-
-      ex
-    end
-
-    unless defined?(refute_match)
-      def refute_match(*args)
-        assert_no_match(*args)
-      end
-    end
-
-    def assert_with_block(msg=nil)
-      unless yield
-        assert(false, msg || "Expected block to yield true")
-      end
-    end
-
-    def pending(msg="")
-      state = "PASSING"
-      begin
-        yield
-      rescue Exception => _
-        state = "FAILING"
-      end
-      where = caller.first.split(/:in/).first
-      puts "\n#{state} PENDING TEST (#{msg}) #{where}"
-    end
-  end
-end

data/test/test_unit_integration/auto_test_unit_test.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-
-#---
-# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
-# 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/test_setup"
-
-require "flexmock/base"
-require "flexmock/test_unit"
-
-class TestFlexmockTestUnit < Test::Unit::TestCase
-  def teardown
-    failed = false
-    begin
-      super
-    rescue Exception => ex
-      failed = true
-    end
-    assert_equal @should_fail, failed, "Expected failed to be #{@should_fail}"
-  end
-
-  # This test should pass.
-  def test_can_create_mocks
-    m = flexmock("mock")
-    m.should_receive(:hi).once
-    m.hi
-    @should_fail = false
-  end
-
-  # This test should fail during teardown.
-  def test_should_fail__mocks_are_auto_verified
-    m = flexmock("mock")
-    m.should_receive(:hi).once
-    @should_fail = true
-  end
-end

data/test/test_unit_integration/minitest_teardown_test.rb

@@ -1,14 +0,0 @@
-require "minitest/autorun"
-require 'flexmock/test_unit'
-
-class SimpleTest < MiniTest::Unit::TestCase
-
-  # This validates that the minitest teardown method is properly
-  # aliased when using MiniTest.
-  #
-  # (see https://github.com/jimweirich/flexmock/issues/14).
-  #
-  def test_flexmock
-    flexmock()
-  end
-end

data/test/tu_integration_test.rb

@@ -1,99 +0,0 @@
-#!/usr/bin/env ruby
-
-#---
-# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
-# 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/test_setup'
-
-# The following tests exercise Test::Unit integration.  They are
-# disabled if actually running under MiniTest because the MiniTest is
-# different enough internally that the tests are not worthwhile.
-
-unless defined?(MiniTest)
-  class TestTuIntegrationFlexMockMethod < Test::Unit::TestCase
-    include FlexMock::TestCase
-
-    def test_can_construct_flexmock
-      mock = flexmock("x")
-      mock.should_receive(:hi).and_return(:hello)
-      assert_equal :hello, mock.hi
-    end
-
-    def test_can_construct_flexmock_with_block
-      mock = flexmock("x") do |m|
-        m.should_receive(:hi).and_return(:hello)
-      end
-      assert_equal :hello, mock.hi
-    end
-  end
-
-  class TestTuIntegrationMockVerificationInTeardown < Test::Unit::TestCase
-    include FlexMock::TestCase
-
-    def teardown
-      assert_raise(assertion_failed_error) do
-        super
-      end
-    end
-
-    def test_mock_verification_occurs_during_teardown
-      flexmock("xyz").should_receive(:hi).with(any).once
-    end
-  end
-
-  class TestTuIntegrationMockVerificationWithoutSetup < Test::Unit::TestCase
-    include FlexMock::TestCase
-
-    def teardown
-      assert_raise(assertion_failed_error) do
-        super
-      end
-    end
-
-    def test_mock_verification_occurs_during_teardown
-      flexmock("xyz").should_receive(:hi).with(any).once
-    end
-  end
-
-  class TestTuIntegrationMockVerificationForgetfulSetup < Test::Unit::TestCase
-    include FlexMock::TestCase
-
-    def teardown
-      assert_raise(assertion_failed_error) do
-        super
-      end
-    end
-
-    def test_mock_verification_occurs_during_teardown
-      flexmock("xyz").should_receive(:hi).with(any).once
-    end
-  end
-
-  class TestTuIntegrationSetupOverridenAndNoMocksOk < Test::Unit::TestCase
-    include FlexMock::TestCase
-
-    def test_mock_verification_occurs_during_teardown
-    end
-  end
-
-  class TestTuIntegrationFailurePreventsVerification < Test::Unit::TestCase
-    include FlexMock::TestCase
-
-    def test_mock_verification_occurs_during_teardown
-      flexmock('m').should_receive(:hi).once
-      simulate_failure
-    end
-
-    private
-
-    def simulate_failure
-      @test_passed = false
-    end
-  end
-end