flexmock 1.3.3 → 2.0.0.rc1

data/test/based_partials_test.rb

@@ -1,51 +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'
-
-class BasedPartialsTest < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def setup
-    super
-    FlexMock.partials_are_based = true
-  end
-
-  def teardown
-    FlexMock.partials_are_based = false
-    super
-  end
-
-  class Dog
-    def bark
-      :woof
-    end
-  end
-
-  def test_based_partials_allow_stubbing_defined_methods
-    dog = Dog.new
-    flexmock(dog).should_receive(:bark => :mock_value)
-    assert_equal :mock_value, dog.bark
-  end
-
-  def test_based_partials_disallow_stubbing_undefined_methods
-    dog = Dog.new
-    assert_raise(NoMethodError, /cannot stub.*wag.*explicitly/) do
-      flexmock(dog).should_receive(:wag => :mock_value)
-    end
-  end
-
-  def test_based_partials_allow_explicitly_stubbing_undefined_methods
-    dog = Dog.new
-    flexmock(dog).should_receive(:wag).explicitly.and_return(:mock_value)
-  end
-
-end

data/test/container_methods_test.rb

@@ -1,118 +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"
-
-# These tests exercise the interface used to define mocks
-class TestFlexmockContainerMethods < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_simple_mock_creation
-    mock = flexmock
-    mock.should_receive(:hi).once.and_return(:lo)
-    assert_equal :lo, mock.hi
-  end
-
-  def test_mock_with_name
-    mock = flexmock("Danny")
-    mock.should_receive(:xxx).with(1)
-    ex = assert_raise(assertion_failed_error) { mock.xxx }
-    assert_match(/Danny/, ex.message)
-  end
-
-  def test_mock_with_symbol_name
-    mock = flexmock(:Danny)
-    mock.should_receive(:xxx).with(1)
-    ex = assert_raise(assertion_failed_error) { mock.xxx }
-    assert_match(/Danny/, ex.message)
-  end
-
-  def test_mock_with_hash
-    mock = flexmock(:hi => :lo, :good => :bye)
-    assert_equal :lo, mock.hi
-    assert_equal :bye, mock.good
-  end
-
-  def test_mock_with_name_and_hash
-    mock = flexmock("Danny", :hi => :lo, :good => :bye)
-    mock.should_receive(:xxx).with(1)
-    assert_equal :lo, mock.hi
-    assert_equal :bye, mock.good
-    ex = assert_raise(assertion_failed_error) { mock.xxx }
-    assert_match(/Danny/, ex.message)
-  end
-
-  def test_mock_with_name_hash_and_block
-    mock = flexmock("Danny", :hi => :lo, :good => :bye) do |m|
-      m.should_receive(:one).and_return(1)
-    end
-    assert_equal 1, mock.one
-    assert_equal :lo, mock.hi
-  end
-
-  def test_basic_stub
-    fido = Object.new
-    mock = flexmock(fido)
-    mock.should_receive(:wag).and_return(:happy)
-    assert_equal :happy, fido.wag
-  end
-
-  def test_basic_stub_with_name
-    fido = Object.new
-    mock = flexmock(fido, "Danny")
-    mock.should_receive(:xxx).with(1).and_return(:happy)
-    ex = assert_raise(assertion_failed_error) { fido.xxx }
-    assert_match(/Danny/, ex.message)
-  end
-
-  def test_stub_with_quick_definitions
-    fido = Object.new
-    flexmock(fido, :wag => :happy)
-    assert_equal :happy, fido.wag
-  end
-
-  def test_stub_with_name_quick_definitions
-    fido = Object.new
-    mock = flexmock(fido, "Danny", :wag => :happy)
-    mock.should_receive(:xxx).with(1).and_return(:happy)
-    ex = assert_raise(assertion_failed_error) { fido.xxx }
-    assert_match(/Danny/, ex.message)
-    assert_equal :happy, fido.wag
-  end
-
-  def test_stubs_are_auto_verified
-    fido = Object.new
-    mock = flexmock(fido)
-    mock.should_receive(:hi).once
-    assert_raise(assertion_failed_error) { flexmock_verify }
-  end
-
-  def test_stubbing_a_string
-    s = "hello"
-    flexmock(:base, s, :length => 2)
-    assert_equal 2, s.length
-  end
-
-  def test_multiple_stubs_work_with_same_partial_mock_proxy
-    obj = Object.new
-    mock1 = flexmock(obj)
-    mock2 = flexmock(obj)
-    assert_equal mock1, mock2
-  end
-
-  def test_multiple_stubs_layer_behavior
-    obj = Object.new
-    flexmock(obj, :hi => :lo)
-    flexmock(obj, :high => :low)
-    assert_equal :lo, obj.hi
-    assert_equal :low, obj.high
-  end
-end

