mocha 0.5.6 → 0.9.0

data/test/unit/object_test.rb

@@ -1,18 +1,19 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/object'
+require 'mocha/mockery'
 require 'mocha/mock'
 require 'method_definer'
 
-require 'mocha/object'
-
 class ObjectTest < Test::Unit::TestCase
   
   include Mocha
     
-  def test_should_build_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
@@ -27,58 +28,6 @@ class ObjectTest < Test::Unit::TestCase
     assert_nil instance.reset_mocha
   end
   
-  def test_should_stub_instance_method
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.expects(:stub).with(Mocha::InstanceMethod.new(instance, :method1))
-    instance.expects(:method1)
-    $stubba.verify
-  end 
-  
-  def test_should_build_and_store_expectation
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    expectation = instance.expects(:method1)
-    assert_equal [expectation], instance.mocha.expectations.to_a
-  end
-  
-  def test_should_verify_expectations
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    instance.expects(:method1).with(:value1, :value2)
-    assert_raise(ExpectationError) { instance.verify }
-  end
-  
-  def test_should_pass_backtrace_into_expects
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    mocha = Object.new
-    mocha.define_instance_accessor(:expects_parameters)
-    mocha.define_instance_method(:expects) { |*parameters| self.expects_parameters = parameters }
-    backtrace = Object.new
-    instance.define_instance_method(:mocha) { mocha }
-    instance.define_instance_method(:caller) { backtrace }
-    instance.expects(:method1)
-    assert_equal [:method1, backtrace], mocha.expects_parameters
-  end
-      
-  def test_should_pass_backtrace_into_stubs
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    mocha = Object.new
-    mocha.define_instance_accessor(:stubs_parameters)
-    mocha.define_instance_method(:stubs) { |*parameters| self.stubs_parameters = parameters }
-    backtrace = Object.new
-    instance.define_instance_method(:mocha) { mocha }
-    instance.define_instance_method(:caller) { backtrace }
-    instance.stubs(:method1)
-    assert_equal [:method1, backtrace], mocha.stubs_parameters
-  end
-      
   def test_should_build_any_instance_object
     klass = Class.new
     any_instance = klass.any_instance
@@ -93,44 +42,12 @@ class ObjectTest < Test::Unit::TestCase
     assert_equal any_instance_1, any_instance_2
   end
   
-  def test_should_stub_class_method
-    klass = Class.new
-    $stubba = Mock.new
-    $stubba.expects(:stub).with(Mocha::ClassMethod.new(klass, :method1))
-    klass.expects(:method1)
-    $stubba.verify
-  end 
-  
-  def test_should_build_and_store_class_method_expectation
-    klass = Class.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    expectation = klass.expects(:method1)
-    assert_equal [expectation], klass.mocha.expectations.to_a
-  end
-  
-  def test_should_stub_module_method
-    mod = Module.new
-    $stubba = Mock.new
-    $stubba.expects(:stub).with(Mocha::ClassMethod.new(mod, :method1))
-    mod.expects(:method1)
-    $stubba.verify
-  end
-  
-  def test_should_build_and_store_module_method_expectation
-    mod = Module.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    expectation = mod.expects(:method1)
-    assert_equal [expectation], mod.mocha.expectations.to_a
-  end
-  
   def test_should_use_stubba_instance_method_for_object
     assert_equal Mocha::InstanceMethod, Object.new.stubba_method
   end
     
-  def test_should_use_stubba_class_method_for_module
-    assert_equal Mocha::ClassMethod, Module.new.stubba_method
+  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

data/test/unit/parameter_matchers/equals_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/equals'
+require 'mocha/inspect'
+
+class EqualsTest < Test::Unit::TestCase
+
+  include Mocha::ParameterMatchers
+
+  def test_should_match_object_that_equals_value
+    matcher = equals('x')
+    assert matcher.matches?(['x'])
+  end
+
+  def test_should_not_match_object_that_does_not_equal_value
+    matcher = equals('x')
+    assert !matcher.matches?(['y'])
+  end
+
+  def test_should_describe_matcher
+    matcher = equals('x')
+    assert_equal "'x'", matcher.mocha_inspect
+  end
+
+end

data/test/unit/parameter_matchers/has_entries_test.rb

@@ -1,6 +1,7 @@
 require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
 
 require 'mocha/parameter_matchers/has_entries'
+require 'mocha/parameter_matchers/object'
 require 'mocha/inspect'
 
 class HasEntriesTest < Test::Unit::TestCase
@@ -22,9 +23,29 @@ class HasEntriesTest < Test::Unit::TestCase
     description = matcher.mocha_inspect
     matches = /has_entries\((.*)\)/.match(description)
     assert_not_nil matches[0]
-    entries = eval(matches[1])
+    entries = eval(matches[1], binding, __FILE__, __LINE__)
     assert_equal 'value_1', entries[:key_1]
     assert_equal 'value_2', entries[:key_2]
   end
   
