cache_method 0.2.3 → 0.2.4

data/test/test_cache_method.rb

@@ -2,415 +2,416 @@ require 'helper'
 
 require 'dalli'
 
-class TestCacheMethod < Test::Unit::TestCase
-  def setup
+describe CacheMethod do
+  before do
     Blog2.request_count = 0
     CopyCat2.echo_count = 0
     CopyCat1.say_count = 0
     CopyCat2.say_count = 0
+    BlogM.request_count = 0
     my_cache = Dalli::Client.new '127.0.0.1:11211'
     my_cache.flush
     CacheMethod.config.storage = my_cache
     CacheMethod.config.generational = true
   end
 
-  def test_cache_instance_method_with_args
+  it %{cache_instance_method_with_args} do
     a = CopyCat1.new 'mimo'
 
     if RUBY_VERSION >= '1.9'
-      assert_equal ['hi'], a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal ['hi']
+      a.echo_count.must_equal 1
 
-      assert_equal ['hi'], a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal ['hi']
+      a.echo_count.must_equal 1
     else
-      assert_equal 'hi', a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal 'hi'
+      a.echo_count.must_equal 1
 
-      assert_equal 'hi', a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal 'hi'
+      a.echo_count.must_equal 1
     end
   end
 
-  def test_cache_instance_method_with_nil_args
+  it %{cache_instance_method_with_nil_args} do
     a = CopyCat1.new 'mimo'
 
     if RUBY_VERSION >= '1.9'
-      assert_equal [], a.echo
-      assert_equal 1, a.echo_count
+      a.echo.must_equal []
+      a.echo_count.must_equal 1
 
-      assert_equal [], a.echo
-      assert_equal 1, a.echo_count
+      a.echo.must_equal []
+      a.echo_count.must_equal 1
 
-      assert_equal [nil], a.echo(nil)
-      assert_equal 2, a.echo_count
+      a.echo(nil).must_equal [nil]
+      a.echo_count.must_equal 2
 
-      assert_equal [nil], a.echo(nil)
-      assert_equal 2, a.echo_count
+      a.echo(nil).must_equal [nil]
+      a.echo_count.must_equal 2
     else
-      assert_equal nil, a.echo
-      assert_equal 1, a.echo_count
+      a.echo.must_equal nil
+      a.echo_count.must_equal 1
 
-      assert_equal nil, a.echo
-      assert_equal 1, a.echo_count
+      a.echo.must_equal nil
+      a.echo_count.must_equal 1
 
-      assert_equal nil, a.echo(nil)
-      assert_equal 2, a.echo_count
+      a.echo(nil).must_equal nil
+      a.echo_count.must_equal 2
 
-      assert_equal nil, a.echo(nil)
-      assert_equal 2, a.echo_count
+      a.echo(nil).must_equal nil
+      a.echo_count.must_equal 2
     end
   end
 
-  def test_cache_instance_method_with_array_args
+  it %{cache_instance_method_with_array_args} do
     a = CopyCat1.new 'mimo'
 
     if RUBY_VERSION >= '1.9'
-      assert_equal [['hi']], a.echo(['hi'])
-      assert_equal 1, a.echo_count
+      a.echo(['hi']).must_equal [['hi']]
+      a.echo_count.must_equal 1
 
-      assert_equal [['hi']], a.echo(['hi'])
-      assert_equal 1, a.echo_count
+      a.echo(['hi']).must_equal [['hi']]
+      a.echo_count.must_equal 1
 
-      assert_equal [['bye']], a.echo(['bye'])
-      assert_equal 2, a.echo_count
+      a.echo(['bye']).must_equal [['bye']]
+      a.echo_count.must_equal 2
 
-      assert_equal [['bye']], a.echo(['bye'])
-      assert_equal 2, a.echo_count
+      a.echo(['bye']).must_equal [['bye']]
+      a.echo_count.must_equal 2
 
-      assert_equal [[]], a.echo([])
-      assert_equal 3, a.echo_count
+      a.echo([]).must_equal [[]]
+      a.echo_count.must_equal 3
 