data/test/default_framework_adapter_test.rb

@@ -1,38 +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"
-
-class TestFlexmockDefaultFrameworkAdapter < Test::Unit::TestCase
-  def setup
-    @adapter = FlexMock::DefaultFrameworkAdapter.new
-  end
-
-  def test_assert_block_raises_exception
-    assert_raise(FlexMock::DefaultFrameworkAdapter::AssertionFailedError) {
-      @adapter.make_assertion("failure message") { false }
-    }
-  end
-
-  def test_make_assertion_doesnt_raise_exception_when_making_assertion
-    @adapter.make_assertion("failure message") { true }
-  end
-
-  def test_make_assertion_doesnt_raise_exception_when_asserting_equal
-    @adapter.assert_equal("a", "a", "no message")
-  end
-
-  def test_assert_equal_can_fail
-    assert_raise(FlexMock::DefaultFrameworkAdapter::AssertionFailedError) {
-      @adapter.assert_equal("a", "b", "a should not equal b")
-    }
-  end
-end

data/test/demeter_mocking_test.rb

@@ -1,191 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/test_setup'
-
-class TestDemeterMocking < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_demeter_mocking_basics
-    m = flexmock("A")
-    m.should_receive("children.first").and_return(:first)
-    assert_kind_of FlexMock, m
-    assert_kind_of FlexMock, m.children
-    assert_equal :first, m.children.first
-  end
-
-  def test_demeter_mocking_with_operators
-    m = flexmock("A")
-    m.should_receive("children.+@.last").and_return(:value)
-    assert_kind_of FlexMock, m
-    assert_kind_of FlexMock, m.children
-    assert_kind_of FlexMock, + m.children
-    assert_equal :value, (+ m.children).last
-  end
-
-  def test_demeter_mocking_with_multiple_operators
-    m = flexmock("A")
-    m.should_receive("+@.-@.~").and_return(:value)
-    assert_equal :value, ~-+m
-  end
-
-  def test_multiple_demeter_mocks_on_same_branch_is_ok
-    m = flexmock("A")
-    m.should_receive("child.x.y.z.first").and_return(:first)
-    m.should_receive("child.x.y.z.last").and_return(:last)
-    assert_equal :first, m.child.x.y.z.first
-    assert_equal :last, m.child.x.y.z.last
-  end
-
-  def test_multi_level_deep_demeter_violation_with_mock
-    a = flexmock("a")
-    a.should_receive("b.c.d.e.f.g.h.i.j.k").and_return(:xyzzy)
-    assert_equal :xyzzy, a.b.c.d.e.f.g.h.i.j.k
-  end
-
-  def test_partial_with_demeter
-    a = flexmock(Object.new, "a partial")
-    a.should_receive("b.c").and_return(:xyzzy)
-    assert_equal :xyzzy, a.b.c
-  end
-
-  def test_multi_level_deep_demeter_violation_with_partial
-    a = flexmock(Object.new, "a")
-    a.should_receive("b.c.d.e.f.g.h.i.j.k").and_return(:xyzzy)
-    assert_equal :xyzzy, a.b.c.d.e.f.g.h.i.j.k
-  end
-
-  def test_final_method_can_have_multiple_expecations
-    a = flexmock("a")
-    a.should_receive("b.c.d.last").with(1).and_return(:one).once
-    a.should_receive("b.c.d.last").with(2).and_return(:two).once
-    assert_equal :one, a.b.c.d.last(1)
-    assert_equal :two, a.b.c.d.last(2)
-  end
-
-  def test_conflicting_mock_declarations_raises_an_error
-    m = flexmock("A")
-    ex = assert_raise(FlexMock::UsageError) do
-      m.should_receive("child").and_return(:xyzzy)
-      m.should_receive("child.other").and_return(:other)
-      m.child.other
-    end
-    assert_match(/conflicting/i, ex.message)
-    assert_match(/mock\s+declaration/i, ex.message)
-    assert_match(/child/i, ex.message)
-  end
-
-  def test_compatible_mock_declarations_are_ok_full_mock_version
-    m = flexmock("A")
-    b = flexmock("B")
-    c = flexmock("C")
-    m.should_receive(:b => b)
-    b.should_receive(:c => c)
-    c.should_receive(:foo => :bar)
-    m.should_receive("b.c.baz").and_return(:barg)
-    m.should_receive("b.zhar").and_return(:zzz)
-
-    assert_equal :bar, m.b.c.foo
-    assert_equal :barg, m.b.c.baz
-    assert_equal :zzz, m.b.zhar
-  end
-
-  def test_compatible_mock_declarations_are_ok_partial_mock_version
-    m = flexmock("A")
-    b = flexmock(Object.new, "B")
-    c = flexmock("C")
-    m.should_receive(:b => b)
-    b.should_receive(:c => c)
-    c.should_receive(:foo => :bar)
-    m.should_receive("b.c.baz").and_return(:barg)
-    m.should_receive("b.zhar").and_return(:zzz)
-
-    assert_equal :bar, m.b.c.foo
-    assert_equal :barg, m.b.c.baz
-    assert_equal :zzz, m.b.zhar
-  end
-
-  def test_paths
-    m = flexmock("A")
-    b = flexmock("B")
-    m.should_receive("a.b" => b)
-    m.should_receive("a.b.c.x" => 1)
-    m.should_receive("a.b.c.y" => 2)
-  end
-
-  def test_conflicting_mock_declarations_in_reverse_order_does_not_raise_error
-    # Not all conflicting definitions can be detected.
-    m = flexmock("A")
-    assert_failure do
-      m.should_receive("child.other").and_return(:other)
-      m.should_receive("child").and_return(:xyzzy)
-      assert_equal :xyzzy, m.child.other
-    end
-  end
-
-  def test_preestablishing_existing_mock_is_ok
-    engine = flexmock("engine")
-    car = flexmock("A")
-    car.should_receive(:engine).and_return(engine)
-    car.should_receive("engine.cylinder").and_return(:cyl)
-    assert_equal :cyl, car.engine.cylinder
-  end
-
-  def test_quick_defs_can_use_demeter_mocking
-    a = flexmock("a")
-    a.should_receive("b.c.d.x").and_return(:x)
-    a.should_receive("b.c.d.y").and_return(:y)
-    a.should_receive("b.c.d.z").and_return(:z)
-    assert_equal :x, a.b.c.d.x
-    assert_equal :y, a.b.c.d.y
-    assert_equal :z, a.b.c.d.z
-  end
-
-  def test_quick_defs_can_use_demeter_mocking_two
-    a = flexmock("a", "b.c.d.xx" => :x, "b.c.d.yy" => :y, "b.c.d.zz" => :z)
-    assert_equal :x, a.b.c.d.xx
-    assert_equal :y, a.b.c.d.yy
-    assert_equal :z, a.b.c.d.zz
-  end
-
-  def test_errors_on_ill_formed_method_names
-    m = flexmock("a")
-    [
-      'a(2)', '0a', 'a-b', 'a b', ' ', 'a ', ' b', 'a!b', "a?b", 'a=b'
-    ].each do |method|
-      assert_raise FlexMock::UsageError do m.should_receive(method) end
-    end
-  end
-
-  def test_no_errors_on_well_formed_method_names
-    m = flexmock("a")
-    [
-      'a', 'a?', 'a!', 'a=', 'z0', 'save!'
-    ].each do |method|
-      assert_nothing_raised do m.should_receive(method) end
-    end
-  end
-
-  def test_readme_example_1
-    cog = flexmock("cog")
-    cog.should_receive(:turn).once.and_return(:ok).mock
-    joint = flexmock("gear", :cog => cog)
-    axle = flexmock("axle", :universal_joint => joint)
-    chassis = flexmock("chassis", :axle => axle)
-    car = flexmock("car", :chassis => chassis)
-    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
-  end
-
-  def test_readme_example_2
-    car = flexmock("car")
-    car.should_receive("chassis.axle.universal_joint.cog.turn" => :ok).once
-    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
-  end
-
-  def test_readme_example_3
-    car = flexmock("car")
-    car.should_receive("chassis.axle.universal_joint.cog.turn").once.
-      and_return(:ok)
-    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
-  end
-
-end