+  def test_should_match_hash_including_specified_entries_with_nested_key_matchers
+    matcher = has_entries(equals(:key_1) => 'value_1', equals(:key_2) => 'value_2')
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_entries_with_nested_key_matchers
+    matcher = has_entries(equals(:key_1) => 'value_2', equals(:key_2) => 'value_2', equals(:key_3) => 'value_3')
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_match_hash_including_specified_entries_with_nested_value_matchers
+    matcher = has_entries(:key_1 => equals('value_1'), :key_2 => equals('value_2'))
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_entries_with_nested_value_matchers
+    matcher = has_entries(:key_1 => equals('value_2'), :key_2 => equals('value_2'), :key_3 => equals('value_3'))
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
 end

data/test/unit/parameter_matchers/has_entry_test.rb

@@ -1,6 +1,8 @@
 require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
 
 require 'mocha/parameter_matchers/has_entry'
+require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class HasEntryTest < Test::Unit::TestCase
@@ -29,12 +31,32 @@ class HasEntryTest < Test::Unit::TestCase
   
   def test_should_describe_matcher_with_key_value_pair
     matcher = has_entry(:key_1, 'value_1')
-    assert_equal "has_entry(:key_1, 'value_1')", matcher.mocha_inspect
+    assert_equal "has_entry(:key_1 => 'value_1')", matcher.mocha_inspect
   end
   
   def test_should_describe_matcher_with_entry
     matcher = has_entry(:key_1 => 'value_1')
-    assert_equal "has_entry(:key_1, 'value_1')", matcher.mocha_inspect
+    assert_equal "has_entry(:key_1 => 'value_1')", matcher.mocha_inspect
+  end
+  
+  def test_should_match_hash_including_specified_entry_with_nested_key_matcher
+    matcher = has_entry(equals(:key_1) => 'value_1')
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_match_hash_including_specified_entry_with_nested_value_matcher
+    matcher = has_entry(:key_1 => equals('value_1'))
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_entry_with_nested_key_matcher
+    matcher = has_entry(equals(:key_1) => 'value_2')
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_entry_with_nested_value_matcher
+    matcher = has_entry(:key_1 => equals('value_2'))
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
   
 end

data/test/unit/parameter_matchers/has_key_test.rb

@@ -1,6 +1,7 @@
 require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
 
 require 'mocha/parameter_matchers/has_key'
+require 'mocha/parameter_matchers/object'
 require 'mocha/inspect'
 
 class HasKeyTest < Test::Unit::TestCase
@@ -22,4 +23,14 @@ class HasKeyTest < Test::Unit::TestCase
     assert_equal 'has_key(:key)', matcher.mocha_inspect
   end
   