-      assert_equal [[]], a.echo([])
-      assert_equal 3, a.echo_count
+      a.echo([]).must_equal [[]]
+      a.echo_count.must_equal 3
     else
-      assert_equal ['hi'], a.echo(['hi'])
-      assert_equal 1, a.echo_count
+      a.echo(['hi']).must_equal ['hi']
+      a.echo_count.must_equal 1
 
-      assert_equal ['hi'], a.echo(['hi'])
-      assert_equal 1, a.echo_count
+      a.echo(['hi']).must_equal ['hi']
+      a.echo_count.must_equal 1
 
-      assert_equal ['bye'], a.echo(['bye'])
-      assert_equal 2, a.echo_count
+      a.echo(['bye']).must_equal ['bye']
+      a.echo_count.must_equal 2
 
-      assert_equal ['bye'], a.echo(['bye'])
-      assert_equal 2, a.echo_count
+      a.echo(['bye']).must_equal ['bye']
+      a.echo_count.must_equal 2
 
-      assert_equal [], a.echo([])
-      assert_equal 3, a.echo_count
+      a.echo([]).must_equal []
+      a.echo_count.must_equal 3
 
-      assert_equal [], a.echo([])
-      assert_equal 3, a.echo_count
+      a.echo([]).must_equal []
+      a.echo_count.must_equal 3
     end
   end
 
-  def test_cache_instance_method_with_array_args_splat
+  it %{cache_instance_method_with_array_args_splat} do
     a = CopyCat1.new 'mimo'
 
     if RUBY_VERSION >= '1.9'
-      assert_equal [['hi', 'there']], a.echo(['hi', 'there'])
-      assert_equal 1, a.echo_count
+      a.echo(['hi', 'there']).must_equal [['hi', 'there']]
+      a.echo_count.must_equal 1
 
-      assert_equal ['hi', 'there'], a.echo('hi', 'there')
-      assert_equal 2, a.echo_count
+      a.echo('hi', 'there').must_equal ['hi', 'there']
+      a.echo_count.must_equal 2
     else
-      assert_equal ['hi', 'there'], a.echo(['hi', 'there'])
-      assert_equal 1, a.echo_count
+      a.echo(['hi', 'there']).must_equal ['hi', 'there']
+      a.echo_count.must_equal 1
 
-      assert_equal ['hi', 'there'], a.echo('hi', 'there')
-      assert_equal 2, a.echo_count
+      a.echo('hi', 'there').must_equal ['hi', 'there']
+      a.echo_count.must_equal 2
     end
   end
 
-  def test_cache_class_method_with_args
-    assert_equal 'hi', CopyCat2.echo('hi')
-    assert_equal 1, CopyCat2.echo_count
+  it %{cache_class_method_with_args} do
+    CopyCat2.echo('hi').must_equal 'hi'
+    CopyCat2.echo_count.must_equal 1
 
-    assert_equal 'hi', CopyCat2.echo('hi')
-    assert_equal 1, CopyCat2.echo_count
+    CopyCat2.echo('hi').must_equal 'hi'
+    CopyCat2.echo_count.must_equal 1
   end
 
-  def test_cache_class_method_with_nil_args
-    assert_equal nil, CopyCat2.echo
-    assert_equal 1, CopyCat2.echo_count
+  it %{cache_class_method_with_nil_args} do
+    CopyCat2.echo.must_equal nil
+    CopyCat2.echo_count.must_equal 1
 
-    assert_equal nil, CopyCat2.echo
-    assert_equal 1, CopyCat2.echo_count
+    CopyCat2.echo.must_equal nil
+    CopyCat2.echo_count.must_equal 1
 
-    assert_equal nil, CopyCat2.echo(nil)
-    assert_equal 2, CopyCat2.echo_count
+    CopyCat2.echo(nil).must_equal nil
+    CopyCat2.echo_count.must_equal 2
 
-    assert_equal nil, CopyCat2.echo(nil)
-    assert_equal 2, CopyCat2.echo_count
+    CopyCat2.echo(nil).must_equal nil
+    CopyCat2.echo_count.must_equal 2
   end
 
