File remove_nose.patch of Package python-fudge

Overview Repositories Revisions Requests Users Attributes Meta

File remove_nose.patch of Package python-fudge (Revision aa524bd930495dcfce475bfc4b0fd7dc)

Currently displaying revision aa524bd930495dcfce475bfc4b0fd7dc , Show latest

--- a/fudge/tests/test_fudge.py
+++ b/fudge/tests/test_fudge.py
@@ -2,9 +2,6 @@ from __future__ import with_statement
 import sys
 import unittest
 
-from nose.tools import eq_, raises
-from nose.exc import SkipTest
-
 import fudge
 from fudge.inspector import arg
 from fudge import (
@@ -17,15 +14,19 @@ def test_decorator_on_def():
     bobby = fudge.Fake()
     bobby.expects("suzie_called")
 
-    @raises(AssertionError)
     @fudge.with_fakes
     def some_test():
-        holder.test_called = True
+        try:
+            holder.test_called = True
+        except AssertionError:
+            pass
+        else:
+            raise AssertionError("Didn't raise AssertionError")
 
-    eq_(some_test.__name__, 'some_test')
+    assert some_test.__name__ == 'some_test'
     some_test()
 
-    eq_(holder.test_called, True)
+    assert holder.test_called == True
 
 # for a test below
 _some_fake = fudge.Fake()
@@ -34,54 +35,54 @@ class TestFake(unittest.TestCase):
 
     def test_guess_name(self):
         if sys.platform.startswith('java'):
-            raise SkipTest("not supported")
+            raise unittest.SkipTest("not supported")
         my_obj = fudge.Fake()
-        eq_(repr(my_obj), "fake:my_obj")
+        self.assertEqual(repr(my_obj), "fake:my_obj")
 
     def test_guess_name_globals(self):
         if sys.platform.startswith('java'):
-            raise SkipTest("not supported")
-        eq_(repr(_some_fake), "fake:_some_fake")
+            raise unittest.SkipTest("not supported")
+        self.assertEqual(repr(_some_fake), "fake:_some_fake")
 
     def test_guess_name_deref(self):
         if sys.platform.startswith('java'):
-            raise SkipTest("not supported")
+            raise unittest.SkipTest("not supported")
         my_obj = 44
         my_obj = fudge.Fake()
-        eq_(repr(my_obj), "fake:my_obj")
+        self.assertEqual(repr(my_obj), "fake:my_obj")
 
     def test_has_attr(self):
         my_obj = fudge.Fake().has_attr(vice='versa', beach='playa')
-        eq_(my_obj.vice, 'versa')
-        eq_(my_obj.beach, 'playa')
+        self.assertEqual(my_obj.vice, 'versa')
+        self.assertEqual(my_obj.beach, 'playa')
 
     def test_has_property(self):
         fake_vise = fudge.Fake().is_callable().returns('versa')
         fake_stuff = fudge.Fake().is_callable().raises(
             Exception('broken stuff'))
         my_obj = fudge.Fake().has_property(vice=fake_vise, stuff=fake_stuff)
-        eq_(my_obj.vice, 'versa')
+        self.assertEqual(my_obj.vice, 'versa')
         try:
             my_obj.stuff
-        except Exception, exc:
-            eq_(str(exc), 'broken stuff')
+        except Exception as exc:
+            self.assertEqual(str(exc), 'broken stuff')
         else:
             raise RuntimeError('expected Exception')
 
     def test_attributes_are_settable(self):
         my_obj = fudge.Fake().has_attr(vice='versa')
         my_obj.vice = 'miami'
-        eq_(my_obj.vice, 'miami')
+        self.assertEqual(my_obj.vice, 'miami')
 
     def test_none_type_attributes_are_settable(self):
         my_obj = fudge.Fake().has_attr(vice=None)
-        eq_(my_obj.vice, None)
+        self.assertEqual(my_obj.vice, None)
         my_obj.vice = 'miami'
-        eq_(my_obj.vice, 'miami')
+        self.assertEqual(my_obj.vice, 'miami')
 
     def test_attributes_can_replace_internals(self):
         my_obj = fudge.Fake().has_attr(provides='hijacked')
-        eq_(my_obj.provides, 'hijacked')
+        self.assertEqual(my_obj.provides, 'hijacked')
 
     def test_repr_shortens_long_values(self):
         fake = Fake("widget").provides("set_bits").with_args(
@@ -89,8 +90,8 @@ class TestFake(unittest.TestCase):
         )
         try:
             fake.set_bits()
-        except AssertionError, exc:
-            eq_(str(exc),
+        except AssertionError as exc:
+            self.assertEqual(str(exc),
             "fake:widget.set_bits('123456789101112131415161718192021222324252627...') "
             "was called unexpectedly with args ()")
         else:
@@ -106,14 +107,14 @@ class TestChainedNames(unittest.TestCase
         fudge.clear_expectations()
 
     def test_basic(self):
-        eq_(repr(self.fake), 'fake:db.Adapter')
+        self.assertEqual(repr(self.fake), 'fake:db.Adapter')
 
     def test_nesting(self):
         f = self.fake
         f = f.provides('query').returns_fake().provides('fetchall')
-        eq_(repr(f), 'fake:db.Adapter.query()')
+        self.assertEqual(repr(f), 'fake:db.Adapter.query()')
         f = f.provides('cursor').returns_fake()
-        eq_(repr(f), 'fake:db.Adapter.query().cursor()')
+        self.assertEqual(repr(f), 'fake:db.Adapter.query().cursor()')
 
     def test_more_nesting(self):
         class ctx:
@@ -125,7 +126,7 @@ class TestChainedNames(unittest.TestCase
              .provides('sendmail'))
             ctx.fake = fake_SMTP()
         test()
-        eq_(str(ctx.fake), 'fake:smtplib.SMTP()')
+        self.assertEqual(str(ctx.fake), 'fake:smtplib.SMTP()')
 
 
 class TestIsAStub(unittest.TestCase):
@@ -171,16 +172,16 @@ class TestIsAStub(unittest.TestCase):
         f.foo.bar().expects('barfoo')
         f.foo.bar().barfoo()
 
-    @raises(AssertionError)
     def test_infinite_path_expectation_is_verified(self):
-        f = fudge.Fake().is_a_stub()
-        f.foo.bar().expects('barfoo').with_args(foo='bar')
-        f.foo.bar().barfoo()
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            f = fudge.Fake().is_a_stub()
+            f.foo.bar().expects('barfoo').with_args(foo='bar')
+            f.foo.bar().barfoo()
+            fudge.verify()
 
     def test_infinite_path_naming(self):
         f = fudge.Fake(name='base').is_a_stub()
-        eq_(str(f.foo.bar().baz), 'fake:base.foo.bar().baz')
+        self.assertEqual(str(f.foo.bar().baz), 'fake:base.foo.bar().baz')
 
 
 class TestLongArgValues(unittest.TestCase):
@@ -192,8 +193,8 @@ class TestLongArgValues(unittest.TestCas
         try:
             # this should not be shortened but the above arg spec should:
             fake.set_bits("99999999999999999999999999999999999999999999999999999999")
-        except AssertionError, exc:
-            eq_(str(exc),
+        except AssertionError as exc:
+            self.assertEqual(str(exc),
             "fake:widget.set_bits('123456789101112131415161718192021222324252627...') "
             "was called unexpectedly with args "
             "('99999999999999999999999999999999999999999999999999999999')")
@@ -207,8 +208,8 @@ class TestLongArgValues(unittest.TestCas
         try:
             # this should not be shortened but the above arg spec should:
             fake.set_bits(newbits="99999999999999999999999999999999999999999999999999999999")
-        except AssertionError, exc:
-            eq_(str(exc),
+        except AssertionError as exc:
+            self.assertEqual(str(exc),
             "fake:widget.set_bits(newbits='123456789101112131415161718192021222324252627...') "
             "was called unexpectedly with args "
             "(newbits='99999999999999999999999999999999999999999999999999999999')")
@@ -223,65 +224,65 @@ class TestArguments(unittest.TestCase):
     def tearDown(self):
         fudge.clear_expectations()
 
-    @raises(AssertionError)
     def test_wrong_args(self):
-        exp = self.fake.expects('theCall').with_args(
-                        1,
-                        "ho ho ho ho ho ho ho, it's Santa",
-                        {'ditto':False})
-        exp.theCall()
+        with self.assertRaises(AssertionError):
+            exp = self.fake.expects('theCall').with_args(
+                            1,
+                            "ho ho ho ho ho ho ho, it's Santa",
+                            {'ditto':False})
+            exp.theCall()
 
-    @raises(AssertionError)
     def test_wrong_kwargs(self):
-        exp = self.fake.expects('other').with_args(one="twozy", items=[1,2,3,4])
-        exp.other(nice="NOT NICE")
+        with self.assertRaises(AssertionError):
+            exp = self.fake.expects('other').with_args(one="twozy", items=[1,2,3,4])
+            exp.other(nice="NOT NICE")
 
-    @raises(AssertionError)
     def test_arg_count(self):
-        exp = self.fake.expects('one').with_arg_count(3)
-        exp.one('no', 'maybe')
+        with self.assertRaises(AssertionError):
+            exp = self.fake.expects('one').with_arg_count(3)
+            exp.one('no', 'maybe')
 
-    @raises(AssertionError)
     def test_kwarg_count(self):
-        exp = self.fake.expects('__init__').with_kwarg_count(2)
-        exp(maybe="yes, maybe")
+        with self.assertRaises(AssertionError):
+            exp = self.fake.expects('__init__').with_kwarg_count(2)
+            exp(maybe="yes, maybe")
 
-    @raises(FakeDeclarationError)
     def test_with_args_requires_a_method(self):
-        self.fake.with_args('something')
+        with self.assertRaises(FakeDeclarationError):
+            self.fake.with_args('something')
 
-    @raises(AssertionError)
     def test_with_args_can_operate_on_provision(self):
-        self.fake.provides("not_expected").with_args('something')
-        self.fake.not_expected() # should still raise arg error
+        with self.assertRaises(AssertionError):
+            self.fake.provides("not_expected").with_args('something')
+            self.fake.not_expected() # should still raise arg error
 
-    @raises(AssertionError)
     def test_with_args_checks_args(self):
-        self.fake.expects('count').with_args('one', two='two')
-        self.fake.count(two='two')
+        with self.assertRaises(AssertionError):
+            self.fake.expects('count').with_args('one', two='two')
+            self.fake.count(two='two')
 
-    @raises(AssertionError)
     def test_with_args_checks_kwargs(self):
-        self.fake.expects('count').with_args('one', two='two')
-        self.fake.count('one')
+        with self.assertRaises(AssertionError):
+            self.fake.expects('count').with_args('one', two='two')
+            self.fake.count('one')
 
-    @raises(AssertionError)
     def test_raises_does_not_obscure_with_kwargs(self):
         # previously, this test failed because the raises(exc)
         # was raised too early.  Issue 6
-        self.fake.expects('count').with_args(two='two').raises(RuntimeError('bork'))
-        self.fake.count('one') # wrong kwargs
+        with self.assertRaises(AssertionError):
+            self.fake.expects('count').with_args(two='two').raises(RuntimeError('bork'))
+            self.fake.count('one') # wrong kwargs
 
-    @raises(AssertionError)
     def test_raises_does_not_obscure_with_args(self):
         # Issue 6
-        self.fake.expects('count').with_args('one').raises(RuntimeError('bork'))
-        self.fake.count(two='two') # wrong args
+        with self.assertRaises(AssertionError):
+            self.fake.expects('count').with_args('one').raises(RuntimeError('bork'))
+            self.fake.count(two='two') # wrong args
 
-    @raises(AssertionError)
     def test_too_many_args(self):
-        db = Fake("db").expects("execute").with_args(bind={'one':1})
-        db.execute("select foozilate()", bind={'one':1}) # unexpected statement arg
+        with self.assertRaises(AssertionError):
+            db = Fake("db").expects("execute").with_args(bind={'one':1})
+            db.execute("select foozilate()", bind={'one':1}) # unexpected statement arg
 
     def test_zero_keywords_ok(self):
         mail = fudge.Fake('mail').expects('send').with_arg_count(3)
@@ -319,37 +320,37 @@ class TestArguments(unittest.TestCase):
         db.transaction("insert", isolation_level="lock")
         fudge.verify()
 
-    @raises(AssertionError)
     def test_with_non_matching_positional_args(self):
-        db = self.fake
-        db.expects('transaction').with_matching_args('update')
-        db.transaction("insert", isolation_level="lock")
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            db = self.fake
+            db.expects('transaction').with_matching_args('update')
+            db.transaction("insert", isolation_level="lock")
+            fudge.verify()
 
-    @raises(AssertionError)
     def test_with_too_many_non_matching_positional_args(self):
         # this may be unintuitve but specifying too many
         # arguments constitutes as non-matching.  Why?
         # Because how else is it possible to implement, by index?
-        db = self.fake
-        db.expects('transaction').with_matching_args('update')
-        db.transaction("update", "delete", isolation_level="lock")
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            db = self.fake
+            db.expects('transaction').with_matching_args('update')
+            db.transaction("update", "delete", isolation_level="lock")
+            fudge.verify()
 
-    @raises(AssertionError)
     def test_with_non_matching_keyword_args(self):
-        db = self.fake
-        db.expects('transaction').with_matching_args(isolation_level="read")
-        db.transaction("insert", isolation_level="lock")
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            db = self.fake
+            db.expects('transaction').with_matching_args(isolation_level="read")
+            db.transaction("insert", isolation_level="lock")
+            fudge.verify()
 
-    @raises(AssertionError)
     def test_missing_matching_positional_args_is_not_ok(self):
         # this is awkward to implement so I think it should not be supported
-        db = self.fake
-        db.expects('transaction').with_matching_args("update")
-        db.transaction()
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            db = self.fake
+            db.expects('transaction').with_matching_args("update")
+            db.transaction()
+            fudge.verify()
 
     def test_missing_matching_keyword_args_is_ok(self):
         db = self.fake
@@ -366,29 +367,29 @@ class TestArguments(unittest.TestCase):
 #         self.call = Call(self.fake)
 #
 #     def test_empty(self):
-#         eq_(self.call._arg_diff(tuple(), tuple()), "")
+#         self.assertEqual(self.call._arg_diff(tuple(), tuple()), "")
 #
 #     def test_one_unexpected(self):
-#         eq_(self.call._arg_diff(('one',), tuple()), "arg #1 was unexpected")
+#         self.assertEqual(self.call._arg_diff(('one',), tuple()), "arg #1 was unexpected")
 #
 #     def test_one_missing(self):
-#         eq_(self.call._arg_diff(tuple(), ('one',)), "arg #1 never showed up")
+#         self.assertEqual(self.call._arg_diff(tuple(), ('one',)), "arg #1 never showed up")
 #
 #     def test_four_unexpected(self):
-#         eq_(self.call._arg_diff(
+#         self.assertEqual(self.call._arg_diff(
 #             ('one','two','three','four'),
 #             ('one','two','three')), "arg #4 was unexpected")
 #
 #     def test_four_missing(self):
-#         eq_(self.call._arg_diff(
+#         self.assertEqual(self.call._arg_diff(
 #             ('one','two','three'),
 #             ('one','two','three','four')), "arg #4 never showed up")
 #
 #     def test_one_mismatch(self):
-#         eq_(self.call._arg_diff(('won',), ('one',)), "arg #1 'won' != 'one'")
+#         self.assertEqual(self.call._arg_diff(('won',), ('one',)), "arg #1 'won' != 'one'")
 #
 #     def test_four_mismatch(self):
-#         eq_(self.call._arg_diff(
+#         self.assertEqual(self.call._arg_diff(
 #             ('one','two','three','not four'),
 #             ('one','two','three','four')), "arg #4 'not four' != 'four'")
 
@@ -399,50 +400,50 @@ class TestArguments(unittest.TestCase):
 #         self.call = Call(self.fake)
 #
 #     def test_empty(self):
-#         eq_(self.call._keyword_diff({}, {}), (True, ""))
+#         self.assertEqual(self.call._keyword_diff({}, {}), (True, ""))
 #
 #     def test_one_empty(self):
-#         eq_(self.call._keyword_diff({},
+#         self.assertEqual(self.call._keyword_diff({},
 #             {'something':'here','another':'there'}),
 #             (False, "these keywords never showed up: ('something', 'another')"))
 #
 #     def test_complex_match_yields_no_reason(self):
 #         actual = {'num':1, 'two':2, 'three':3}
 #         expected = {'num':1, 'two':2, 'three':3}
-#         eq_(self.call._keyword_diff(actual, expected), (True, ""))
+#         self.assertEqual(self.call._keyword_diff(actual, expected), (True, ""))
 #
 #     def test_simple_mismatch_yields_no_reason(self):
 #         actual = {'num':1}
 #         expected = {'num':2}
-#         eq_(self.call._keyword_diff(actual, expected), (False, ""))
+#         self.assertEqual(self.call._keyword_diff(actual, expected), (False, ""))
 #
 #     def test_simple_match_yields_no_reason(self):
 #         actual = {'num':1}
 #         expected = {'num':1}
-#         eq_(self.call._keyword_diff(actual, expected), (True, ""))
+#         self.assertEqual(self.call._keyword_diff(actual, expected), (True, ""))
 #
 #     def test_actual_kw_extra_key(self):
 #         actual = {'one':1, 'two':2}
 #         expected = {'one':1}
-#         eq_(self.call._keyword_diff(actual, expected),
+#         self.assertEqual(self.call._keyword_diff(actual, expected),
 #             (False, "keyword 'two' was not expected"))
 #
 #     def test_actual_kw_value_inequal(self):
 #         actual = {'one':1, 'two':2}
 #         expected = {'one':1, 'two':3}
-#         eq_(self.call._keyword_diff(actual, expected),
+#         self.assertEqual(self.call._keyword_diff(actual, expected),
 #             (False, "two=2 != two=3"))
 #
 #     def test_expected_kw_extra_key(self):
 #         actual = {'one':1}
 #         expected = {'one':1, 'two':2}
-#         eq_(self.call._keyword_diff(actual, expected),
+#         self.assertEqual(self.call._keyword_diff(actual, expected),
 #             (False, "this keyword never showed up: ('two',)"))
 #
 #     def test_expected_kw_value_inequal(self):
 #         actual = {'one':1, 'two':'not two'}
 #         expected = {'one':1, 'two':2}
-#         eq_(self.call._keyword_diff(actual, expected),
+#         self.assertEqual(self.call._keyword_diff(actual, expected),
 #             (False, "two='not two' != two=2"))
 
 class TestCall(unittest.TestCase):
@@ -452,41 +453,41 @@ class TestCall(unittest.TestCase):
 
     def test_repr(self):
         s = Call(self.fake)
-        eq_(repr(s), "fake:SMTP()")
+        self.assertEqual(repr(s), "fake:SMTP()")
 
     def test_repr_callable(self):
         s = Call(self.fake.is_callable())
-        eq_(repr(s), "fake:SMTP()")
+        self.assertEqual(repr(s), "fake:SMTP()")
 
     def test_repr_with_args(self):
         s = Call(self.fake)
         s.expected_args = [1,"bad"]
-        eq_(repr(s), "fake:SMTP(1, 'bad')")
+        self.assertEqual(repr(s), "fake:SMTP(1, 'bad')")
 
     def test_repr_with_kwargs(self):
         s = Call(self.fake)
         s.expected_args = [1,"bad"]
         s.expected_kwargs = {'baz':'borzo'}
-        eq_(repr(s), "fake:SMTP(1, 'bad', baz='borzo')")
+        self.assertEqual(repr(s), "fake:SMTP(1, 'bad', baz='borzo')")
 
     def test_named_repr_with_args(self):
         s = Call(self.fake, call_name='connect')
         s.expected_args = [1,"bad"]
-        eq_(repr(s), "fake:SMTP.connect(1, 'bad')")
+        self.assertEqual(repr(s), "fake:SMTP.connect(1, 'bad')")
 
     def test_nested_named_repr_with_args(self):
         f = self.fake.provides('get_conn').returns_fake()
         s = Call(f, call_name='connect')
         s.expected_args = [1,"bad"]
-        eq_(repr(s), "fake:SMTP.get_conn().connect(1, 'bad')")
+        self.assertEqual(repr(s), "fake:SMTP.get_conn().connect(1, 'bad')")
 
     def test_named_repr_with_index(self):
         s = Call(self.fake, call_name='connect')
         s.expected_args = [1,"bad"]
         s.index = 0
-        eq_(repr(s), "fake:SMTP.connect(1, 'bad')[0]")
+        self.assertEqual(repr(s), "fake:SMTP.connect(1, 'bad')[0]")
         s.index = 1
-        eq_(repr(s), "fake:SMTP.connect(1, 'bad')[1]")
+        self.assertEqual(repr(s), "fake:SMTP.connect(1, 'bad')[1]")
 
 
 class TestCallStack(unittest.TestCase):
@@ -505,24 +506,24 @@ class TestCallStack(unittest.TestCase):
         c.return_val = 2
         call_stack.add_call(c)
 
-        eq_(call_stack(), 1)
-        eq_(call_stack(), 2)
+        self.assertEqual(call_stack(), 1)
+        self.assertEqual(call_stack(), 2)
 
-    @raises(AssertionError)
     def test_no_calls(self):
-        call_stack = CallStack(self.fake)
-        call_stack()
+        with self.assertRaises(AssertionError):
+            call_stack = CallStack(self.fake)
+            call_stack()
 
-    @raises(AssertionError)
     def test_end_of_calls(self):
-        call_stack = CallStack(self.fake)
+        with self.assertRaises(AssertionError):
+            call_stack = CallStack(self.fake)
 
-        c = Call(self.fake)
-        c.return_val = 1
-        call_stack.add_call(c)
+            c = Call(self.fake)
+            c.return_val = 1
+            call_stack.add_call(c)
 
-        eq_(call_stack(), 1)
-        call_stack()
+            self.assertEqual(call_stack(), 1)
+            call_stack()
 
     def test_get_call_object(self):
         call_stack = CallStack(self.fake)
@@ -542,7 +543,7 @@ class TestCallStack(unittest.TestCase):
         c.return_val = 1
         call_stack = CallStack(self.fake, initial_calls=[c])
 
-        eq_(call_stack(), 1)
+        self.assertEqual(call_stack(), 1)
 
     def test_reset(self):
         call_stack = CallStack(self.fake)
@@ -555,47 +556,47 @@ class TestCallStack(unittest.TestCase):
         c.return_val = 2
         call_stack.add_call(c)
 
-        eq_(call_stack(), 1)
-        eq_(call_stack(), 2)
+        self.assertEqual(call_stack(), 1)
+        self.assertEqual(call_stack(), 2)
 
         call_stack.reset()
 
-        eq_(call_stack(), 1)
-        eq_(call_stack(), 2)
+        self.assertEqual(call_stack(), 1)
+        self.assertEqual(call_stack(), 2)
 
 class TestFakeCallables(unittest.TestCase):
 
     def tearDown(self):
         fudge.clear_expectations()
 
-    @raises(RuntimeError)
     def test_not_callable_by_default(self):
-        self.fake = fudge.Fake()
-        self.fake()
+        with self.assertRaises(RuntimeError):
+            self.fake = fudge.Fake()
+            self.fake()
 
     def test_callable(self):
         fake = fudge.Fake().is_callable()
         fake() # allow the call
         fudge.verify() # no error
 
-    @raises(AttributeError)
     def test_cannot_stub_any_call_by_default(self):
-        self.fake.Anything() # must define this first
+        with self.assertRaises(AttributeError):
+            self.fake.Anything() # must define this first
 
-    @raises(AssertionError)
     def test_stub_with_args(self):
-        self.fake = fudge.Fake().is_callable().with_args(1,2)
-        self.fake(1)
+        with self.assertRaises(AssertionError):
+            self.fake = fudge.Fake().is_callable().with_args(1,2)
+            self.fake(1)
 
-    @raises(AssertionError)
     def test_stub_with_arg_count(self):
-        self.fake = fudge.Fake().is_callable().with_arg_count(3)
-        self.fake('bah')
+        with self.assertRaises(AssertionError):
+            self.fake = fudge.Fake().is_callable().with_arg_count(3)
+            self.fake('bah')
 
-    @raises(AssertionError)
     def test_stub_with_kwarg_count(self):
-        self.fake = fudge.Fake().is_callable().with_kwarg_count(3)
-        self.fake(two=1)
+        with self.assertRaises(AssertionError):
+            self.fake = fudge.Fake().is_callable().with_kwarg_count(3)
+            self.fake(two=1)
 
     def test_stub_with_provides(self):
         self.fake = fudge.Fake().provides("something")
@@ -608,28 +609,28 @@ class TestFakeCallables(unittest.TestCas
 
         # replace Fake.with_args()
         self.fake = fudge.Fake().provides("with_args").returns(1)
-        eq_(self.fake.with_args(), 1)
+        self.assertEqual(self.fake.with_args(), 1)
 
-    @raises(AssertionError)
     def test_stub_with_provides_and_args(self):
-        self.fake = fudge.Fake().provides("something").with_args(1,2)
-        self.fake.something()
+        with self.assertRaises(AssertionError):
+            self.fake = fudge.Fake().provides("something").with_args(1,2)
+            self.fake.something()
 
     def test_stub_is_not_registered(self):
         self.fake = fudge.Fake().provides("something")
         exp = self.fake._get_current_call()
-        eq_(exp.call_name, "something")
-        assert exp not in fudge.registry
+        self.assertEqual(exp.call_name, "something")
+        self.assertNotIn(exp, fudge.registry)
 
-    @raises(RuntimeError)
     def test_raises_class(self):
-        self.fake = fudge.Fake().provides("fail").raises(RuntimeError)
-        self.fake.fail()
+        with self.assertRaises(RuntimeError):
+            self.fake = fudge.Fake().provides("fail").raises(RuntimeError)
+            self.fake.fail()
 
-    @raises(RuntimeError)
     def test_raises_instance(self):
-        self.fake = fudge.Fake().provides("fail").raises(RuntimeError("batteries ran out"))
-        self.fake.fail()
+        with self.assertRaises(RuntimeError):
+            self.fake = fudge.Fake().provides("fail").raises(RuntimeError("batteries ran out"))
+            self.fake.fail()
 
 class TestReplacementCalls(unittest.TestCase):
 
@@ -642,7 +643,7 @@ class TestReplacementCalls(unittest.Test
             return "hijacked"
 
         fake = fudge.Fake().provides("something").calls(something)
-        eq_(fake.something(), "hijacked")
+        self.assertEqual(fake.something(), "hijacked")
 
     def test_calls_mixed_with_returns(self):
 
@@ -652,18 +653,18 @@ class TestReplacementCalls(unittest.Test
             return "hijacked"
 
         fake = fudge.Fake().provides("something").calls(something).returns("other")
-        eq_(fake.something(), "other")
-        eq_(called, [True])
+        self.assertEqual(fake.something(), "other")
+        self.assertEqual(called, [True])
 
-    @raises(AssertionError)
     def test_calls_mixed_with_expectations(self):
 
         def something():
             return "hijacked"
 
-        # with_args() expectation should not get lost:
-        fake = fudge.Fake().provides("something").calls(something).with_args(1,2)
-        eq_(fake.something(), "hijacked")
+        with self.assertRaises(AssertionError):
+            # with_args() expectation should not get lost:
+            fake = fudge.Fake().provides("something").calls(something).with_args(1,2)
+            self.assertEqual(fake.something(), "hijacked")
 
     def test_replace_init(self):
 
@@ -672,7 +673,7 @@ class TestReplacementCalls(unittest.Test
                 return "hi"
 
         fake = fudge.Fake().provides("__init__").returns(custom_object())
-        eq_(fake().hello(), "hi")
+        self.assertEqual(fake().hello(), "hi")
 
 class TestFakeTimesCalled(unittest.TestCase):
 
@@ -684,32 +685,32 @@ class TestFakeTimesCalled(unittest.TestC
         # this should not raise an error because the call was provided not expected
         fudge.verify()
 
-    @raises(AssertionError)
     def test_when_provided_raises_on_too_many_calls(self):
-        self.fake = fudge.Fake().provides("something").times_called(2)
-        self.fake.something()
-        self.fake.something()
-        self.fake.something() # too many
+        with self.assertRaises(AssertionError):
+            self.fake = fudge.Fake().provides("something").times_called(2)
+            self.fake.something()
+            self.fake.something()
+            self.fake.something() # too many
 
-    @raises(AssertionError)
     def test_when_expected(self):
-        self.fake = fudge.Fake().expects("something").times_called(2)
-        self.fake.something()
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            self.fake = fudge.Fake().expects("something").times_called(2)
+            self.fake.something()
+            fudge.verify()
 
-    @raises(AssertionError)
     def test_when_expected_raises_on_too_many_calls(self):
-        self.fake = fudge.Fake().expects("something").times_called(2)
-        self.fake.something()
-        self.fake.something()
-        self.fake.something() # too many
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            self.fake = fudge.Fake().expects("something").times_called(2)
+            self.fake.something()
+            self.fake.something()
+            self.fake.something() # too many
+            fudge.verify()
 
-    @raises(AssertionError)
     def test_expected_callable(self):
-        login = fudge.Fake('login',expect_call=True).times_called(2)
-        login()
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            login = fudge.Fake('login',expect_call=True).times_called(2)
+            login()
+            fudge.verify()
 
     def test_callable_ok(self):
         self.fake = fudge.Fake(callable=True).times_called(2)
@@ -734,19 +735,19 @@ class TestNextCall(unittest.TestCase):
     def tearDown(self):
         fudge.clear_expectations()
 
-    @raises(FakeDeclarationError)
     def test_next_call_then_times_called_is_error(self):
-        self.fake = fudge.Fake().expects("hi").returns("goodday").next_call().times_called(4)
-        self.fake.hi()
-        self.fake.hi()
-        fudge.verify()
+        with self.assertRaises(FakeDeclarationError):
+            self.fake = fudge.Fake().expects("hi").returns("goodday").next_call().times_called(4)
+            self.fake.hi()
+            self.fake.hi()
+            fudge.verify()
 
-    @raises(FakeDeclarationError)
     def test_times_called_then_next_call_is_error(self):
-        self.fake = fudge.Fake().expects("hi").times_called(4).next_call()
-        self.fake.hi()
-        self.fake.hi()
-        fudge.verify()
+        with self.assertRaises(FakeDeclarationError):
+            self.fake = fudge.Fake().expects("hi").times_called(4).next_call()
+            self.fake.hi()
+            self.fake.hi()
+            fudge.verify()
 
     def test_stacked_returns(self):
         fake = fudge.Fake().provides("something")
@@ -756,20 +757,20 @@ class TestNextCall(unittest.TestCase):
         fake = fake.next_call()
         fake = fake.returns(3)
 
-        eq_(fake.something(), 1)
-        eq_(fake.something(), 2)
-        eq_(fake.something(), 3)
+        self.assertEqual(fake.something(), 1)
+        self.assertEqual(fake.something(), 2)
+        self.assertEqual(fake.something(), 3)
 
-    @raises(AssertionError)
     def test_stacked_calls_are_finite(self):
-        self.fake = fudge.Fake().provides("something")
-        self.fake = self.fake.returns(1)
-        self.fake = self.fake.next_call()
-        self.fake = self.fake.returns(2)
-
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 2)
-        self.fake.something()
+        with self.assertRaises(AssertionError):
+            self.fake = fudge.Fake().provides("something")
+            self.fake = self.fake.returns(1)
+            self.fake = self.fake.next_call()
+            self.fake = self.fake.returns(2)
+
+            self.assertEqual(self.fake.something(), 1)
+            self.assertEqual(self.fake.something(), 2)
+            self.fake.something()
 
     def test_stack_is_reset_when_name_changes(self):
         self.fake = fudge.Fake().provides("something")
@@ -779,13 +780,13 @@ class TestNextCall(unittest.TestCase):
         self.fake = self.fake.provides("other")
         self.fake = self.fake.returns(3)
 
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 2)
-        eq_(self.fake.other(), 3)
-        eq_(self.fake.other(), 3)
-        eq_(self.fake.other(), 3)
-        eq_(self.fake.other(), 3)
-        eq_(self.fake.other(), 3)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 2)
+        self.assertEqual(self.fake.other(), 3)
+        self.assertEqual(self.fake.other(), 3)
+        self.assertEqual(self.fake.other(), 3)
+        self.assertEqual(self.fake.other(), 3)
+        self.assertEqual(self.fake.other(), 3)
 
     def test_next_call_with_multiple_returns(self):
         self.fake = fudge.Fake().provides("something")
@@ -797,10 +798,10 @@ class TestNextCall(unittest.TestCase):
         self.fake = self.fake.next_call()
         self.fake = self.fake.returns(4)
 
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 2)
-        eq_(self.fake.other(), 3)
-        eq_(self.fake.other(), 4)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 2)
+        self.assertEqual(self.fake.other(), 3)
+        self.assertEqual(self.fake.other(), 4)
 
     def test_stacked_calls_do_not_collide(self):
         self.fake = fudge.Fake().provides("something")
@@ -812,22 +813,22 @@ class TestNextCall(unittest.TestCase):
         self.fake = self.fake.next_call()
         self.fake = self.fake.returns(4)
 
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.other(), 3)
-        eq_(self.fake.something(), 2)
-        eq_(self.fake.other(), 4)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.other(), 3)
+        self.assertEqual(self.fake.something(), 2)
+        self.assertEqual(self.fake.other(), 4)
 
     def test_returns_are_infinite(self):
         self.fake = fudge.Fake().provides("something").returns(1)
 
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 1)
 
     def test_stacked_does_not_copy_expectations(self):
 
@@ -837,8 +838,8 @@ class TestNextCall(unittest.TestCase):
         fake = fake.next_call()
         fake = fake.returns(-1)
 
-        eq_(fake.add(1,2), 3)
-        eq_(fake.add(), -1)
+        self.assertEqual(fake.add(1,2), 3)
+        self.assertEqual(fake.add(), -1)
 
     def test_stacked_calls_are_in_registry(self):
         fake = fudge.Fake().expects("count").with_args(1)
@@ -863,10 +864,10 @@ class TestNextCall(unittest.TestCase):
         # hmm
         call_stack = fake._declared_calls[fake._last_declared_call_name]
         calls = [c for c in call_stack]
-        eq_(calls[0].index, 0)
-        eq_(calls[1].index, 1)
-        eq_(calls[2].index, 2)
-        eq_(calls[3].index, 3)
+        self.assertEqual(calls[0].index, 0)
+        self.assertEqual(calls[1].index, 1)
+        self.assertEqual(calls[2].index, 2)
+        self.assertEqual(calls[3].index, 3)
 
     def test_start_stop_resets_stack(self):
         fudge.clear_expectations()
@@ -875,18 +876,18 @@ class TestNextCall(unittest.TestCase):
         fake = fake.next_call()
         fake = fake.returns(2)
 
-        eq_(fake.something(), 1)
-        eq_(fake.something(), 2)
+        self.assertEqual(fake.something(), 1)
+        self.assertEqual(fake.something(), 2)
 
         fudge.clear_calls()
 
-        eq_(fake.something(), 1)
-        eq_(fake.something(), 2)
+        self.assertEqual(fake.something(), 1)
+        self.assertEqual(fake.something(), 2)
 
         fudge.verify()
 
-        eq_(fake.something(), 1)
-        eq_(fake.something(), 2)
+        self.assertEqual(fake.something(), 1)
+        self.assertEqual(fake.something(), 2)
 
     def test_next_call_with_callables(self):
         login = (fudge.Fake('login')
@@ -896,9 +897,9 @@ class TestNextCall(unittest.TestCase):
                                 .returns("maybe")
                                 .next_call()
                                 .returns("no"))
-        eq_(login(), "yes")
-        eq_(login(), "maybe")
-        eq_(login(), "no")
+        self.assertEqual(login(), "yes")
+        self.assertEqual(login(), "maybe")
+        self.assertEqual(login(), "no")
 
     def test_returns(self):
         db = Fake("db")\
@@ -906,18 +907,18 @@ class TestNextCall(unittest.TestCase):
             .provides("set_id")\
             .next_call(for_method="get_id").returns(2)
         # print [c.return_val for c in db._declared_calls["get_id"]._calls]
-        eq_(db.get_id(), 1)
-        eq_(db.set_id(), None)
-        eq_(db.get_id(), 2)
+        self.assertEqual(db.get_id(), 1)
+        self.assertEqual(db.set_id(), None)
+        self.assertEqual(db.get_id(), 2)
 
     def test_expectations_with_multiple_return_values(self):
         db = Fake("db")\
             .expects("get_id").returns(1)\
             .expects("set_id")\
             .next_call(for_method="get_id").returns(2)
-        eq_(db.get_id(), 1)
-        eq_(db.set_id(), None)
-        eq_(db.get_id(), 2)
+        self.assertEqual(db.get_id(), 1)
+        self.assertEqual(db.set_id(), None)
+        self.assertEqual(db.get_id(), 2)
 
         fudge.verify()
 
@@ -927,11 +928,11 @@ class TestExpectsAndProvides(unittest.Te
     def tearDown(self):
         fudge.clear_expectations()
 
-    @raises(AssertionError)
     def test_nocall(self):
-        fake = fudge.Fake()
-        exp = fake.expects('something')
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            fake = fudge.Fake()
+            exp = fake.expects('something')
+            fudge.verify()
 
     def test_multiple_provides_on_chained_fakes_ok(self):
         db = Fake("db").provides("insert").returns_fake().provides("insert")
@@ -958,8 +959,8 @@ class TestExpectsAndProvides(unittest.Te
         self.fake = self.fake.expects("something")
         self.fake = self.fake.returns(2)
 
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 2)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 2)
 
     def test_multiple_provides_act_like_next_call(self):
         self.fake = fudge.Fake().provides("something")
@@ -967,8 +968,8 @@ class TestExpectsAndProvides(unittest.Te
         self.fake = self.fake.provides("something")
         self.fake = self.fake.returns(2)
 
-        eq_(self.fake.something(), 1)
-        eq_(self.fake.something(), 2)
+        self.assertEqual(self.fake.something(), 1)
+        self.assertEqual(self.fake.something(), 2)
 
     def test_multiple_expects_for_sep_methods(self):
         self.fake = (fudge.Fake()
@@ -982,10 +983,10 @@ class TestExpectsAndProvides(unittest.Te
                         .returns('B')
         )
 
-        eq_(self.fake.marco(), 1)
-        eq_(self.fake.marco(), 2)
-        eq_(self.fake.polo(), 'A')
-        eq_(self.fake.polo(), 'B')
+        self.assertEqual(self.fake.marco(), 1)
+        self.assertEqual(self.fake.marco(), 2)
+        self.assertEqual(self.fake.polo(), 'A')
+        self.assertEqual(self.fake.polo(), 'B')
 
     def test_multiple_provides_for_sep_methods(self):
         self.fake = (fudge.Fake()
@@ -999,60 +1000,60 @@ class TestExpectsAndProvides(unittest.Te
                         .returns('B')
         )
 
-        eq_(self.fake.marco(), 1)
-        eq_(self.fake.marco(), 2)
-        eq_(self.fake.polo(), 'A')
-        eq_(self.fake.polo(), 'B')
+        self.assertEqual(self.fake.marco(), 1)
+        self.assertEqual(self.fake.marco(), 2)
+        self.assertEqual(self.fake.polo(), 'A')
+        self.assertEqual(self.fake.polo(), 'B')
 
 class TestOrderedCalls(unittest.TestCase):
 
     def tearDown(self):
         fudge.clear_expectations()
 
-    @raises(AssertionError)
     def test_out_of_order(self):
-        fake = fudge.Fake().remember_order().expects("one").expects("two")
-        fake.two()
-        fake.one()
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            fake = fudge.Fake().remember_order().expects("one").expects("two")
+            fake.two()
+            fake.one()
+            fudge.verify()
 
-    @raises(FakeDeclarationError)
     def test_cannot_remember_order_when_callable_is_true(self):
-        fake = fudge.Fake().is_callable().remember_order()
+        with self.assertRaises(FakeDeclarationError):
+            fake = fudge.Fake().is_callable().remember_order()
 
-    @raises(FakeDeclarationError)
     def test_cannot_remember_order_when_expect_call_is_true(self):
-        fake = fudge.Fake(expect_call=True).remember_order()
+        with self.assertRaises(FakeDeclarationError):
+            fake = fudge.Fake(expect_call=True).remember_order()
 
-    @raises(AssertionError)
     def test_not_enough_calls(self):
-        # need to drop down a level to bypass expected calls:
-        r = Registry()
-        fake = Fake()
-        call_order = ExpectedCallOrder(fake)
-        r.remember_expected_call_order(call_order)
+        with self.assertRaises(AssertionError):
+            # need to drop down a level to bypass expected calls:
+            r = Registry()
+            fake = Fake()
+            call_order = ExpectedCallOrder(fake)
+            r.remember_expected_call_order(call_order)
 
-        exp = ExpectedCall(fake, "callMe", call_order=call_order)
-        call_order.add_expected_call(exp)
+            exp = ExpectedCall(fake, "callMe", call_order=call_order)
+            call_order.add_expected_call(exp)
 
-        r.verify()
+            r.verify()
 
-    @raises(AssertionError)
     def test_only_one_call(self):
-        # need to drop down a level to bypass expected calls:
-        r = Registry()
-        fake = Fake()
-        call_order = ExpectedCallOrder(fake)
-        r.remember_expected_call_order(call_order)
-
-        exp = ExpectedCall(fake, "one", call_order=call_order)
-        call_order.add_expected_call(exp)
-        exp() # call this
+        with self.assertRaises(AssertionError):
+            # need to drop down a level to bypass expected calls:
+            r = Registry()
+            fake = Fake()
+            call_order = ExpectedCallOrder(fake)
+            r.remember_expected_call_order(call_order)
+
+            exp = ExpectedCall(fake, "one", call_order=call_order)
+            call_order.add_expected_call(exp)
+            exp() # call this
 
-        exp = ExpectedCall(fake, "two", call_order=call_order)
-        call_order.add_expected_call(exp)
+            exp = ExpectedCall(fake, "two", call_order=call_order)
+            call_order.add_expected_call(exp)
 
-        r.verify()
+            r.verify()
 
     def test_incremental_order_assertion_ok(self):
         # need to drop down a level to bypass expected calls:
@@ -1075,38 +1076,38 @@ class TestOrderedCalls(unittest.TestCase
             .expects("get_id").returns(1)\
             .expects("set_id")\
             .next_call(for_method="get_id").returns(2)
-        eq_(db.get_id(), 1)
-        eq_(db.set_id(), None)
-        eq_(db.get_id(), 2)
+        self.assertEqual(db.get_id(), 1)
+        self.assertEqual(db.set_id(), None)
+        self.assertEqual(db.get_id(), 2)
         fudge.verify()
 
-    @raises(AssertionError)
     def test_chained_fakes_honor_order(self):
-        Thing = Fake("thing").remember_order().expects("__init__")
-        holder = Thing.expects("get_holder").returns_fake()
-        holder = holder.expects("init")
-
-        thing = Thing()
-        holder = thing.get_holder()
-        # missing thing.init()
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            Thing = Fake("thing").remember_order().expects("__init__")
+            holder = Thing.expects("get_holder").returns_fake()
+            holder = holder.expects("init")
+
+            thing = Thing()
+            holder = thing.get_holder()
+            # missing thing.init()
+            fudge.verify()
 
-    @raises(AssertionError)
     def test_too_many_calls(self):
-        db = Fake("db")\
-            .remember_order()\
-            .expects("get_id").returns(1)\
-            .expects("set_id")
-        eq_(db.get_id(), 1)
-        eq_(db.set_id(), None)
-        # extra :
-        eq_(db.get_id(), 1)
+        with self.assertRaises(AssertionError):
+            db = Fake("db")\
+                .remember_order()\
+                .expects("get_id").returns(1)\
+                .expects("set_id")
+            self.assertEqual(db.get_id(), 1)
+            self.assertEqual(db.set_id(), None)
+            # extra :
+            self.assertEqual(db.get_id(), 1)
 
-    @raises(AssertionError)
     def test_expects_call_shortcut(self):
-        remove = Fake("os.remove").expects_call()
-        fudge.verify()
-        assert isinstance(remove, Fake)
+        with self.assertRaises(AssertionError):
+            remove = Fake("os.remove").expects_call()
+            fudge.verify()
+            assert isinstance(remove, Fake)
 
     def test_expects_call_shortcut_ok(self):
         remove = Fake("os.remove").expects_call()
@@ -1139,37 +1140,37 @@ class TestPatchedFakes(unittest.TestCase
 
         some_test()
         fudge.verify() # should be no errors
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
 
     def test_expectations_are_verified(self):
 
         class holder:
             test_called = False
 
-        @raises(AssertionError)
         @fudge.patch('shutil.copy')
         def some_test(copy):
-            copy.expects('__call__')
-            holder.test_called = True
+            with self.assertRaises(AssertionError):
+                copy.expects('__call__')
+                holder.test_called = True
 
-        some_test()
-        eq_(holder.test_called, True)
+                some_test()
+                self.assertEqual(holder.test_called, True)
 
     def test_expectations_are_always_cleared(self):
 
         class holder:
             test_called = False
 
-        @raises(RuntimeError)
         @fudge.patch('shutil.copy')
         def some_test(copy):
-            holder.test_called = True
-            copy.expects_call()
-            raise RuntimeError
+            with self.assertRaises(RuntimeError):
+                holder.test_called = True
+                copy.expects_call()
+                raise RuntimeError
 
         some_test()
         fudge.verify() # should be no errors
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
 
     def test_calls_are_cleared(self):
 
@@ -1188,29 +1189,29 @@ class TestPatchedFakes(unittest.TestCase
 
         some_test()
         fudge.verify() # should be no errors
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
 
     def test_with_statement(self):
 
         class holder:
             test_called = False
 
-        @raises(AssertionError)
         def run_test():
-            with fudge.patch('shutil.copy') as copy:
-                copy.expects('__call__')
-                holder.test_called = True
+            with self.assertRaises(AssertionError):
+                with fudge.patch('shutil.copy') as copy:
+                    copy.expects('__call__')
+                    holder.test_called = True
 
         run_test()
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
 
     def test_with_statement_exception(self):
 
-        @raises(RuntimeError)
         def run_test():
-            with fudge.patch('shutil.copy') as copy:
-                copy.expects('__call__')
-                raise RuntimeError()
+            with self.assertRaises(RuntimeError):
+                with fudge.patch('shutil.copy') as copy:
+                    copy.expects('__call__')
+                    raise RuntimeError()
 
         run_test()
 
@@ -1226,7 +1227,7 @@ class TestNonPatchedFakeTest(unittest.Te
         def some_test():
             holder.test_called = True
 
-        eq_(some_test.__name__, 'some_test')
+        self.assertEqual(some_test.__name__, 'some_test')
 
     def test_expectations_are_cleared(self):
 
@@ -1242,23 +1243,23 @@ class TestNonPatchedFakeTest(unittest.Te
 
         some_test()
         fudge.verify() # should be no errors
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
 
     def test_expectations_are_always_cleared(self):
 
         class holder:
             test_called = False
 
-        @raises(RuntimeError)
         @fudge.test
         def some_test():
-            holder.test_called = True
-            fake = fudge.Fake('db').expects('save')
-            raise RuntimeError
+            with self.assertRaises(RuntimeError):
+                holder.test_called = True
+                fake = fudge.Fake('db').expects('save')
+                raise RuntimeError
 
         some_test()
         fudge.verify() # should be no errors
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
 
     def test_calls_are_cleared(self):
 
@@ -1277,13 +1278,13 @@ class TestNonPatchedFakeTest(unittest.Te
 
         some_test()
         fudge.verify() # should be no errors
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
 
-    @raises(AssertionError)
     def test_verify(self):
 
         @fudge.test
         def some_test():
             fake = fudge.Fake('db').expects('save')
 
-        some_test()
+        with self.assertRaises(AssertionError):
+            some_test()
--- a/fudge/tests/test_inspector.py
+++ b/fudge/tests/test_inspector.py
@@ -1,12 +1,9 @@
 # -*- coding: utf-8 -*-
-import re
 import unittest
 
-from nose.tools import eq_, raises
-
 import fudge
 from fudge import inspector
-from fudge.inspector import arg, arg_not
+from fudge.inspector import arg
 from fudge import Fake
 
 class TestAnyValue(unittest.TestCase):
@@ -20,11 +17,11 @@ class TestAnyValue(unittest.TestCase):
 
     def test_repr(self):
         any = inspector.AnyValue()
-        eq_(repr(any), "arg.any()")
+        self.assertEqual(repr(any), "arg.any()")
 
     def test_str(self):
         any = inspector.AnyValue()
-        eq_(str(any), "arg.any()")
+        self.assertEqual(str(any), "arg.any()")
 
 
 class TestPassesTest(unittest.TestCase):
@@ -38,12 +35,12 @@ class TestPassesTest(unittest.TestCase):
         counter = Fake("counter").expects("increment").with_args(arg.passes_test(isint))
         counter.increment(25)
 
-    @raises(AssertionError)
     def test_passes_fail(self):
         def is_str(v):
             return isinstance(v,str)
-        counter = Fake("counter").expects("set_name").with_args(arg.passes_test(is_str))
-        counter.set_name(25)
+        with self.assertRaises(AssertionError):
+            counter = Fake("counter").expects("set_name").with_args(arg.passes_test(is_str))
+            counter.set_name(25)
 
     def test_repr(self):
         class test(object):
@@ -53,7 +50,7 @@ class TestPassesTest(unittest.TestCase):
                 return "v is an int"
 
         passes = inspector.PassesTest(test())
-        eq_(repr(passes), "arg.passes_test(v is an int)")
+        self.assertEqual(repr(passes), "arg.passes_test(v is an int)")
 
     def test_str(self):
         class test(object):
@@ -63,7 +60,7 @@ class TestPassesTest(unittest.TestCase):
                 return "v is an int"
 
         passes = inspector.PassesTest(test())
-        eq_(str(passes), "arg.passes_test(v is an int)")
+        self.assertEqual(str(passes), "arg.passes_test(v is an int)")
 
 class TestIsInstance(unittest.TestCase):
 
@@ -74,22 +71,22 @@ class TestIsInstance(unittest.TestCase):
         counter = Fake("counter").expects("increment").with_args(arg.isinstance(int))
         counter.increment(25)
 
-    @raises(AssertionError)
     def test_passes_fail(self):
-        counter = Fake("counter").expects("set_name").with_args(arg.isinstance(str))
-        counter.set_name(25)
+        with self.assertRaises(AssertionError):
+            counter = Fake("counter").expects("set_name").with_args(arg.isinstance(str))
+            counter.set_name(25)
 
     def test_repr(self):
         passes = inspector.IsInstance(int)
-        eq_(repr(passes), "arg.isinstance('int')")
+        self.assertEqual(repr(passes), "arg.isinstance('int')")
 
     def test_str(self):
         passes = inspector.IsInstance(str)
-        eq_(str(passes), "arg.isinstance('str')")
+        self.assertEqual(str(passes), "arg.isinstance('str')")
 
     def test_list(self):
         passes = inspector.IsInstance((str, int))
-        eq_(str(passes), "arg.isinstance(('str', 'int'))")
+        self.assertEqual(str(passes), "arg.isinstance(('str', 'int'))")
 
 class TestObjectlike(unittest.TestCase):
 
@@ -106,40 +103,40 @@ class TestObjectlike(unittest.TestCase):
                                .with_args(arg.has_attr(size=12,color='red'))
         widget.configure(Config())
 
-    @raises(AssertionError)
     def test_has_attr_fail(self):
         class Config(object):
             color = 'red'
 
-        widget = Fake("widget").expects("configure")\
-                               .with_args(arg.has_attr(size=12))
-        widget.configure(Config())
+        with self.assertRaises(AssertionError):
+            widget = Fake("widget").expects("configure")\
+                                   .with_args(arg.has_attr(size=12))
+            widget.configure(Config())
 
-    @raises(AssertionError)
     def test_has_attr_fail_wrong_value(self):
         class Config(object):
             color = 'red'
 
-        widget = Fake("widget").expects("configure")\
-                               .with_args(arg.has_attr(color="green"))
-        widget.configure(Config())
+        with self.assertRaises(AssertionError):
+            widget = Fake("widget").expects("configure")\
+                                   .with_args(arg.has_attr(color="green"))
+            widget.configure(Config())
 
     def test_objectlike_str(self):
         o = inspector.HasAttr(one=1, two="two")
-        eq_(str(o), "arg.has_attr(one=1, two='two')")
+        self.assertEqual(str(o), "arg.has_attr(one=1, two='two')")
 
     def test_objectlike_repr(self):
         o = inspector.HasAttr(one=1, two="two")
-        eq_(repr(o), "arg.has_attr(one=1, two='two')")
+        self.assertEqual(repr(o), "arg.has_attr(one=1, two='two')")
 
     def test_objectlike_unicode(self):
         o = inspector.HasAttr(one=1, ivan=u"Ivan_Krsti\u0107")
-        eq_(repr(o), "arg.has_attr(ivan=%s, one=1)" % repr(u'Ivan_Krsti\u0107'))
+        self.assertEqual(repr(o), "arg.has_attr(ivan=%s, one=1)" % repr(u'Ivan_Krsti\u0107'))
 
     def test_objectlike_repr_long_val(self):
         o = inspector.HasAttr(
                 bytes="011110101000101010011111111110000001010100000001110000000011")
-        eq_(repr(o),
+        self.assertEqual(repr(o),
             "arg.has_attr(bytes='011110101000101010011111111110000001010100000...')")
 
 class TestStringlike(unittest.TestCase):
@@ -151,10 +148,10 @@ class TestStringlike(unittest.TestCase):
         db = Fake("db").expects("execute").with_args(arg.startswith("insert into"))
         db.execute("insert into foo values (1,2,3,4)")
 
-    @raises(AssertionError)
     def test_startswith_fail(self):
-        db = Fake("db").expects("execute").with_args(arg.startswith("insert into"))
-        db.execute("select from")
+        with self.assertRaises(AssertionError):
+            db = Fake("db").expects("execute").with_args(arg.startswith("insert into"))
+            db.execute("select from")
 
     def test_startswith_ok_uni(self):
         db = Fake("db").expects("execute").with_args(arg.startswith(u"Ivan_Krsti\u0107"))
@@ -162,7 +159,7 @@ class TestStringlike(unittest.TestCase):
 
     def test_startswith_unicode(self):
         p = inspector.Startswith(u"Ivan_Krsti\u0107")
-        eq_(repr(p), "arg.startswith(%s)" % repr(u'Ivan_Krsti\u0107'))
+        self.assertEqual(repr(p), "arg.startswith(%s)" % repr(u'Ivan_Krsti\u0107'))
 
     def test_endswith_ok(self):
         db = Fake("db").expects("execute").with_args(arg.endswith("values (1,2,3,4)"))
@@ -174,36 +171,36 @@ class TestStringlike(unittest.TestCase):
 
     def test_endswith_unicode(self):
         p = inspector.Endswith(u"Ivan_Krsti\u0107")
-        eq_(repr(p), "arg.endswith(%s)" % repr(u'Ivan_Krsti\u0107'))
+        self.assertEqual(repr(p), "arg.endswith(%s)" % repr(u'Ivan_Krsti\u0107'))
 
     def test_startswith_repr(self):
         p = inspector.Startswith("_start")
-        eq_(repr(p), "arg.startswith('_start')")
+        self.assertEqual(repr(p), "arg.startswith('_start')")
 
     def test_endswith_repr(self):
         p = inspector.Endswith("_ending")
-        eq_(repr(p), "arg.endswith('_ending')")
+        self.assertEqual(repr(p), "arg.endswith('_ending')")
 
     def test_startswith_str(self):
         p = inspector.Startswith("_start")
-        eq_(str(p), "arg.startswith('_start')")
+        self.assertEqual(str(p), "arg.startswith('_start')")
 
     def test_endswith_str(self):
         p = inspector.Endswith("_ending")
-        eq_(str(p), "arg.endswith('_ending')")
+        self.assertEqual(str(p), "arg.endswith('_ending')")
 
     def test_startswith_str_long_value(self):
         p = inspector.Startswith(
             "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
-        eq_(str(p),
+        self.assertEqual(str(p),
             "arg.startswith('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...')" )
 
     def test_endswith_str_long_value(self):
         p = inspector.Endswith(
             "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         )
-        eq_(str(p),
+        self.assertEqual(str(p),
             "arg.endswith('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...')" )
 
 class TestContains(unittest.TestCase):
@@ -217,11 +214,11 @@ class TestContains(unittest.TestCase):
         db.execute("select * from table foo where bar = 1")
         fudge.verify()
 
-    @raises(AssertionError)
     def test_contains_fail(self):
-        db = Fake("db").expects("execute").with_args(arg.contains("table foo"))
-        db.execute("select into table notyourmama;")
-        fudge.verify()
+        with self.assertRaises(AssertionError):
+            db = Fake("db").expects("execute").with_args(arg.contains("table foo"))
+            db.execute("select into table notyourmama;")
+            fudge.verify()
 
     def test_contains_list(self):
         db = Fake("db").expects("execute_statements").with_args(
@@ -235,20 +232,20 @@ class TestContains(unittest.TestCase):
 
     def test_str(self):
         c = inspector.Contains(":part:")
-        eq_(str(c), "arg.contains(':part:')")
+        self.assertEqual(str(c), "arg.contains(':part:')")
 
     def test_str_long_val(self):
         c = inspector.Contains(
             "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
-        eq_(str(c), "arg.contains('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...')")
+        self.assertEqual(str(c), "arg.contains('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...')")
 
     def test_repr(self):
         c = inspector.Contains(":part:")
-        eq_(repr(c), "arg.contains(':part:')")
+        self.assertEqual(repr(c), "arg.contains(':part:')")
 
     def test_unicode(self):
         c = inspector.Contains(u"Ivan_Krsti\u0107")
-        eq_(repr(c), "arg.contains(%s)" % repr(u'Ivan_Krsti\u0107'))
+        self.assertEqual(repr(c), "arg.contains(%s)" % repr(u'Ivan_Krsti\u0107'))
 
 class TestMakeValueTest(unittest.TestCase):
 
--- a/fudge/tests/test_patcher.py
+++ b/fudge/tests/test_patcher.py
@@ -1,207 +1,203 @@
-from __future__ import with_statement
 import inspect
 import unittest
 
-from nose.exc import SkipTest
-from nose.tools import eq_, raises
-
 import fudge
 
 
 class Freddie(object):
     pass
 
-        
-def test_patch_obj():
-    class holder:
-        exc = Exception()
-    
-    patched = fudge.patch_object(holder, "exc", Freddie())
-    eq_(type(holder.exc), type(Freddie()))
-    patched.restore()
-    eq_(type(holder.exc), type(Exception()))
-
-
-def test_patch_path():
-    from os.path import join as orig_join
-    patched = fudge.patch_object("os.path", "join", Freddie())
-    import os.path
-    eq_(type(os.path.join), type(Freddie()))
-    patched.restore()
-    eq_(type(os.path.join), type(orig_join))
-
-
-def test_patch_builtin():
-    import datetime
-    orig_datetime = datetime.datetime
-    now = datetime.datetime(2010, 11, 4, 8, 19, 11, 28778)
-    fake = fudge.Fake('now').is_callable().returns(now)
-    patched = fudge.patch_object(datetime.datetime, 'now', fake)
-    try:
-        eq_(datetime.datetime.now(), now)
-    finally:
+
+class PatcherTest(unittest.TestCase):
+    def test_patch_obj(self):
+        class holder:
+            exc = Exception()
+
+        patched = fudge.patch_object(holder, "exc", Freddie())
+        self.assertEqual(type(holder.exc), type(Freddie()))
         patched.restore()
-    eq_(datetime.datetime.now, orig_datetime.now)
+        self.assertEqual(type(holder.exc), type(Exception()))
 
 
-def test_patch_long_path():
-    import fudge.tests.support._for_patch
-    orig = fudge.tests.support._for_patch.some_object.inner
-    long_path = 'fudge.tests.support._for_patch.some_object.inner'
-    with fudge.patch(long_path) as fake:
-        assert isinstance(fake, fudge.Fake)
-    eq_(fudge.tests.support._for_patch.some_object.inner, orig)
-
-
-@raises(ImportError)
-def test_patch_non_existant_path():
-    with fudge.patch('__not_a_real_import_path.nested.one.two.three') as fake:
-        pass
-
-
-@raises(AttributeError)
-def test_patch_non_existant_attribute():
-    with fudge.patch('fudge.tests.support._for_patch.does.not.exist') as fake:
-        pass
-
-
-def test_patch_builtin_as_string():
-    import datetime
-    orig_datetime = datetime.datetime
-    now = datetime.datetime(2006, 11, 4, 8, 19, 11, 28778)
-    fake_dt = fudge.Fake('datetime').provides('now').returns(now)
-    patched = fudge.patch_object('datetime', 'datetime', fake_dt)
-    try:
-        # timetuple is a workaround for strange Jython behavior!
-        eq_(datetime.datetime.now().timetuple(), now.timetuple())
-    finally:
+    def test_patch_path(self):
+        from os.path import join as orig_join
+        patched = fudge.patch_object("os.path", "join", Freddie())
+        import os.path
+        self.assertEqual(type(os.path.join), type(Freddie()))
         patched.restore()
-    eq_(datetime.datetime.now, orig_datetime.now)
+        self.assertEqual(type(os.path.join), type(orig_join))
 
 
-def test_decorator_on_def():
-    class holder:
-        test_called = False
-        exc = Exception()
-        
-    @fudge.with_patched_object(holder, "exc", Freddie())
-    def some_test():
-        holder.test_called = True
-        eq_(type(holder.exc), type(Freddie()))
-    
-    eq_(some_test.__name__, 'some_test')
-    some_test()
-    eq_(holder.test_called, True)
-    eq_(type(holder.exc), type(Exception()))
-
-
-def test_decorator_on_class():
-    class holder:
-        test_called = False
-        exc = Exception()
-    
-    class SomeTest(object):
-        
+    def test_patch_builtin(self):
+        import datetime
+        orig_datetime = datetime.datetime
+        now = datetime.datetime(2010, 11, 4, 8, 19, 11, 28778)
+        fake = fudge.Fake('now').is_callable().returns(now)
+        patched = fudge.patch_object(datetime.datetime, 'now', fake)
+        try:
+            self.assertEqual(datetime.datetime.now(), now)
+        finally:
+            patched.restore()
+        self.assertEqual(datetime.datetime.now, orig_datetime.now)
+
+
+    def test_patch_long_path(self):
+        import fudge.tests.support._for_patch
+        orig = fudge.tests.support._for_patch.some_object.inner
+        long_path = 'fudge.tests.support._for_patch.some_object.inner'
+        with fudge.patch(long_path) as fake:
+            assert isinstance(fake, fudge.Fake)
+        self.assertEqual(fudge.tests.support._for_patch.some_object.inner, orig)
+
+
+    def test_patch_non_existant_path(self):
+        with self.assertRaises(ImportError):
+            with fudge.patch('__not_a_real_import_path.nested.one.two.three') as fake:
+                pass
+
+
+    def test_patch_non_existant_attribute(self):
+        with self.assertRaises(AttributeError):
+            with fudge.patch('fudge.tests.support._for_patch.does.not.exist') as fake:
+                pass
+
+    def test_patch_builtin_as_string(self):
+        import datetime
+        orig_datetime = datetime.datetime
+        now = datetime.datetime(2006, 11, 4, 8, 19, 11, 28778)
+        fake_dt = fudge.Fake('datetime').provides('now').returns(now)
+        patched = fudge.patch_object('datetime', 'datetime', fake_dt)
+        try:
+            # timetuple is a workaround for strange Jython behavior!
+            self.assertEqual(datetime.datetime.now().timetuple(), now.timetuple())
+        finally:
+            patched.restore()
+        self.assertEqual(datetime.datetime.now, orig_datetime.now)
+
+
+    def test_decorator_on_def(self):
+        class holder:
+            test_called = False
+            exc = Exception()
+
         @fudge.with_patched_object(holder, "exc", Freddie())
-        def some_test(self):
+        def some_test():
             holder.test_called = True
-            eq_(type(holder.exc), type(Freddie()))
-    
-    eq_(SomeTest.some_test.__name__, 'some_test')
-    s = SomeTest()
-    s.some_test()
-    eq_(holder.test_called, True)
-    eq_(type(holder.exc), type(Exception()))
-
-
-def test_patched_context():
-    if not hasattr(fudge, "patched_context"):
-        raise SkipTest("Cannot test with patched_context() because not in 2.5")
-    
-    class Boo:
-        fargo = "is over there"
-    
-    ctx = fudge.patched_context(Boo, 'fargo', 'is right here')
-    # simulate with fudge.patched_context():
-    ctx.__enter__()
-    eq_(Boo.fargo, "is right here")
-    ctx.__exit__(None, None, None)
-    eq_(Boo.fargo, "is over there")
-
-
-def test_base_class_attribute():
-    class Base(object):
-        foo = 'bar'
-    class Main(Base):
-        pass
-    fake = fudge.Fake()
-    p = fudge.patch_object(Main, 'foo', fake)
-    eq_(Main.foo, fake)
-    eq_(Base.foo, 'bar')
-    p.restore()
-    eq_(Main.foo, 'bar')
-    assert 'foo' not in Main.__dict__, ('Main.foo was not restored correctly')
-
-
-def test_bound_methods():
-    class Klass(object):
-        def method(self):
-            return 'foozilate'
-    instance = Klass()
-    fake = fudge.Fake()
-    p = fudge.patch_object(instance, 'method', fake)
-    eq_(instance.method, fake)
-    p.restore()
-    eq_(instance.method(), Klass().method())
-    assert inspect.ismethod(instance.method)
-    assert 'method' not in instance.__dict__, (
-                            'instance.method was not restored correctly')
-
-
-def test_staticmethod_descriptor():
-    class Klass(object):
-        @staticmethod
-        def static():
-            return 'OK'
-    fake = fudge.Fake()
-    p = fudge.patch_object(Klass, 'static', fake)
-    eq_(Klass.static, fake)
-    p.restore()
-    eq_(Klass.static(), 'OK')
-
-
-def test_property():
-    class Klass(object):
-        @property
-        def prop(self):
-            return 'OK'
-    exact_prop = Klass.prop
-    instance = Klass()
-    fake = fudge.Fake()
-    p = fudge.patch_object(instance, 'prop', fake)
-    eq_(instance.prop, fake)
-    p.restore()
-    eq_(instance.prop, 'OK')
-    eq_(Klass.prop, exact_prop)
-
-
-def test_inherited_property():
-    class SubKlass(object):
-        @property
-        def prop(self):
-            return 'OK'
-    class Klass(SubKlass):
-        pass
-    exact_prop = SubKlass.prop
-    instance = Klass()
-    fake = fudge.Fake()
-    p = fudge.patch_object(instance, 'prop', fake)
-    eq_(instance.prop, fake)
-    p.restore()
-    eq_(instance.prop, 'OK')
-    assert 'prop' not in Klass.__dict__, (
-                                'Klass.prop was not restored properly')
-    eq_(SubKlass.prop, exact_prop)
+            self.assertEqual(type(holder.exc), type(Freddie()))
+
+        self.assertEqual(some_test.__name__, 'some_test')
+        some_test()
+        self.assertEqual(holder.test_called, True)
+        self.assertEqual(type(holder.exc), type(Exception()))
+
+
+    def test_decorator_on_class(self):
+        class holder:
+            test_called = False
+            exc = Exception()
+
+        class SomeTest(object):
+
+            @fudge.with_patched_object(holder, "exc", Freddie())
+            def some_test(self):
+                holder.test_called = True
+                assert isinstance(holder.exc, Freddie)
+
+        self.assertEqual(SomeTest.some_test.__name__, 'some_test')
+        s = SomeTest()
+        s.some_test()
+        self.assertEqual(holder.test_called, True)
+        self.assertEqual(type(holder.exc), type(Exception()))
+
+
+    def test_patched_context(self):
+        if not hasattr(fudge, "patched_context"):
+            raise unittest.SkipTest("Cannot test with patched_context() because not in 2.5")
+
+        class Boo:
+            fargo = "is over there"
+
+        ctx = fudge.patched_context(Boo, 'fargo', 'is right here')
+        # simulate with fudge.patched_context():
+        ctx.__enter__()
+        self.assertEqual(Boo.fargo, "is right here")
+        ctx.__exit__(None, None, None)
+        self.assertEqual(Boo.fargo, "is over there")
+
+
+    def test_base_class_attribute(self):
+        class Base(object):
+            foo = 'bar'
+        class Main(Base):
+            pass
+        fake = fudge.Fake()
+        p = fudge.patch_object(Main, 'foo', fake)
+        self.assertEqual(Main.foo, fake)
+        self.assertEqual(Base.foo, 'bar')
+        p.restore()
+        self.assertEqual(Main.foo, 'bar')
+        assert 'foo' not in Main.__dict__, ('Main.foo was not restored correctly')
+
+
+    def test_bound_methods(self):
+        class Klass(object):
+            def method(self):
+                return 'foozilate'
+        instance = Klass()
+        fake = fudge.Fake()
+        p = fudge.patch_object(instance, 'method', fake)
+        self.assertEqual(instance.method, fake)
+        p.restore()
+        self.assertEqual(instance.method(), Klass().method())
+        assert inspect.ismethod(instance.method)
+        assert 'method' not in instance.__dict__, (
+                                'instance.method was not restored correctly')
+
+
+    def test_staticmethod_descriptor(self):
+        class Klass(object):
+            @staticmethod
+            def static():
+                return 'OK'
+        fake = fudge.Fake()
+        p = fudge.patch_object(Klass, 'static', fake)
+        self.assertEqual(Klass.static, fake)
+        p.restore()
+        self.assertEqual(Klass.static(), 'OK')
+
+
+    def test_property(self):
+        class Klass(object):
+            @property
+            def prop(self):
+                return 'OK'
+        exact_prop = Klass.prop
+        instance = Klass()
+        fake = fudge.Fake()
+        p = fudge.patch_object(instance, 'prop', fake)
+        self.assertEqual(instance.prop, fake)
+        p.restore()
+        self.assertEqual(instance.prop, 'OK')
+        self.assertEqual(Klass.prop, exact_prop)
+
+
+    def test_inherited_property(self):
+        class SubKlass(object):
+            @property
+            def prop(self):
+                return 'OK'
+        class Klass(SubKlass):
+            pass
+        exact_prop = SubKlass.prop
+        instance = Klass()
+        fake = fudge.Fake()
+        p = fudge.patch_object(instance, 'prop', fake)
+        self.assertEqual(instance.prop, fake)
+        p.restore()
+        self.assertEqual(instance.prop, 'OK')
+        assert 'prop' not in Klass.__dict__, (
+                                    'Klass.prop was not restored properly')
+        self.assertEqual(SubKlass.prop, exact_prop)
 
 
 class TestPatch(unittest.TestCase):
@@ -213,17 +209,17 @@ class TestPatch(unittest.TestCase):
 
         class holder:
             test_called = False
-        
+
         @fudge.patch('shutil.copy')
         def some_test(copy):
             import shutil
             holder.test_called = True
             assert isinstance(copy, fudge.Fake)
-            eq_(copy, shutil.copy)
-    
-        eq_(some_test.__name__, 'some_test')
+            self.assertEqual(copy, shutil.copy)
+
+        self.assertEqual(some_test.__name__, 'some_test')
         some_test()
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
         import shutil
         assert not isinstance(shutil.copy, fudge.Fake)
 
@@ -232,7 +228,7 @@ class TestPatch(unittest.TestCase):
 
         class holder:
             test_called = False
-    
+
         class MyTest(object):
 
             @fudge.patch('shutil.copy')
@@ -240,12 +236,12 @@ class TestPatch(unittest.TestCase):
                 import shutil
                 holder.test_called = True
                 assert isinstance(copy, fudge.Fake)
-                eq_(copy, shutil.copy)
-    
-        eq_(MyTest.some_test.__name__, 'some_test')
+                assert copy == shutil.copy
+
+        self.assertEqual(MyTest.some_test.__name__, 'some_test')
         m = MyTest()
         m.some_test()
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
         import shutil
         assert not isinstance(shutil.copy, fudge.Fake)
 
@@ -253,7 +249,7 @@ class TestPatch(unittest.TestCase):
 
         class holder:
             test_called = False
-        
+
         @fudge.patch('shutil.copy',
                      'os.remove')
         def some_test(copy, remove):
@@ -262,12 +258,12 @@ class TestPatch(unittest.TestCase):
             holder.test_called = True
             assert isinstance(copy, fudge.Fake)
             assert isinstance(remove, fudge.Fake)
-            eq_(copy, shutil.copy)
-            eq_(remove, os.remove)
-    
-        eq_(some_test.__name__, 'some_test')
+            self.assertEqual(copy, shutil.copy)
+            self.assertEqual(remove, os.remove)
+
+        self.assertEqual(some_test.__name__, 'some_test')
         some_test()
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
         import shutil
         assert not isinstance(shutil.copy, fudge.Fake)
         import os
@@ -282,11 +278,11 @@ class TestPatch(unittest.TestCase):
             with fudge.patch('shutil.copy') as copy:
                 import shutil
                 assert isinstance(copy, fudge.Fake)
-                eq_(copy, shutil.copy)
+                self.assertEqual(copy, shutil.copy)
                 holder.test_called = True
-        
+
         run_test()
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
         import shutil
         assert not isinstance(shutil.copy, fudge.Fake)
 
@@ -302,12 +298,12 @@ class TestPatch(unittest.TestCase):
                 import os
                 assert isinstance(copy, fudge.Fake)
                 assert isinstance(remove, fudge.Fake)
-                eq_(copy, shutil.copy)
-                eq_(remove, os.remove)
+                self.assertEqual(copy, shutil.copy)
+                self.assertEqual(remove, os.remove)
                 holder.test_called = True
-        
+
         run_test()
-        eq_(holder.test_called, True)
+        self.assertEqual(holder.test_called, True)
         import shutil
         assert not isinstance(shutil.copy, fudge.Fake)
         import os
--- a/fudge/tests/test_registry.py
+++ b/fudge/tests/test_registry.py
@@ -1,109 +1,108 @@
-
-import thread
+try:
+    import _thread as thread
+except ImportError:
+    import thread
 import sys
 import unittest
 import fudge
-from nose.exc import SkipTest
-from nose.tools import eq_, raises
-from fudge import (
-    Fake, Registry, ExpectedCall, ExpectedCallOrder, Call, CallStack, FakeDeclarationError)
+from fudge import ExpectedCall, ExpectedCallOrder
 
 class TestRegistry(unittest.TestCase):
-    
+
     def setUp(self):
         self.fake = fudge.Fake()
         self.reg = fudge.registry
         # in case of error, clear out everything:
         self.reg.clear_all()
-    
+
     def tearDown(self):
         pass
-    
-    @raises(AssertionError)
+
     def test_expected_call_not_called(self):
-        self.reg.clear_calls()
-        self.reg.expect_call(ExpectedCall(self.fake, 'nothing'))
-        self.reg.verify()
-        
+        with self.assertRaises(AssertionError):
+            self.reg.clear_calls()
+            self.reg.expect_call(ExpectedCall(self.fake, 'nothing'))
+            self.reg.verify()
+
     def test_clear_calls_resets_calls(self):
         exp = ExpectedCall(self.fake, 'callMe')
         self.reg.expect_call(exp)
         exp()
-        eq_(exp.was_called, True)
-        
+        self.assertEqual(exp.was_called, True)
+
         self.reg.clear_calls()
-        eq_(exp.was_called, False, "call was not reset by clear_calls()")
-        
+        self.assertEqual(exp.was_called, False, "call was not reset by clear_calls()")
+
     def test_clear_calls_resets_call_order(self):
         exp_order = ExpectedCallOrder(self.fake)
         exp = ExpectedCall(self.fake, 'callMe', call_order=exp_order)
         exp_order.add_expected_call(exp)
         self.reg.remember_expected_call_order(exp_order)
-        
+
         exp()
-        eq_(exp_order._actual_calls, [exp])
-        
+        self.assertEqual(exp_order._actual_calls, [exp])
+
         self.reg.clear_calls()
-        eq_(exp_order._actual_calls, [], "call order calls were not reset by clear_calls()")
-    
+        self.assertEqual(exp_order._actual_calls, [], "call order calls were not reset by clear_calls()")
+
     def test_verify_resets_calls(self):
         exp = ExpectedCall(self.fake, 'callMe')
         exp()
-        eq_(exp.was_called, True)
-        eq_(len(self.reg.get_expected_calls()), 1)
-        
+        self.assertEqual(exp.was_called, True)
+        self.assertEqual(len(self.reg.get_expected_calls()), 1)
+
         self.reg.verify()
-        eq_(exp.was_called, False, "call was not reset by verify()")
-        eq_(len(self.reg.get_expected_calls()), 1, "verify() should not reset expectations")
-        
+        self.assertEqual(exp.was_called, False, "call was not reset by verify()")
+        self.assertEqual(len(self.reg.get_expected_calls()), 1, "verify() should not reset expectations")
+
     def test_verify_resets_call_order(self):
         exp_order = ExpectedCallOrder(self.fake)
         exp = ExpectedCall(self.fake, 'callMe', call_order=exp_order)
         exp_order.add_expected_call(exp)
         self.reg.remember_expected_call_order(exp_order)
-        
+
         exp()
-        eq_(exp_order._actual_calls, [exp])
-        
+        self.assertEqual(exp_order._actual_calls, [exp])
+
         self.reg.verify()
-        eq_(exp_order._actual_calls, [], "call order calls were not reset by verify()")
-    
+        self.assertEqual(exp_order._actual_calls, [], "call order calls were not reset by verify()")
+
     def test_global_verify(self):
         exp = ExpectedCall(self.fake, 'callMe')
         exp()
-        eq_(exp.was_called, True)
-        eq_(len(self.reg.get_expected_calls()), 1)
-        
+        self.assertEqual(exp.was_called, True)
+        self.assertEqual(len(self.reg.get_expected_calls()), 1)
+
         fudge.verify()
-        
-        eq_(exp.was_called, False, "call was not reset by verify()")
-        eq_(len(self.reg.get_expected_calls()), 1, "verify() should not reset expectations")
-    
+
+        self.assertEqual(exp.was_called, False, "call was not reset by verify()")
+        self.assertEqual(len(self.reg.get_expected_calls()), 1, "verify() should not reset expectations")
+
     def test_global_clear_expectations(self):
         exp = ExpectedCall(self.fake, 'callMe')
         exp()
-        eq_(len(self.reg.get_expected_calls()), 1)
+        self.assertEqual(len(self.reg.get_expected_calls()), 1)
         exp_order = ExpectedCallOrder(self.fake)
         self.reg.remember_expected_call_order(exp_order)
-        eq_(self.reg.get_expected_call_order().keys(), [self.fake])
-        
+        self.assertEqual(self.reg.get_expected_call_order().keys(), [self.fake])
+
         fudge.clear_expectations()
-        
-        eq_(len(self.reg.get_expected_calls()), 0, 
+
+        self.assertEqual(len(self.reg.get_expected_calls()), 0,
             "clear_expectations() should reset expectations")
-        eq_(len(self.reg.get_expected_call_order().keys()), 0,
+        self.assertEqual(len(self.reg.get_expected_call_order().keys()), 0,
             "clear_expectations() should reset expected call order")
-    
+
     def test_multithreading(self):
         if sys.platform.startswith('java'):
-            raise SkipTest('this test is flaky in Jython')
+            raise unittest.SkipTest('this test is flaky in Jython')
 
         reg = fudge.registry
-        
+
         class thread_run:
             waiting = 5
             errors = []
-        
+
         # while this barely catches collisions
         # it ensures that each thread can use the registry ok
         def registry(num):
@@ -111,32 +110,32 @@ class TestRegistry(unittest.TestCase):
                 try:
                     fudge.clear_calls()
                     fudge.clear_expectations()
-                    
+
                     exp_order = ExpectedCallOrder(self.fake)
                     reg.remember_expected_call_order(exp_order)
-                    eq_(len(reg.get_expected_call_order().keys()), 1)
-                    
+                    self.assertEqual(len(reg.get_expected_call_order().keys()), 1)
+
                     # registered first time on __init__ :
-                    exp = ExpectedCall(self.fake, 'callMe', call_order=exp_order) 
+                    exp = ExpectedCall(self.fake, 'callMe', call_order=exp_order)
                     reg.expect_call(exp)
                     reg.expect_call(exp)
                     reg.expect_call(exp)
-                    eq_(len(reg.get_expected_calls()), 4)
-                    
+                    self.assertEqual(len(reg.get_expected_calls()), 4)
+
                     # actual calls:
                     exp()
                     exp()
                     exp()
                     exp()
-                    
+
                     fudge.verify()
                     fudge.clear_expectations()
-                except Exception, er:
+                except Exception as er:
                     thread_run.errors.append(er)
                     raise
             finally:
                 thread_run.waiting -= 1
-                
+
         thread.start_new_thread(registry, (1,))
         thread.start_new_thread(registry, (2,))
         thread.start_new_thread(registry, (3,))
--- a/fudge/__init__.py
+++ b/fudge/__init__.py
@@ -9,7 +9,10 @@ __version__ = '1.1.1'
 import os
 import re
 import sys
-import thread
+try:
+    import _thread as thread
+except ImportError:
+    import thread
 import warnings
 from fudge.exc import FakeDeclarationError
 from fudge.patcher import *
--- a/fudge/patcher.py
+++ b/fudge/patcher.py
@@ -9,6 +9,7 @@ __all__ = ['patch_object', 'with_patched
 
 import sys
 
+import six
 import fudge
 from fudge.util import wraps
 
@@ -80,7 +81,7 @@ class patch(object):
             except:
                 etype, val, tb = sys.exc_info()
                 self.__exit__(etype, val, tb)
-                raise etype, val, tb
+                six.reraise(etype, val, tb)
             else:
                 self.__exit__(None, None, None)
             return value
@@ -239,7 +240,7 @@ def patch_object(obj, attr_name, patched
         'clean'
         
     """
-    if isinstance(obj, (str, unicode)):
+    if isinstance(obj, six.string_types):
         obj_path = adjusted_path = obj
         done = False
         exc = None
@@ -259,7 +260,7 @@ def patch_object(obj, attr_name, patched
                     # We're at the top level module and it doesn't exist.
                     # Raise the first exception since it will make more sense:
                     etype, val, tb = exc
-                    raise etype, val, tb
+                    six.reraise(etype, val, tb)
                 if not adjusted_path.count('.'):
                     at_top_level = True
         for part in obj_path.split('.')[1:]:
--- a/fudge/inspector.py
+++ b/fudge/inspector.py
@@ -21,6 +21,7 @@ should end with the suffix ".jpg"
 
 """
 import warnings
+import six
 
 from fudge.util import fmt_val, fmt_dict_vals
 
@@ -505,7 +506,7 @@ class Stringlike(ValueTest):
         return self._make_argspec(fmt_val(self.part))
 
     def stringlike(self, value):
-        if isinstance(value, (str, unicode)):
+        if isinstance(value, six.string_types):
             return value
         else:
             return str(value)
--- a/setup.py
+++ b/setup.py
@@ -51,7 +51,7 @@ email without actually sending email::
     author_email='kumar.mcmillan@gmail.com',
     license="The MIT License",
     packages=find_packages(exclude=['ez_setup']),
-    install_requires=[],
+    install_requires=['six'],
     url='https://github.com/fudge-py/fudge',
     include_package_data=True,
     classifiers = [

Places

File remove_nose.patch of Package python-fudge (Revision aa524bd930495dcfce475bfc4b0fd7dc)

Places