jferris-mocha 0.9.7.0.1247796736 → 0.9.7.20090701124354

data/Rakefile

@@ -141,7 +141,7 @@ def build_specification(version = Mocha::VERSION)
   Gem::Specification.new do |s|
     s.name   = "mocha"
     s.summary = "Mocking and stubbing library"
-    s.version = "#{version}.0.#{Time.now.to_i}"
+    s.version = version
     s.platform = Gem::Platform::RUBY
       s.author = 'James Mead'
     s.description = <<-EOF
@@ -208,10 +208,3 @@ task 'release' => ['default', 'generate_docs', 'publish_packages', 'publish_docs
   puts "*** Remember to commit newly generated gemspec after release ***"
   puts
 end
-
-desc "Generate a gemspec file"
-task :gemspec do
-  File.open("#{specification.name}.gemspec", 'w') do |f|
-    f.write specification.to_yaml
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jferris-mocha
 version: !ruby/object:Gem::Version 
-  version: 0.9.7.0.1247796736
+  version: 0.9.7.20090701124354
 platform: ruby
 authors: 
 - James Mead
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-15 21:00:00 -07:00
+date: 2009-07-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,7 +59,6 @@ files:
 - lib/mocha/integration/test_unit/ruby_version_186_and_above.rb
 - lib/mocha/integration/test_unit.rb
 - lib/mocha/integration.rb
-- lib/mocha/invocation.rb
 - lib/mocha/is_a.rb
 - lib/mocha/logger.rb
 - lib/mocha/metaclass.rb
@@ -124,7 +123,6 @@ files:
 - test/acceptance/partial_mocks_test.rb
 - test/acceptance/return_value_test.rb
 - test/acceptance/sequence_test.rb
-- test/acceptance/spy_test.rb
 - test/acceptance/states_test.rb
 - test/acceptance/stub_any_instance_method_test.rb
 - test/acceptance/stub_class_method_test.rb
@@ -146,14 +144,12 @@ files:
 - test/acceptance/stubbing_on_non_mock_object_test.rb
 - test/deprecation_disabler.rb
 - test/execution_point.rb
-- test/matcher_helpers.rb
 - test/method_definer.rb
 - test/simple_counter.rb
 - test/test_helper.rb
 - test/test_runner.rb
 - test/unit/any_instance_method_test.rb
 - test/unit/array_inspect_test.rb
-- test/unit/assert_received_test.rb
 - test/unit/backtrace_filter_test.rb
 - test/unit/cardinality_test.rb
 - test/unit/central_test.rb
@@ -164,9 +160,7 @@ files:
 - test/unit/expectation_list_test.rb
 - test/unit/expectation_test.rb
 - test/unit/hash_inspect_test.rb
-- test/unit/have_received_test.rb
 - test/unit/in_state_ordering_constraint_test.rb
-- test/unit/invocation_test.rb
 - test/unit/metaclass_test.rb
 - test/unit/method_matcher_test.rb
 - test/unit/mock_test.rb

data/lib/mocha/invocation.rb

@@ -1,10 +0,0 @@
-module Mocha
-  class Invocation # :nodoc:
-    attr_reader :mock, :method_name, :arguments
-    def initialize(mock, method_name, arguments)
-      @mock        = mock
-      @method_name = method_name
-      @arguments   = arguments
-    end
-  end
-end

data/test/acceptance/spy_test.rb

@@ -1,134 +0,0 @@
-require File.join(File.dirname(__FILE__), "acceptance_test_helper")
-require 'mocha'
-require 'matcher_helpers'
-
-module SpyTestMethods
-
-  def setup
-    setup_acceptance_test
-  end
-  
-  def teardown
-    teardown_acceptance_test
-  end
-  
-  def test_should_accept_wildcard_stub_call_without_arguments
-    instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s
-    assert_received(instance, :to_s)
-    assert_matcher_accepts have_received(:to_s), instance
-  end
-
-  def test_should_accept_wildcard_stub_call_with_arguments
-    instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s(:argument)
-    assert_received(instance, :to_s)
-    assert_matcher_accepts have_received(:to_s), instance
-  end
-
-  def test_should_not_accept_wildcard_stub_without_call
-    instance = new_instance
-    instance.stubs(:to_s)
-    assert_fails { assert_received(instance, :to_s) }
-    assert_fails { assert_matcher_accepts have_received(:to_s), instance }
-  end
-
-  def test_should_not_accept_call_without_arguments
-    instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s
-    assert_fails { assert_received(instance, :to_s) {|expect| expect.with(1) } }
-    assert_fails { assert_matcher_accepts have_received(:to_s).with(1), instance }
-  end
-
-  def test_should_not_accept_call_with_different_arguments
-    instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s(2)
-    assert_fails { assert_received(instance, :to_s) {|expect| expect.with(1) } }
-    assert_fails { assert_matcher_accepts have_received(:to_s).with(1), instance }
-  end
-
-  def test_should_accept_call_with_correct_arguments
-    instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s(1)
-    assert_received(instance, :to_s) {|expect| expect.with(1) }
-    assert_matcher_accepts have_received(:to_s).with(1), instance
-  end
-
-  def test_should_accept_call_with_wildcard_arguments
-    instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s('hello')
-    assert_received(instance, :to_s) {|expect| expect.with(is_a(String)) }
-    assert_matcher_accepts have_received(:to_s).with(is_a(String)), instance
-  end
-
-  def test_should_reject_call_on_different_mock
-    instance = new_instance
-    other    = new_instance
-    instance.stubs(:to_s)
-    other.stubs(:to_s)
-    other.to_s('hello')
-    assert_fails { assert_received(instance, :to_s) {|expect| expect.with(is_a(String)) } }
-    assert_fails { assert_matcher_accepts have_received(:to_s).with(is_a(String)), instance }
-  end
-
-  def test_should_accept_correct_number_of_calls
-    instance = new_instance
-    instance.stubs(:to_s)
-    2.times { instance.to_s }
-    assert_received(instance, :to_s) {|expect| expect.twice }
-    assert_matcher_accepts have_received(:to_s).twice, instance
-  end
-
-  def test_should_reject_not_enough_calls
-    instance = new_instance
-    instance.stubs(:to_s)
-    instance.to_s
-    message = /expected exactly twice/
-    assert_fails(message) { assert_received(instance, :to_s) {|expect| expect.twice } }
-    assert_fails(message) { assert_matcher_accepts have_received(:to_s).twice, instance }
-  end
-
-  def test_should_reject_too_many_calls
-    instance = new_instance
-    instance.stubs(:to_s)
-    2.times { instance.to_s }
-    message = /expected exactly once/
-    assert_fails(message) { assert_received(instance, :to_s) {|expect| expect.once } }
-    assert_fails(message) { assert_matcher_accepts have_received(:to_s).once, instance }
-  end
-
-  def assert_fails(message=/not yet invoked/)
-    begin
-      yield
-    rescue Test::Unit::AssertionFailedError => exception
-      assert_match message, exception.message, "Test failed, but with the wrong message"
-      return
-    end
-    flunk("Expected to fail")
-  end
-
-end
-
-class PartialSpyTest < Test::Unit::TestCase
-  include AcceptanceTest
-  include SpyTestMethods
-
-  def new_instance
-    Object.new
-  end
-end
-
-class PureSpyTest < Test::Unit::TestCase
-  include AcceptanceTest
-  include SpyTestMethods
-
-  def new_instance
-    stub
-  end
-end

data/test/matcher_helpers.rb

@@ -1,5 +0,0 @@
-class Test::Unit::TestCase
-  def assert_matcher_accepts(matcher, instance)
-    assert matcher.matches?(instance), matcher.failure_message
-  end
-end

data/test/unit/assert_received_test.rb

@@ -1,145 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'test_runner'
-require 'mocha/api'
-require 'mocha/mockery'
-require 'mocha/object'
-
-class AssertReceivedTest < Test::Unit::TestCase
-
-  include Mocha
-  include TestRunner
-  include Mocha::API
-
-  def teardown
-    Mockery.reset_instance
-  end
-
-  class FakeMock
-    def initialize(name)
-      @name = name
-    end
-
-    def inspect
-      @name
-    end
-
-    def mocha
-      self
-    end
-  end
-
-  def test_passes_if_invocation_exists
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    Mockery.instance.invocation(mock, method, [])
-    assert_passes do
-      assert_received(mock, method)
-    end
-  end
-
-  def test_fails_if_invocation_doesnt_exist
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    assert_fails do
-      assert_received(mock, method)
-    end
-  end
-
-  def test_fails_if_invocation_exists_with_different_arguments
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    Mockery.instance.invocation(mock, method, [2, 1])
-    assert_fails do
-      assert_received(mock, method) {|expect| expect.with(1, 2) }
-    end
-  end
-
-  def test_passes_if_invocation_exists_with_wildcard_arguments
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    Mockery.instance.invocation(mock, method, ['hello'])
-    assert_passes do
-      assert_received(mock, method) {|expect| expect.with(is_a(String)) }
-    end
-  end
-
-  def test_passes_if_invocation_exists_with_exact_arguments
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    Mockery.instance.invocation(mock, method, ['hello'])
-    assert_passes do
-      assert_received(mock, method) {|expect| expect.with('hello') }
-    end
-  end
-
-  def test_fails_if_invocation_exists_only_on_other_mock
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    other  = 'another mock'
-    Mockery.instance.invocation(other, method, ['hello'])
-    assert_fails do
-      assert_received(mock, method)
-    end
-  end
-
-  def test_passes_if_invocation_exists_for_impersonating_mock
-    method = :a_method
-    object = Object.new
-    mock   = FakeMock.new('a mock')
-
-    class << object
-      attr_accessor :mocha
-    end
-    object.mocha = mock
-
-    Mockery.instance.invocation(mock, method, ['hello'])
-    assert_passes do
-      assert_received(object, method) {|expect| expect.with('hello') }
-    end
-  end
-
-  def test_passes_if_invocation_count_correct
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    2.times { Mockery.instance.invocation(mock, method, []) }
-    assert_passes do
-      assert_received(mock, method) {|expect| expect.twice }
-    end
-  end
-
-  def test_fails_if_invocation_count_too_low
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    Mockery.instance.invocation(mock, method, [])
-    assert_fails do
-      assert_received(mock, method) {|expect| expect.twice }
-    end
-  end
-
-  def test_fails_if_invocation_count_too_high
-    method = :a_method
-    mock   = FakeMock.new('a mock')
-    2.times { Mockery.instance.invocation(mock, method, []) }
-    assert_fails do
-      assert_received(mock, method) {|expect| expect.once }
-    end
-  end
-
-  def assert_passes(&block)
-    assert ! fails?(&block)
-  end
-
-  def assert_fails(&block)
-    assert fails?(&block)
-  end
-
-  def fails?
-    begin
-      yield
-      false
-    rescue Test::Unit::AssertionFailedError
-      true
-    end
-  end
-
-end

data/test/unit/have_received_test.rb

@@ -1,192 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'test_runner'
-require 'mocha/api'
-require 'mocha/mockery'
-require 'mocha/object'
-require 'matcher_helpers'
-
-module HaveReceivedTestMethods
-
-  include Mocha
-
-  def teardown
-    Mockery.reset_instance
-  end
-
-  def test_passes_if_invocation_exists
-    method = :a_method
-    mock   = new_mock('a mock')
-    Mockery.instance.invocation(mock, method, [])
-    assert_passes do
-      assert_matcher_accepts have_received(method), mock
-    end
-  end
-
-  def test_fails_if_invocation_doesnt_exist
-    method = :a_method
-    mock   = new_mock('a mock')
-    assert_fails do
-      assert_matcher_accepts have_received(method), mock
-    end
-  end
-
-  def test_fails_if_invocation_exists_with_different_arguments
-    method = :a_method
-    mock   = new_mock('a mock')
-    Mockery.instance.invocation(mock, method, [2, 1])
-    assert_fails do
-      assert_matcher_accepts have_received(method).with(1, 2), mock
-    end
-  end
-
-  def test_passes_if_invocation_exists_with_wildcard_arguments
-    method = :a_method
-    mock   = new_mock('a mock')
-    Mockery.instance.invocation(mock, method, ['hello'])
-    assert_passes do
-      assert_matcher_accepts have_received(method).with(is_a(String)), mock
-    end
-  end
-
-  def test_passes_if_invocation_exists_with_exact_arguments
-    method = :a_method
-    mock   = new_mock('a mock')
-    Mockery.instance.invocation(mock, method, ['hello'])
-    assert_passes do
-      assert_matcher_accepts have_received(method).with('hello'), mock
-    end
-  end
-
-  def test_fails_if_invocation_exists_only_on_other_mock
-    method = :a_method
-    mock   = new_mock('a mock')
-    other  = 'another mock'
-    Mockery.instance.invocation(other, method, ['hello'])
-    assert_fails do
-      assert_matcher_accepts have_received(method), mock
-    end
-  end
-
-  def test_passes_if_invocation_exists_for_impersonating_mock
-    method = :a_method
-    object = Object.new
-    mock   = new_mock('a mock')
-
-    class << object
-      attr_accessor :mocha
-    end
-    object.mocha = mock
-
-    Mockery.instance.invocation(mock, method, ['hello'])
-    assert_passes do
-      assert_matcher_accepts have_received(method).with('hello'), object
-    end
-  end
-
-  def test_passes_if_invocation_count_correct
-    method = :a_method
-    mock   = new_mock('a mock')
-    2.times { Mockery.instance.invocation(mock, method, []) }
-    assert_passes do
-      assert_matcher_accepts have_received(method).twice, mock
-    end
-  end
-
-  def test_fails_if_invocation_count_incorrect
-    method = :a_method
-    mock   = new_mock('a mock')
-    Mockery.instance.invocation(mock, method, [])
-    assert_fails do
-      assert_matcher_accepts have_received(method).twice, mock
-    end
-  end
-
-  def test_fails_if_invocation_count_too_low
-    method = :a_method
-    mock   = new_mock('a mock')
-    Mockery.instance.invocation(mock, method, [])
-    assert_fails do
-      assert_matcher_accepts have_received(method).twice, mock
-    end
-  end
-
-  def test_fails_if_invocation_count_too_high
-    method = :a_method
-    mock   = new_mock('a mock')
-    2.times { Mockery.instance.invocation(mock, method, []) }
-    assert_fails do
-      assert_matcher_accepts have_received(method).once, mock
-    end
-  end
-
-  def assert_passes(&block)
-    assert ! fails?(&block)
-  end
-
-  def assert_fails(&block)
-    assert fails?(&block)
-  end
-
-  def fails?
-    begin
-      yield
-      false
-    rescue Test::Unit::AssertionFailedError
-      true
-    end
-  end
-
-end
-
-class PartialHaveReceivedTest < Test::Unit::TestCase
-
-  include TestRunner
-  include Mocha::API
-  include HaveReceivedTestMethods
-
-  class FakeMock
-    def initialize(name)
-      @name = name
-    end
-
-    def inspect
-      @name
-    end
-
-    def mocha
-      self
-    end
-  end
-
-  def new_mock(*args)
-    FakeMock.new(*args)
-  end
-
-end
-
-
-class PureHaveReceivedTest < Test::Unit::TestCase
-
-  include TestRunner
-  include Mocha::API
-  include HaveReceivedTestMethods
-
-  class FakeMock
-    def initialize(name)
-      @name = name
-    end
-
-    def inspect
-      @name
-    end
-
-    def mocha
-      self
-    end
-  end
-
-  def new_mock(*args)
-    Mocha::Mock.new(*args)
-  end
-
-end

data/test/unit/invocation_test.rb

@@ -1,17 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/invocation'
-
-class InvocationTest < Test::Unit::TestCase
-
-  include Mocha
-
-  def test_has_mock_method_name_and_args
-    mock   = 'a mock'
-    method = :call_me
-    args   = [1, 2]
-    invocation = Invocation.new(mock, method, args)
-    assert_equal mock, invocation.mock
-    assert_equal method, invocation.method_name
-    assert_equal args, invocation.arguments
-  end
-end