-  def test_cache_class_method_with_array_args
-    assert_equal ['hi'], CopyCat2.echo(['hi'])
-    assert_equal 1, CopyCat2.echo_count
+  it %{cache_class_method_with_array_args} do
+    CopyCat2.echo(['hi']).must_equal ['hi']
+    CopyCat2.echo_count.must_equal 1
 
-    assert_equal ['hi'], CopyCat2.echo(['hi'])
-    assert_equal 1, CopyCat2.echo_count
+    CopyCat2.echo(['hi']).must_equal ['hi']
+    CopyCat2.echo_count.must_equal 1
 
-    assert_equal ['bye'], CopyCat2.echo(['bye'])
-    assert_equal 2, CopyCat2.echo_count
+    CopyCat2.echo(['bye']).must_equal ['bye']
+    CopyCat2.echo_count.must_equal 2
 
-    assert_equal ['bye'], CopyCat2.echo(['bye'])
-    assert_equal 2, CopyCat2.echo_count
+    CopyCat2.echo(['bye']).must_equal ['bye']
+    CopyCat2.echo_count.must_equal 2
 
-    assert_equal [], CopyCat2.echo([])
-    assert_equal 3, CopyCat2.echo_count
+    CopyCat2.echo([]).must_equal []
+    CopyCat2.echo_count.must_equal 3
 
-    assert_equal [], CopyCat2.echo([])
-    assert_equal 3, CopyCat2.echo_count
+    CopyCat2.echo([]).must_equal []
+    CopyCat2.echo_count.must_equal 3
   end
 
-  def test_cache_class_method_with_array_args_splat
+  it %{cache_class_method_with_array_args_splat} do
     if RUBY_VERSION >= '1.9'
-      assert_equal ['hi', 'there'], CopyCat2.echo(['hi', 'there'])
-      assert_equal 1, CopyCat2.echo_count
+      CopyCat2.echo(['hi', 'there']).must_equal ['hi', 'there']
+      CopyCat2.echo_count.must_equal 1
 
-      assert_equal ['hi', 'there'], CopyCat2.echo('hi', 'there')
-      assert_equal 2, CopyCat2.echo_count
+      CopyCat2.echo('hi', 'there').must_equal ['hi', 'there']
+      CopyCat2.echo_count.must_equal 2
     else
-      assert_equal ['hi', 'there'], CopyCat2.echo(['hi', 'there'])
-      assert_equal 1, CopyCat2.echo_count
+      CopyCat2.echo(['hi', 'there']).must_equal ['hi', 'there']
+      CopyCat2.echo_count.must_equal 1
 
-      assert_equal ['hi', 'there'], CopyCat2.echo('hi', 'there')
-      assert_equal 2, CopyCat2.echo_count
+      CopyCat2.echo('hi', 'there').must_equal ['hi', 'there']
+      CopyCat2.echo_count.must_equal 2
     end
   end
 
-  def test_cache_instance_method
+  it %{cache_instance_method} do
     a = new_instance_of_my_blog
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 1, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 1
     a = new_instance_of_my_blog
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 0, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 0
     xxx = new_instance_of_another_blog
-    assert_equal ["hello from #{xxx.name}"], xxx.get_latest_entries
-    assert_equal 1, xxx.request_count
+    xxx.get_latest_entries.must_equal ["hello from #{xxx.name}"]
+    xxx.request_count.must_equal 1
   end
 
-  def test_clear_instance_method
+  it %{clear_instance_method} do
     a = new_instance_of_my_blog
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 1, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 1
     a.cache_method_clear :get_latest_entries
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 2, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 2
   end
 
-  def test_clear_correct_instance_method
+  it %{clear_correct_instance_method} do
     a = new_instance_of_my_blog
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 1, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 1
     a.cache_method_clear :foobar
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 1, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 1
   end
 
-  def test_clear_instance_method_from_correct_instance
+  it %{clear_instance_method_from_correct_instance} do
     a = new_instance_of_my_blog
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 1, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 1
     xxx = new_instance_of_another_blog
