jferris-mocha 0.9.5.0.1240002286

data/test/unit/object_test.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+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
+  
+end

data/test/unit/parameter_matchers/all_of_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/all_of'
+require 'mocha/inspect'
+require 'stub_matcher'
+
+class AllOfTest < Test::Unit::TestCase
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_if_all_matchers_match
+    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(true), Stub::Matcher.new(true))
+    assert matcher.matches?(['any_old_value'])
+  end
+  
+  def test_should_not_match_if_any_matcher_does_not_match
+    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
+    assert !matcher.matches?(['any_old_value'])
+  end
+  
+  def test_should_describe_matcher
+    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
+    assert_equal 'all_of(matcher(true), matcher(false), matcher(true))', matcher.mocha_inspect
+  end
+  
+end

data/test/unit/parameter_matchers/any_of_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/any_of'
+require 'mocha/inspect'
+require 'stub_matcher'
+
+class AnyOfTest < Test::Unit::TestCase
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_if_any_matchers_match
+    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
+    assert matcher.matches?(['any_old_value'])
+  end
+  
+  def test_should_not_match_if_no_matchers_match
+    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(false), Stub::Matcher.new(false))
+    assert !matcher.matches?(['any_old_value'])
+  end
+  
+  def test_should_describe_matcher
+    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
+    assert_equal 'any_of(matcher(false), matcher(true), matcher(false))', matcher.mocha_inspect
+  end
+  
+end

data/test/unit/parameter_matchers/anything_test.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/anything'
+require 'mocha/inspect'
+
+class AnythingTest < Test::Unit::TestCase
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_anything
+    matcher = anything
+    assert matcher.matches?([:something])
+    assert matcher.matches?([{'x' => 'y'}])
+  end
+  
+  def test_should_describe_matcher
+    matcher = anything
+    assert_equal "anything", matcher.mocha_inspect
+  end
+  
+end

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

@@ -0,0 +1,51 @@
+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
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_hash_including_specified_entries
+    matcher = has_entries(:key_1 => 'value_1', :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
+    matcher = has_entries(:key_1 => 'value_2', :key_2 => 'value_2', :key_3 => 'value_3')
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_describe_matcher
+    matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
+    description = matcher.mocha_inspect
+    matches = /has_entries\((.*)\)/.match(description)
+    assert_not_nil matches[0]
+    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

@@ -0,0 +1,82 @@
+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
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_hash_including_specified_key_value_pair
+    matcher = has_entry(:key_1, 'value_1')
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_key_value_pair
+    matcher = has_entry(:key_1, 'value_2')
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_match_hash_including_specified_entry
+    matcher = has_entry(:key_1 => 'value_1')
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_entry
+    matcher = has_entry(:key_1 => 'value_2')
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  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
+  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
+  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
+  
+  def test_should_not_match_object_that_doesnt_respond_to_keys
+    matcher = has_entry(:key_1 => equals('value_2'))
+    object = Class.new do
+      def [](key)
+        'value_2'
+      end
+    end.new
+    assert !matcher.matches?([object])
+  end
+  
+  def test_should_not_match_object_that_doesnt_respond_to_square_bracket
+    matcher = has_entry(:key_1 => equals('value_2'))
+    object = Class.new do
+      def keys
+        [:key_1]
+      end
+    end.new
+    assert !matcher.matches?([object])
+  end
+  
+end

data/test/unit/parameter_matchers/has_key_test.rb

@@ -0,0 +1,36 @@
+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
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_hash_including_specified_key
+    matcher = has_key(:key_1)
+    assert matcher.matches?([{ :key_1 => 1, :key_2 => 2 }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_key
+    matcher = has_key(:key_1)
+    assert !matcher.matches?([{ :key_2 => 2 }])
+  end
+  
+  def test_should_describe_matcher
+    matcher = has_key(:key)
+    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

@@ -0,0 +1,37 @@
+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
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_hash_including_specified_value
+    matcher = has_value('value_1')
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_value
+    matcher = has_value('value_1')
+    assert !matcher.matches?([{ :key_2 => 'value_2' }])
+  end
+  
+  def test_should_describe_matcher
+    matcher = has_value('value_1')
+    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/includes_test.rb

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

data/test/unit/parameter_matchers/instance_of_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/instance_of'
+require 'mocha/inspect'
+
+class InstanceOfTest < Test::Unit::TestCase
+
+  include Mocha::ParameterMatchers
+
+  def test_should_match_object_that_is_an_instance_of_specified_class
+    matcher = instance_of(String)
+    assert matcher.matches?(['string'])
+  end
+
+  def test_should_not_match_object_that_is_not_an_instance_of_specified_class
+    matcher = instance_of(String)
+    assert !matcher.matches?([99])
+  end
+
+  def test_should_describe_matcher
+    matcher = instance_of(String)
+    assert_equal "instance_of(String)", matcher.mocha_inspect
+  end
+
+end

data/test/unit/parameter_matchers/is_a_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/is_a'
+require 'mocha/inspect'
+
+class IsATest < Test::Unit::TestCase
+
+  include Mocha::ParameterMatchers
+
+  def test_should_match_object_that_is_a_specified_class
+    matcher = is_a(Integer)
+    assert matcher.matches?([99])
+  end
+
+  def test_should_not_match_object_that_is_not_a_specified_class
+    matcher = is_a(Integer)
+    assert !matcher.matches?(['string'])
+  end
+
+  def test_should_describe_matcher
+    matcher = is_a(Integer)
+    assert_equal "is_a(Integer)", matcher.mocha_inspect
+  end
+
+end

data/test/unit/parameter_matchers/kind_of_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/kind_of'
+require 'mocha/inspect'
+
+class KindOfTest < Test::Unit::TestCase
+
+  include Mocha::ParameterMatchers
+
+  def test_should_match_object_that_is_a_kind_of_specified_class
+    matcher = kind_of(Integer)
+    assert matcher.matches?([99])
+  end
+
+  def test_should_not_match_object_that_is_not_a_kind_of_specified_class
+    matcher = kind_of(Integer)
+    assert !matcher.matches?(['string'])
+  end
+
+  def test_should_describe_matcher
+    matcher = kind_of(Integer)
+    assert_equal "kind_of(Integer)", matcher.mocha_inspect
+  end
+
+end

data/test/unit/parameter_matchers/not_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/not'
+require 'mocha/inspect'
+require 'stub_matcher'
+
+class NotTest < Test::Unit::TestCase
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_if_matcher_does_not_match
+    matcher = Not(Stub::Matcher.new(false))
+    assert matcher.matches?(['any_old_value'])
+  end
+  
+  def test_should_not_match_if_matcher_does_match
+    matcher = Not(Stub::Matcher.new(true))
+    assert !matcher.matches?(['any_old_value'])
+  end
+  
+  def test_should_describe_matcher
+    matcher = Not(Stub::Matcher.new(true))
+    assert_equal 'Not(matcher(true))', matcher.mocha_inspect
+  end
+  
+end

data/test/unit/parameter_matchers/regexp_matches_test.rb

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

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

@@ -0,0 +1,27 @@
+module Stub
+  
+  class Matcher
+
+    attr_accessor :value
+
+    def initialize(matches)
+      @matches = matches
+    end
+
+    def matches?(available_parameters)
+      value = available_parameters.shift
+      @value = value
+      @matches
+    end
+
+    def mocha_inspect
+      "matcher(#{@matches})"
+    end
+    
+    def to_matcher
+      self
+    end
+
+  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