data/test/deprecated_methods_test.rb

@@ -1,225 +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/deprecated_methods'
-
-class TestFlexMock < Test::Unit::TestCase
-  include FlexMock::TestCase
-  include FlexMock::RedirectError
-
-  def s(&block)
-    redirect_error(&block)
-  end
-
-  def setup
-    @mock = flexmock('mock')
-  end
-
-  def test_handle
-    args = nil
-    s { @mock.mock_handle(:hi) { |a, b| args = [a,b] } }
-    @mock.hi(1,2)
-    assert_equal [1,2], args
-  end
-
-  def test_handle_no_block
-    s { @mock.mock_handle(:blip) }
-    @mock.blip
-    assert true, "just checking for failures"
-  end
-
-  def test_called_with_block
-    called = false
-    s { @mock.mock_handle(:blip) { |block| block.call } }
-    @mock.blip { called = true }
-    assert called, "Block to blip should be called"
-  end
-
-  def test_return_value
-    s { @mock.mock_handle(:blip) { 10 } }
-    assert_equal 10, @mock.blip
-  end
-
-  def test_handle_missing_method
-    expected_error = (RUBY_VERSION >= "1.8.0") ? NoMethodError : NameError
-    ex = assert_raises(expected_error) {
-      @mock.not_defined
-    }
-    assert_match(/not_defined/, ex.message)
-  end
-
-  def test_ignore_missing_method
-    @mock.mock_ignore_missing
-    @mock.blip
-    assert true, "just checking for failures"
-  end
-
-  def test_good_counts
-    s { @mock.mock_handle(:blip, 3) }
-    @mock.blip
-    @mock.blip
-    @mock.blip
-    @mock.flexmock_verify
-  end
-
-  def test_bad_counts
-    s { @mock.mock_handle(:blip, 3) }
-    @mock.blip
-    @mock.blip
-    begin
-      @mock.flexmock_verify
-    rescue assertion_failed_error => err
-    end
-    assert_not_nil err
-  end
-
-  def test_undetermined_counts
-    FlexMock.use('fs') { |m|
-      s { m.mock_handle(:blip) }
-      m.blip
-      m.blip
-      m.blip
-    }
-  end
-
-  def test_zero_counts
-    assert_raises(assertion_failed_error) do
-      FlexMock.use { |m|
-        s { m.mock_handle(:blip, 0) }
-        m.blip
-      }
-    end
-  end
-
-  def test_file_io_with_use
-    FlexMock.use do |m|
-      filedata = ["line 1", "line 2"]
-      s { m.mock_handle(:gets, 3) { filedata.shift } }
-      assert_equal 2, count_lines(m)
-    end
-  end
-
-  def count_lines(stream)
-    result = 0
-    while stream.gets
-      result += 1
-    end
-    result
-  end
-
-  def test_use
-    assert_raises(assertion_failed_error) {
-      FlexMock.use do |m|
-	s { m.mock_handle(:blip, 2) }
-	m.blip
-      end
-    }
-  end
-
-  def test_failures_during_use
-    ex = assert_raises(NameError) {
-      FlexMock.use do |m|
-	s { m.mock_handle(:blip, 2) }
-	xyz
-      end
-    }
-    assert_match(/undefined local variable or method/, ex.message)
-  end
-
-  def test_sequential_values
-    values = [1,4,9,16]
-    s { @mock.mock_handle(:get) { values.shift } }
-    assert_equal 1, @mock.get
-    assert_equal 4, @mock.get
-    assert_equal 9, @mock.get
-    assert_equal 16, @mock.get
-  end
-
-  def test_respond_to_returns_false_for_non_handled_methods
-    assert(!@mock.respond_to?(:blah), "should not respond to blah")
-  end
-
-  def test_respond_to_returns_true_for_explicit_methods
-    s { @mock.mock_handle(:xyz) }
-    assert(@mock.respond_to?(:xyz), "should respond to test")
-  end
-
-  def test_respond_to_returns_true_for_missing_methods_when_ignoring_missing
-    @mock.mock_ignore_missing
-    assert(@mock.respond_to?(:yada), "should respond to yada now")
-  end
-
-  def test_respond_to_returns_true_for_missing_methods_when_ignoring_missing_using_should
-    @mock.should_ignore_missing
-    assert(@mock.respond_to?(:yada), "should respond to yada now")
-  end
-
-  def test_method_proc_raises_error_on_unknown
-    assert_raises(NameError) {
-      @mock.method(:xyzzy)
-    }
-  end
-
-  def test_method_returns_callable_proc
-    got_it = false
-    s { @mock.mock_handle(:xyzzy) { got_it = true } }
-    method_proc = @mock.method(:xyzzy)
-    assert_not_nil method_proc
-    method_proc.call([])
-    assert(got_it, "method proc should run")
-  end
-
-  def test_method_returns_do_nothing_proc_for_missing_methods
-    @mock.mock_ignore_missing
-    method_proc = @mock.method(:plugh)
-    assert_not_nil method_proc
-    assert_equal FlexMock.undefined, method_proc.call
-  end
-end
-
-class TestDeprecatedOrderingMethods < Test::Unit::TestCase
-  include FlexMock::TestCase
-  include FlexMock::RedirectError
-
-  def test_deprecated_ordering_methods
-    flexmock(:x).should_receive(:msg).globally.ordered(:testgroup)
-    assert_equal({ :testgroup => 1 }, flexmock_groups)
-    message = redirect_error do
-      assert_equal({ :testgroup => 1 }, mock_groups)
-    end
-    assert_match(/deprecated/i, message)
-    assert_match(/\bmock_groups/, message)
-    assert_match(/\bflexmock_groups/, message)
-  end
-end
-
-class TestAnyInstance < Test::Unit::TestCase
-  include FlexMock::TestCase
-  include FlexMock::RedirectError
-
-  class Dog
-    def bark
-      :woof
-    end
-  end
-
-  def test_any_instance_still_works_for_backwards_compatibility
-    message = redirect_error do
-      flexstub(Dog).any_instance do |obj|
-        obj.should_receive(:bark).and_return(:whimper)
-        assert_match(/deprecated/, message)
-      end
-    end
-    m = Dog.new
-    assert_equal :whimper,  m.bark
-  end
-end