-    assert_equal ["hello from #{xxx.name}"], xxx.get_latest_entries
-    assert_equal 1, xxx.request_count
+    xxx.get_latest_entries.must_equal ["hello from #{xxx.name}"]
+    xxx.request_count.must_equal 1
     xxx.cache_method_clear :get_latest_entries
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 1, a.request_count
-    assert_equal ["hello from #{xxx.name}"], xxx.get_latest_entries
-    assert_equal 2, xxx.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 1
+    xxx.get_latest_entries.must_equal ["hello from #{xxx.name}"]
+    xxx.request_count.must_equal 2
   end
 
-  def test_cache_instance_method_ttl
+  it %{cache_instance_method_ttl} do
     a = new_instance_of_my_blog
-    assert_equal ["voo vaa #{a.name}"], a.get_latest_entries2
-    assert_equal 1, a.request_count
+    a.get_latest_entries2.must_equal ["voo vaa #{a.name}"]
+    a.request_count.must_equal 1
     sleep 2
-    assert_equal ["voo vaa #{a.name}"], a.get_latest_entries2
-    assert_equal 2, a.request_count
+    a.get_latest_entries2.must_equal ["voo vaa #{a.name}"]
+    a.request_count.must_equal 2
   end
 
-  def test_cache_class_method
-    assert_equal 0, Blog2.request_count
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
+  it %{cache_class_method} do
+    Blog2.request_count.must_equal 0
+    Blog2.get_latest_entries.must_equal 'danke schoen'
+    Blog2.request_count.must_equal 1
+    Blog2.get_latest_entries.must_equal 'danke schoen'
+    Blog2.request_count.must_equal 1
   end
 
-  def test_clear_class_method
-    assert_equal 0, Blog2.request_count
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
+  it %{clear_class_method} do
+    Blog2.request_count.must_equal 0
+    Blog2.get_latest_entries.must_equal 'danke schoen'
+    Blog2.request_count.must_equal 1
     Blog2.cache_method_clear :get_latest_entries
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 2, Blog2.request_count
+    Blog2.get_latest_entries.must_equal 'danke schoen'
+    Blog2.request_count.must_equal 2
   end
 
-  def test_clear_correct_class_method
-    assert_equal 0, Blog2.request_count
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
+  it %{clear_correct_class_method} do
+    Blog2.request_count.must_equal 0
+    Blog2.get_latest_entries.must_equal 'danke schoen'
+    Blog2.request_count.must_equal 1
 
     Blog2.cache_method_clear :foobar
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 1, Blog2.request_count
+    Blog2.get_latest_entries.must_equal 'danke schoen'
+    Blog2.request_count.must_equal 1
 
     Blog2.cache_method_clear :get_latest_entries
-    assert_equal 'danke schoen', Blog2.get_latest_entries
-    assert_equal 2, Blog2.request_count
+    Blog2.get_latest_entries.must_equal 'danke schoen'
+    Blog2.request_count.must_equal 2
   end
 
-  def test_never_set_storage
+  it %{never_set_storage} do
     CacheMethod.config.instance_variable_set :@storage, nil
     a = CopyCat1.new 'mimo'
 
     if RUBY_VERSION >= '1.9'
-      assert_equal ['hi'], a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal ['hi']
+      a.echo_count.must_equal 1
 
-      assert_equal ['hi'], a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal ['hi']
+      a.echo_count.must_equal 1
     else
-      assert_equal 'hi', a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal 'hi'
+      a.echo_count.must_equal 1
 
-      assert_equal 'hi', a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal 'hi'
+      a.echo_count.must_equal 1
     end
   end
 
-  def test_set_storage_to_nil
+  it %{set_storage_to_nil} do
     CacheMethod.config.storage = nil
     a = CopyCat1.new 'mimo'
 
     if RUBY_VERSION >= '1.9'
-      assert_equal ['hi'], a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal ['hi']
+      a.echo_count.must_equal 1
 
-      assert_equal ['hi'], a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal ['hi']
+      a.echo_count.must_equal 1
     else
-      assert_equal 'hi', a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal 'hi'
+      a.echo_count.must_equal 1
 
-      assert_equal 'hi', a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal 'hi'
+      a.echo_count.must_equal 1
     end
   end
 
