diff --git a/tests/regressiontests/dispatch/tests/test_dispatcher.py b/tests/regressiontests/dispatch/tests/test_dispatcher.py index bfa3ee9a97..0bc99a1505 100644 --- a/tests/regressiontests/dispatch/tests/test_dispatcher.py +++ b/tests/regressiontests/dispatch/tests/test_dispatcher.py @@ -1,147 +1,144 @@ from django.dispatch.dispatcher import * from django.dispatch import dispatcher, robust - -import unittest, pprint, copy +import unittest +import copy def x(a): return a -class Dummy( object ): +class Dummy(object): pass - class Callable(object): - - def __call__( self, a ): + def __call__(self, a): return a - - def a( self, a ): + + def a(self, a): return a - class DispatcherTests(unittest.TestCase): """Test suite for dispatcher (barely started)""" - + def setUp(self): # track the initial state, since it's possible that others have bleed receivers in self.sendersBack = copy.copy(dispatcher.sendersBack) self.connections = copy.copy(dispatcher.connections) self.senders = copy.copy(dispatcher.senders) - - def _isclean( self ): + + def _testIsClean(self): """Assert that everything has been cleaned up automatically""" self.assertEqual(dispatcher.sendersBack, self.sendersBack) self.assertEqual(dispatcher.connections, self.connections) self.assertEqual(dispatcher.senders, self.senders) - def testExact (self): + def testExact(self): a = Dummy() signal = 'this' - connect( x, signal, a ) + connect(x, signal, a) expected = [(x,a)] result = send('this',a, a=a) self.assertEqual(result, expected) - disconnect( x, signal, a ) - self.assertEqual(len(list(getAllReceivers(a,signal))), 0) - self._isclean() - + disconnect(x, signal, a) + self.assertEqual(list(getAllReceivers(a,signal)), []) + self._testIsClean() + def testAnonymousSend(self): a = Dummy() signal = 'this' - connect( x, signal ) + connect(x, signal) expected = [(x,a)] result = send(signal,None, a=a) - assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) - disconnect( x, signal ) - assert len(list(getAllReceivers(None,signal))) == 0 - self._isclean() - + self.assertEqual(result, expected) + disconnect(x, signal) + self.assertEqual(list(getAllReceivers(None,signal)), []) + self._testIsClean() + def testAnyRegistration(self): a = Dummy() signal = 'this' - connect( x, signal, Any ) + connect(x, signal, Any) expected = [(x,a)] result = send('this',object(), a=a) - assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) - disconnect( x, signal, Any ) + self.assertEqual(result, expected) + disconnect(x, signal, Any) expected = [] result = send('this',object(), a=a) - assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) - assert len(list(getAllReceivers(Any,signal))) == 0 - - self._isclean() + self.assertEqual(result, expected) + self.assertEqual(list(getAllReceivers(Any,signal)), []) + self._testIsClean() + def testAnyRegistration2(self): a = Dummy() signal = 'this' - connect( x, Any, a ) + connect(x, Any, a) expected = [(x,a)] result = send('this',a, a=a) - assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) - disconnect( x, Any, a ) - assert len(list(getAllReceivers(a,Any))) == 0 - self._isclean() - + self.assertEqual(result, expected) + disconnect(x, Any, a) + self.assertEqual(list(getAllReceivers(a,Any)), []) + self._testIsClean() + def testGarbageCollected(self): a = Callable() b = Dummy() signal = 'this' - connect( a.a, signal, b ) - expected = [] - del a - result = send('this',b, a=b) - assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) - assert len(list(getAllReceivers(b,signal))) == 0, """Remaining handlers: %s"""%(getAllReceivers(b,signal),) - self._isclean() - - def testGarbageCollectedObj(self): - class x: - def __call__( self, a ): - return a - a = Callable() - b = Dummy() - signal = 'this' - connect( a, signal, b ) + connect(a.a, signal, b) expected = [] del a result = send('this',b, a=b) self.assertEqual(result, expected) - self.assertEqual(len(list(getAllReceivers(b,signal))), 0) - self._isclean() - + self.assertEqual(list(getAllReceivers(b,signal)), []) + self._testIsClean() + + def testGarbageCollectedObj(self): + class x: + def __call__(self, a): + return a + a = Callable() + b = Dummy() + signal = 'this' + connect(a, signal, b) + expected = [] + del a + result = send('this',b, a=b) + self.assertEqual(result, expected) + self.assertEqual(list(getAllReceivers(b,signal)), []) + self._testIsClean() + def testMultipleRegistration(self): a = Callable() b = Dummy() signal = 'this' - connect( a, signal, b ) - connect( a, signal, b ) - connect( a, signal, b ) - connect( a, signal, b ) - connect( a, signal, b ) - connect( a, signal, b ) + connect(a, signal, b) + connect(a, signal, b) + connect(a, signal, b) + connect(a, signal, b) + connect(a, signal, b) + connect(a, signal, b) result = send('this',b, a=b) - assert len( result ) == 1, result - assert len(list(getAllReceivers(b,signal))) == 1, """Remaining handlers: %s"""%(getAllReceivers(b,signal),) + self.assertEqual(len(result), 1) + self.assertEqual(len(list(getAllReceivers(b,signal))), 1) del a del b del result - self._isclean() - - def testRobust( self ): + self._testIsClean() + + def testRobust(self): """Test the sendRobust function""" - def fails( ): - raise ValueError( 'this' ) + def fails(): + raise ValueError('this') a = object() signal = 'this' - connect( fails, Any, a ) + connect(fails, Any, a) result = robust.sendRobust('this',a, a=a) err = result[0][1] - assert isinstance( err, ValueError ) - assert err.args == ('this',) + self.assert_(isinstance(err, ValueError)) + self.assertEqual(err.args, ('this',)) def getSuite(): return unittest.makeSuite(DispatcherTests,'test') - + if __name__ == "__main__": unittest.main () diff --git a/tests/regressiontests/dispatch/tests/test_robustapply.py b/tests/regressiontests/dispatch/tests/test_robustapply.py index a70d968c6b..499450eec4 100644 --- a/tests/regressiontests/dispatch/tests/test_robustapply.py +++ b/tests/regressiontests/dispatch/tests/test_robustapply.py @@ -1,22 +1,29 @@ from django.dispatch.robustapply import * import unittest + def noArgument(): pass -def oneArgument (blah): + +def oneArgument(blah): pass + def twoArgument(blah, other): pass -class TestCases( unittest.TestCase ): - def test01( self ): - robustApply(noArgument ) - def test02( self ): - self.assertRaises( TypeError, robustApply, noArgument, "this" ) - def test03( self ): - self.assertRaises( TypeError, robustApply, oneArgument ) - def test04( self ): + +class TestCases(unittest.TestCase): + def test01(self): + robustApply(noArgument) + + def test02(self): + self.assertRaises(TypeError, robustApply, noArgument, "this") + + def test03(self): + self.assertRaises(TypeError, robustApply, oneArgument) + + def test04(self): """Raise error on duplication of a particular argument""" - self.assertRaises( TypeError, robustApply, oneArgument, "this", blah = "that" ) + self.assertRaises(TypeError, robustApply, oneArgument, "this", blah = "that") def getSuite(): return unittest.makeSuite(TestCases,'test') diff --git a/tests/regressiontests/dispatch/tests/test_saferef.py b/tests/regressiontests/dispatch/tests/test_saferef.py index eac7d1e5a1..233a2023e0 100644 --- a/tests/regressiontests/dispatch/tests/test_saferef.py +++ b/tests/regressiontests/dispatch/tests/test_saferef.py @@ -1,69 +1,70 @@ from django.dispatch.saferef import * import unittest -class Test1( object): - def x( self ): + +class Test1(object): + def x(self): pass + def test2(obj): pass -class Test2( object ): - def __call__( self, obj ): + +class Test2(object): + def __call__(self, obj): pass -class Tester (unittest.TestCase): - def setUp (self): + +class Tester(unittest.TestCase): + def setUp(self): ts = [] ss = [] - for x in xrange( 5000 ): + for x in xrange(5000): t = Test1() - ts.append( t) - s = safeRef(t.x, self._closure ) - ss.append( s) - ts.append( test2 ) - ss.append( safeRef(test2, self._closure) ) - for x in xrange( 30 ): + ts.append(t) + s = safeRef(t.x, self._closure) + ss.append(s) + ts.append(test2) + ss.append(safeRef(test2, self._closure)) + for x in xrange(30): t = Test2() - ts.append( t) - s = safeRef(t, self._closure ) - ss.append( s) + ts.append(t) + s = safeRef(t, self._closure) + ss.append(s) self.ts = ts self.ss = ss self.closureCount = 0 - def tearDown( self ): + + def tearDown(self): del self.ts del self.ss + def testIn(self): """Test the "in" operator for safe references (cmp)""" for t in self.ts[:50]: - assert safeRef(t.x) in self.ss + self.assert_(safeRef(t.x) in self.ss) + def testValid(self): """Test that the references are valid (return instance methods)""" for s in self.ss: - assert s() + self.assert_(s()) + def testShortCircuit (self): """Test that creation short-circuits to reuse existing references""" sd = {} for s in self.ss: sd[s] = 1 for t in self.ts: - if hasattr( t, 'x'): - assert sd.has_key( safeRef(t.x)) + if hasattr(t, 'x'): + self.assert_(sd.has_key(safeRef(t.x))) else: - assert sd.has_key( safeRef(t)) + self.assert_(sd.has_key(safeRef(t))) + def testRepresentation (self): """Test that the reference object's representation works - + XXX Doesn't currently check the results, just that no error is raised """ - repr( self.ss[-1] ) - - def test(self): - self.closureCount = 0 - wholeI = len(self.ts) - for i in xrange( len(self.ts)-1, -1, -1): - del self.ts[i] - if wholeI-i != self.closureCount: - """Unexpected number of items closed, expected %s, got %s closed"""%( wholeI-i,self.closureCount) + repr(self.ss[-1]) def _closure(self, ref): """Dumb utility mechanism to increment deletion counter""" @@ -73,4 +74,4 @@ def getSuite(): return unittest.makeSuite(Tester,'test') if __name__ == "__main__": - unittest.main () + unittest.main()