Django

Code

Changeset 4589

Show
Ignore:
Timestamp:
02/25/07 21:44:36 (2 years ago)
Author:
jacob
Message:

Updated the dispatch unit tests to be consistant with our coding style.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/trunk/tests/regressiontests/dispatch/tests/test_dispatcher.py

    r4588 r4589  
    11from django.dispatch.dispatcher import * 
    22from django.dispatch import dispatcher, robust 
    3  
    4 import unittest, pprint, copy 
     3import unittest 
     4import copy 
    55 
    66def x(a): 
    77    return a 
    88 
    9 class Dummy( object ): 
     9class Dummy(object): 
    1010    pass 
    1111 
    12  
    1312class Callable(object): 
    14  
    15     def __call__( self, a ): 
     13    def __call__(self, a): 
    1614        return a 
    17  
    18     def a( self, a ): 
     15     
     16    def a(self, a): 
    1917        return a 
    20  
    2118 
    2219class DispatcherTests(unittest.TestCase): 
    2320    """Test suite for dispatcher (barely started)""" 
    24  
     21     
    2522    def setUp(self): 
    2623        # track the initial state, since it's possible that others have bleed receivers in 
    …… 
    2825        self.connections = copy.copy(dispatcher.connections) 
    2926        self.senders = copy.copy(dispatcher.senders) 
    30          
    31     def _isclean( self ): 
     27     
     28    def _testIsClean(self): 
    3229        """Assert that everything has been cleaned up automatically""" 
    3330        self.assertEqual(dispatcher.sendersBack, self.sendersBack) 
    …… 
    3532        self.assertEqual(dispatcher.senders, self.senders) 
    3633     
    37     def testExact (self): 
     34    def testExact(self): 
    3835        a = Dummy() 
    3936        signal = 'this' 
    40         connect( x, signal, a ) 
     37        connect(x, signal, a) 
    4138        expected = [(x,a)] 
    4239        result = send('this',a, a=a) 
    4340        self.assertEqual(result, expected) 
    44         disconnect( x, signal, a ) 
    45         self.assertEqual(len(list(getAllReceivers(a,signal))), 0) 
    46         self._isclean() 
    47  
     41        disconnect(x, signal, a) 
     42        self.assertEqual(list(getAllReceivers(a,signal)), []) 
     43        self._testIsClean() 
     44     
    4845    def testAnonymousSend(self): 
    4946        a = Dummy() 
    5047        signal = 'this' 
    51         connect( x, signal ) 
     48        connect(x, signal) 
    5249        expected = [(x,a)] 
    5350        result = send(signal,None, a=a) 
    54         assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) 
    55         disconnect( x, signal ) 
    56         assert len(list(getAllReceivers(None,signal))) == 0 
    57         self._isclean() 
    58  
     51        self.assertEqual(result, expected) 
     52        disconnect(x, signal) 
     53        self.assertEqual(list(getAllReceivers(None,signal)), []) 
     54        self._testIsClean() 
     55     
    5956    def testAnyRegistration(self): 
    6057        a = Dummy() 
    6158        signal = 'this' 
    62         connect( x, signal, Any ) 
     59        connect(x, signal, Any) 
    6360        expected = [(x,a)] 
    6461        result = send('this',object(), a=a) 
    65         assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) 
    66         disconnect( x, signal, Any ) 
     62        self.assertEqual(result, expected) 
     63        disconnect(x, signal, Any) 
    6764        expected = [] 
    6865        result = send('this',object(), a=a) 
    69         assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) 
    70         assert len(list(getAllReceivers(Any,signal))) == 0 
    71  
    72         self._isclean() 
     66        self.assertEqual(result, expected) 
     67        self.assertEqual(list(getAllReceivers(Any,signal)), []) 
    7368         
     69        self._testIsClean() 
     70     
    7471    def testAnyRegistration2(self): 
    7572        a = Dummy() 
    7673        signal = 'this' 
    77         connect( x, Any, a ) 
     74        connect(x, Any, a) 
    7875        expected = [(x,a)] 
    7976        result = send('this',a, a=a) 
    80         assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) 
    81         disconnect( x, Any, a ) 
    82         assert len(list(getAllReceivers(a,Any))) == 0 
    83         self._isclean() 
    84  
     77        self.assertEqual(result, expected) 
     78        disconnect(x, Any, a) 
     79        self.assertEqual(list(getAllReceivers(a,Any)), []) 
     80        self._testIsClean() 
     81     
    8582    def testGarbageCollected(self): 
    8683        a = Callable() 
    8784        b = Dummy() 
    8885        signal = 'this' 
    89         connect( a.a, signal, b ) 
     86        connect(a.a, signal, b) 
    9087        expected = [] 
    9188        del a 
    9289        result = send('this',b, a=b) 
    93         assert result == expected,"""Send didn't return expected result:\n\texpected:%s\n\tgot:%s"""% (expected, result) 
    94         assert len(list(getAllReceivers(b,signal))) == 0, """Remaining handlers: %s"""%(getAllReceivers(b,signal),) 
    95         self._isclean() 
    96  
     90        self.assertEqual(result, expected) 
     91        self.assertEqual(list(getAllReceivers(b,signal)), []) 
     92        self._testIsClean() 
     93     
    9794    def testGarbageCollectedObj(self): 
    9895        class x: 
    99             def __call__( self, a ): 
     96            def __call__(self, a): 
    10097                return a 
    10198        a = Callable() 
    10299        b = Dummy() 
    103100        signal = 'this' 
    104         connect( a, signal, b ) 
     101        connect(a, signal, b) 
    105102        expected = [] 
    106103        del a 
    107104        result = send('this',b, a=b) 
    108105        self.assertEqual(result, expected) 
    109         self.assertEqual(len(list(getAllReceivers(b,signal))), 0) 
    110         self._isclean() 
     106        self.assertEqual(list(getAllReceivers(b,signal)), []) 
     107        self._testIsClean() 
    111108 
    112  
     109     
    113110    def testMultipleRegistration(self): 
    114111        a = Callable() 
    115112        b = Dummy() 
    116113        signal = 'this' 
    117         connect( a, signal, b ) 
    118         connect( a, signal, b ) 
    119         connect( a, signal, b ) 
    120         connect( a, signal, b ) 
    121         connect( a, signal, b ) 
    122         connect( a, signal, b ) 
     114        connect(a, signal, b) 
     115        connect(a, signal, b) 
     116        connect(a, signal, b) 
     117        connect(a, signal, b) 
     118        connect(a, signal, b) 
     119        connect(a, signal, b) 
    123120        result = send('this',b, a=b) 
    124         assert len( result ) == 1, result 
    125         assert len(list(getAllReceivers(b,signal))) == 1, """Remaining handlers: %s"""%(getAllReceivers(b,signal),) 
     121        self.assertEqual(len(result), 1) 
     122        self.assertEqual(len(list(getAllReceivers(b,signal))), 1) 
    126123        del a 
    127124        del b 
    128125        del result 
    129         self._isclean() 
    130  
    131     def testRobust( self ): 
     126        self._testIsClean() 
     127     
     128    def testRobust(self): 
    132129        """Test the sendRobust function""" 
    133         def fails( ): 
    134             raise ValueError( 'this' ) 
     130        def fails(): 
     131            raise ValueError('this') 
    135132        a = object() 
    136133        signal = 'this' 
    137         connect( fails, Any, a ) 
     134        connect(fails, Any, a) 
    138135        result = robust.sendRobust('this',a, a=a) 
    139136        err = result[0][1] 
    140         assert isinstance( err, ValueError ) 
    141         assert err.args == ('this',) 
     137        self.assert_(isinstance(err, ValueError)) 
     138        self.assertEqual(err.args, ('this',)) 
    142139 
    143140def getSuite(): 
    144141    return unittest.makeSuite(DispatcherTests,'test') 
    145          
     142 
    146143if __name__ == "__main__": 
    147144    unittest.main () 

  • django/trunk/tests/regressiontests/dispatch/tests/test_robustapply.py

    r4588 r4589  
    22 
    33import unittest 
     4 
    45def noArgument(): 
    56    pass 
    6 def oneArgument (blah): 
     7 
     8def oneArgument(blah): 
    79    pass 
     10 
    811def twoArgument(blah, other): 
    912    pass 
    10 class TestCases( unittest.TestCase ): 
    11     def test01( self ): 
    12         robustApply(noArgument ) 
    13     def test02( self ): 
    14         self.assertRaises( TypeError, robustApply, noArgument, "this" ) 
    15     def test03( self ): 
    16         self.assertRaises( TypeError, robustApply, oneArgument ) 
    17     def test04( self ): 
     13 
     14class TestCases(unittest.TestCase): 
     15    def test01(self): 
     16        robustApply(noArgument) 
     17     
     18    def test02(self): 
     19        self.assertRaises(TypeError, robustApply, noArgument, "this") 
     20     
     21    def test03(self): 
     22        self.assertRaises(TypeError, robustApply, oneArgument) 
     23     
     24    def test04(self): 
    1825        """Raise error on duplication of a particular argument""" 
    19         self.assertRaises( TypeError, robustApply, oneArgument, "this", blah = "that" ) 
     26        self.assertRaises(TypeError, robustApply, oneArgument, "this", blah = "that") 
    2027 
    2128def getSuite(): 

  • django/trunk/tests/regressiontests/dispatch/tests/test_saferef.py

    r4588 r4589  
    22 
    33import unittest 
    4 class Test1( object): 
    5     def x( self ): 
     4 
     5class Test1(object): 
     6    def x(self): 
    67        pass 
     8 
    79def test2(obj): 
    810    pass 
    9 class Test2( object ): 
    10     def __call__( self, obj ): 
     11 
     12class Test2(object): 
     13    def __call__(self, obj): 
    1114        pass 
    12 class Tester (unittest.TestCase): 
    13     def setUp (self): 
     15 
     16class Tester(unittest.TestCase): 
     17    def setUp(self): 
    1418        ts = [] 
    1519        ss = [] 
    16         for x in xrange( 5000 ): 
     20        for x in xrange(5000): 
    1721            t = Test1() 
    18             ts.append( t) 
    19             s = safeRef(t.x, self._closure ) 
    20             ss.append( s) 
    21         ts.append( test2 ) 
    22         ss.append( safeRef(test2, self._closure) ) 
    23         for x in xrange( 30 ): 
     22            ts.append(t) 
     23            s = safeRef(t.x, self._closure) 
     24            ss.append(s) 
     25        ts.append(test2) 
     26        ss.append(safeRef(test2, self._closure)) 
     27        for x in xrange(30): 
    2428            t = Test2() 
    25             ts.append( t) 
    26             s = safeRef(t, self._closure ) 
    27             ss.append( s) 
     29            ts.append(t) 
     30            s = safeRef(t, self._closure) 
     31            ss.append(s) 
    2832        self.ts = ts 
    2933        self.ss = ss 
    3034        self.closureCount = 0 
    31     def tearDown( self ): 
     35     
     36    def tearDown(self): 
    3237        del self.ts 
    3338        del self.ss 
     39     
    3440    def testIn(self): 
    3541        """Test the "in" operator for safe references (cmp)""" 
    3642        for t in self.ts[:50]: 
    37             assert safeRef(t.x) in self.ss 
     43            self.assert_(safeRef(t.x) in self.ss) 
     44     
    3845    def testValid(self): 
    3946        """Test that the references are valid (return instance methods)""" 
    4047        for s in self.ss: 
    41             assert s() 
     48            self.assert_(s()) 
     49     
    4250    def testShortCircuit (self): 
    4351        """Test that creation short-circuits to reuse existing references""" 
    …… 
    4654            sd[s] = 1 
    4755        for t in self.ts: 
    48             if hasattr( t, 'x'): 
    49                 assert sd.has_key( safeRef(t.x)) 
     56            if hasattr(t, 'x'): 
     57                self.assert_(sd.has_key(safeRef(t.x))) 
    5058            else: 
    51                 assert sd.has_key( safeRef(t)) 
     59                self.assert_(sd.has_key(safeRef(t))) 
     60     
    5261    def testRepresentation (self): 
    5362        """Test that the reference object's representation works 
    54  
     63         
    5564        XXX Doesn't currently check the results, just that no error 
    5665            is raised 
    5766        """ 
    58         repr( self.ss[-1] ) 
    59          
    60     def test(self): 
    61         self.closureCount = 0 
    62         wholeI = len(self.ts) 
    63         for i in xrange( len(self.ts)-1, -1, -1): 
    64             del self.ts[i] 
    65             if wholeI-i != self.closureCount: 
    66                 """Unexpected number of items closed, expected %s, got %s closed"""%( wholeI-i,self.closureCount) 
     67        repr(self.ss[-1]) 
    6768         
    6869    def _closure(self, ref): 
    …… 
    7475 
    7576if __name__ == "__main__": 
    76     unittest.main () 
     77    unittest.main()