-  def test_cache_module_method
-    assert_equal 0, BlogM.request_count
-    assert_equal 'danke schoen', BlogM.get_latest_entries
-    assert_equal 1, BlogM.request_count
-    assert_equal 'danke schoen', BlogM.get_latest_entries
-    assert_equal 1, BlogM.request_count
+  it %{cache_module_method} do
+    BlogM.request_count.must_equal 0
+    BlogM.get_latest_entries.must_equal 'danke schoen'
+    BlogM.request_count.must_equal 1
+    BlogM.get_latest_entries.must_equal 'danke schoen'
+    BlogM.request_count.must_equal 1
   end
 
-  def test_as_cache_key
-    assert_raises(RuntimeError, /Used as_cache_key/) do
+  it %{as_cache_key} do
+    lambda do
       a = CopyCat1a.new 'mimo'
       a.echo 'hi'
-    end
+    end.must_raise(RuntimeError, /Used as_cache_key/)
   end
 
-  def test_to_cache_key
-    assert_raises(RuntimeError, /Used to_cache_key/) do
+  it %{to_cache_key} do
+    lambda do
       a = CopyCat1b.new 'mimo'
       a.echo 'hi'
-    end
+    end.must_raise(RuntimeError, /Used to_cache_key/)
   end
 
-  def test_method_added_by_extension
-    assert_equal 'hi', CopyCat2.say('hi')
-    assert_equal 1, CopyCat2.say_count
+  it %{method_added_by_extension} do
+    CopyCat2.say('hi').must_equal 'hi'
+    CopyCat2.say_count.must_equal 1
 
-    assert_equal 'hi', CopyCat2.say('hi')
-    assert_equal 1, CopyCat2.say_count
+    CopyCat2.say('hi').must_equal 'hi'
+    CopyCat2.say_count.must_equal 1
   end
 
-  def test_method_added_by_inclusion
+  it %{method_added_by_inclusion} do
     a = CopyCat1.new 'sayer'
 
-    assert_equal 'hi', a.say('hi')
-    assert_equal 1, a.say_count
+    a.say('hi').must_equal 'hi'
+    a.say_count.must_equal 1
 
-    assert_equal 'hi', a.say('hi')
-    assert_equal 1, a.say_count
+    a.say('hi').must_equal 'hi'
+    a.say_count.must_equal 1
   end
 
-  def test_not_confused_by_module
-    assert_equal 'hi', CopyCat2.say('hi')
-    assert_equal 1, CopyCat2.say_count
+  it %{not_confused_by_module} do
+    CopyCat2.say('hi').must_equal 'hi'
+    CopyCat2.say_count.must_equal 1
 
-    assert_equal 'hi', CopyCat2.say('hi')
-    assert_equal 1, CopyCat2.say_count
+    CopyCat2.say('hi').must_equal 'hi'
+    CopyCat2.say_count.must_equal 1
 
-    assert_equal 'hi', CopyCat1.say('hi')
-    assert_equal 1, CopyCat1.say_count
+    CopyCat1.say('hi').must_equal 'hi'
+    CopyCat1.say_count.must_equal 1
 
-    assert_equal 'hi', CopyCat1.say('hi')
-    assert_equal 1, CopyCat1.say_count
+    CopyCat1.say('hi').must_equal 'hi'
+    CopyCat1.say_count.must_equal 1
   end
 
-  def test_disable_generational_caching
+  it %{disable_generational_caching} do
     CacheMethod.config.generational = false
 
     a = CopyCat1.new 'mimo'
 
     if RUBY_VERSION >= '1.9'
-      assert_equal ['hi'], a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal ['hi']
+      a.echo_count.must_equal 1
 
-      assert_equal ['hi'], a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal ['hi']
+      a.echo_count.must_equal 1
     else
-      assert_equal 'hi', a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal 'hi'
+      a.echo_count.must_equal 1
 
-      assert_equal 'hi', a.echo('hi')
-      assert_equal 1, a.echo_count
+      a.echo('hi').must_equal 'hi'
+      a.echo_count.must_equal 1
     end
   end
 