+  def test_should_match_hash_including_specified_key_with_nested_key_matcher
+    matcher = has_key(equals(:key_1))
+    assert matcher.matches?([{ :key_1 => 1, :key_2 => 2 }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_key_with_nested_key_matcher
+    matcher = has_key(equals(:key_1))
+    assert !matcher.matches?([{ :key_2 => 2 }])
+  end
+  
 end

data/test/unit/parameter_matchers/has_value_test.rb

@@ -1,6 +1,8 @@
 require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
 
 require 'mocha/parameter_matchers/has_value'
+require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class HasValueTest < Test::Unit::TestCase
@@ -22,4 +24,14 @@ class HasValueTest < Test::Unit::TestCase
     assert_equal "has_value('value_1')", matcher.mocha_inspect
   end
   
+  def test_should_match_hash_including_specified_value_with_nested_value_matcher
+    matcher = has_value(equals('value_1'))
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_value_with_nested_value_matcher
+    matcher = has_value(equals('value_1'))
+    assert !matcher.matches?([{ :key_2 => 'value_2' }])
+  end
+  
 end

data/test/unit/parameter_matchers/regexp_matches_test.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
 require 'mocha/parameter_matchers/regexp_matches'
 require 'mocha/inspect'
 
-class MatchesTest < Test::Unit::TestCase
+class RegexpMatchesTest < Test::Unit::TestCase
   
   include Mocha::ParameterMatchers
   

data/test/unit/parameter_matchers/responds_with_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/responds_with'
+require 'mocha/inspect'
+
+class RespondsWithTest < Test::Unit::TestCase
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_parameter_responding_with_expected_value
+    matcher = responds_with(:upcase, 'FOO')
+    assert matcher.matches?(['foo'])
+  end
+  
+  def test_should_not_match_parameter_responding_with_unexpected_value
+    matcher = responds_with(:upcase, 'FOO')
+    assert !matcher.matches?(['bar'])
+  end
+  
+  def test_should_describe_matcher
+    matcher = responds_with(:foo, :bar)
+    assert_equal 'responds_with(:foo, :bar)', matcher.mocha_inspect
+  end
+  
+end

data/test/unit/parameter_matchers/stub_matcher.rb

@@ -17,6 +17,10 @@ module Stub
     def mocha_inspect
       "matcher(#{@matches})"
     end
+    
+    def to_matcher
+      self
+    end
 
   end
   

data/test/unit/parameter_matchers/yaml_equivalent_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/yaml_equivalent'
+require 'mocha/inspect'
+
+class YamlEquivalentTest < Test::Unit::TestCase
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_parameter_matching_yaml_representation_of_object
+    matcher = yaml_equivalent([1, 2, 3])
+    assert matcher.matches?(["--- \n- 1\n- 2\n- 3\n"])
+  end
+  
+  def test_should_not_match_parameter_matching_yaml_representation_of_object
+    matcher = yaml_equivalent([1, 2, 3])
+    assert !matcher.matches?(["--- \n- 4\n- 5\n"])
+  end
+  
+  def test_should_describe_matcher
+    matcher = yaml_equivalent([1, 2, 3])
+    assert_equal "yaml_equivalent([1, 2, 3])", matcher.mocha_inspect
+  end
+  
+end

data/test/unit/single_return_value_test.rb

@@ -1,33 +1,14 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 
 require 'mocha/single_return_value'
-require 'deprecation_disabler'
 
 class SingleReturnValueTest < Test::Unit::TestCase
   
   include Mocha
-  include DeprecationDisabler
   
   def test_should_return_value
     value = SingleReturnValue.new('value')
     assert_equal 'value', value.evaluate
   end
   
-  def test_should_return_result_of_calling_proc
-    proc = lambda { 'value' }
-    value = SingleReturnValue.new(proc)
-    result = nil
-    disable_deprecations { result = value.evaluate }
-    assert_equal 'value', result
-  end
-  
-  def test_should_indicate_deprecated_use_of_expectation_returns_method
-    proc = lambda {}
-    value = SingleReturnValue.new(proc)
-    Deprecation.messages = []
-    disable_deprecations { value.evaluate }
-    expected_message = "use of Expectation#returns with instance of Proc - see Expectation#returns RDoc for alternatives"
-    assert_equal [expected_message], Deprecation.messages
-  end
-  
 end

data/test/unit/state_machine_test.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/state_machine'
+
+class StateMachineTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_initially_be_in_no_state
+    state_machine = StateMachine.new('name')
+    any_state.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_be_able_to_enter_a_state
+    state_machine = StateMachine.new('name')
+    state = 'A'
+    other_states = any_state.reject { |s| s == state }
+    
+    state_machine.is(state).activate
+    
+    assert state_machine.is(state).active?
+    assert !state_machine.is_not(state).active?
+    other_states.each do |s|
+      assert !state_machine.is(s).active?
+      assert state_machine.is_not(s).active?
+    end
+  end
+  
+  def test_should_be_able_to_change_state
+    state_machine = StateMachine.new('name')
+    state = 'B'
+    other_states = any_state.reject { |s| s == state }
+    
+    state_machine.is('A').activate
+    state_machine.is(state).activate
+    
+    assert state_machine.is(state).active?
+    assert !state_machine.is_not(state).active?
+    other_states.each do |s|
+      assert !state_machine.is(s).active?
+      assert state_machine.is_not(s).active?
+    end
+  end
+  
+  def test_should_be_put_into_an_initial_state
+    state_machine = StateMachine.new('name')
+    initial_state = 'A'
+    other_states = any_state.reject { |s| s == initial_state }
+    
+    state_machine.starts_as(initial_state)
+    
+    assert state_machine.is(initial_state).active?
+    assert !state_machine.is_not(initial_state).active?
+    other_states.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_be_put_into_a_new_state
+    next_state = 'B'
+    
+    other_states = any_state.reject { |s| s == next_state }
+    state_machine = StateMachine.new('name').starts_as('A')
+    
+    state_machine.become(next_state)
+    
+    assert state_machine.is(next_state).active?
+    assert !state_machine.is_not(next_state).active?
+    other_states.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_describe_itself_as_name_and_current_state
+    state_machine = StateMachine.new('state_machine_name')
+    assert_equal 'state_machine_name has no current state', state_machine.mocha_inspect
+    inspectable_state = Class.new { define_method(:mocha_inspect) { "'inspectable_state'" } }.new
+    state_machine.is(inspectable_state).activate
+    assert_equal "state_machine_name is 'inspectable_state'", state_machine.mocha_inspect
+  end
+  
+  def test_should_have_self_describing_states
+    state_machine = StateMachine.new('state_machine_name')
+    inspectable_state = Class.new { define_method(:mocha_inspect) { "'inspectable_state'" } }.new
+    assert_equal "state_machine_name is 'inspectable_state'", state_machine.is(inspectable_state).mocha_inspect
+    assert_equal "state_machine_name is not 'inspectable_state'", state_machine.is_not(inspectable_state).mocha_inspect
+  end
+  
+  def any_state
+    %w(A B C D)
+  end
+  
+end