-  def test_cant_cache_method_clear_without_generational_caching
+  it %{cant_cache_method_clear_without_generational_caching} do
     CacheMethod.config.generational = false
 
     a = new_instance_of_my_blog
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 1, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 1
 
     assert_raises(::RuntimeError) do
       a.cache_method_clear :get_latest_entries
     end
 
-    assert_equal ["hello from #{a.name}"], a.get_latest_entries
-    assert_equal 1, a.request_count
+    a.get_latest_entries.must_equal ["hello from #{a.name}"]
+    a.request_count.must_equal 1
   end
 
-  def test_doesnt_rely_on_to_s_for_args_digest
+  it %{doesnt_rely_on_to_s_for_args_digest} do
     hello = DontStringifyMe.new("hello")
     world = DontStringifyMe.new("world")
 
     a = CopyCat1.new 'mimo'
 
     a.echo(hello)
-    assert_equal 1, a.echo_count
+    a.echo_count.must_equal 1
 
     a.echo(hello)
-    assert_equal 1, a.echo_count
+    a.echo_count.must_equal 1
 
     a.echo(world)
-    assert_equal 2, a.echo_count
+    a.echo_count.must_equal 2
 
     a.echo(world)
-    assert_equal 2, a.echo_count
+    a.echo_count.must_equal 2
   end
 
-  def test_doesnt_marshal_if_as_cache_key_defined
+  it %{doesnt_marshal_if_as_cache_key_defined} do
     hello = DontMarshalMe.new("hello")
     world = DontMarshalMe.new("world")
 
@@ -436,47 +437,46 @@ class TestCacheMethod < Test::Unit::TestCase
       ack_count += 1
       5.times do
         a.ack(nasty)
-        assert_equal ack_count, a.ack_count
-
+        a.ack_count.must_equal ack_count
         a.ack(nasty)
-        assert_equal ack_count, a.ack_count
+        a.ack_count.must_equal ack_count
       end
     end
   end
 
-  def test_cached_query
+  it %{cached_query} do
     a = CopyCat1.new 'mimo'
-    assert !a.cache_method_cached?(:echo, 'hi')
-    assert !a.cache_method_cached?(:echo, 'there')
+    a.cache_method_cached?(:echo, 'hi').must_equal false
+    a.cache_method_cached?(:echo, 'there').must_equal false
     a.echo('hi')
-    assert a.cache_method_cached?(:echo, 'hi')
-    assert !a.cache_method_cached?(:echo, 'there')
+    a.cache_method_cached?(:echo, 'hi').must_equal true
+    a.cache_method_cached?(:echo, 'there').must_equal false
 
-    assert !BlogM.cache_method_cached?(:get_latest_entries)
-    assert !BlogM.cache_method_cached?(:get_latest_entries, 'there')
+    BlogM.cache_method_cached?(:get_latest_entries).must_equal false
+    BlogM.cache_method_cached?(:get_latest_entries, 'there').must_equal false
     BlogM.get_latest_entries
-    assert BlogM.cache_method_cached?(:get_latest_entries)
-    assert !BlogM.cache_method_cached?(:get_latest_entries, 'there')
+    BlogM.cache_method_cached?(:get_latest_entries).must_equal true
+    BlogM.cache_method_cached?(:get_latest_entries, 'there').must_equal false
   end
 
-  def test_class_name_automatically_appended_to_cache_key
+  it %{class_name_automatically_appended_to_cache_key} do
     jek = DrJekyll.new
     hyde = MrHyde.new
 
-    assert_equal jek.as_cache_key, hyde.as_cache_key
+    hyde.as_cache_key.must_equal jek.as_cache_key
 
     a = CopyCat1.new 'mimo'
 
     a.ack(jek)
-    assert_equal 1, a.ack_count
+    a.ack_count.must_equal 1
 
     a.ack(hyde)
-    assert_equal 2, a.ack_count
+    a.ack_count.must_equal 2
 
     a.ack(jek)
-    assert_equal 2, a.ack_count
+    a.ack_count.must_equal 2
 
     a.ack(hyde)
-    assert_equal 2, a.ack_count
+    a.ack_count.must_equal 2
   end
 end