[Checkins] SVN: Products.CMFTopic/trunk/Products/CMFTopic/tests/test_ unittest cleanup:

Yvo Schubbe cvs-admin at zope.org
Sun Apr 22 11:04:44 UTC 2012


Log message for revision 125230:
  unittest cleanup:
  - replaced deprecated assert method aliases
  - PEP 8

Changed:
  U   Products.CMFTopic/trunk/Products/CMFTopic/tests/test_DateC.py
  U   Products.CMFTopic/trunk/Products/CMFTopic/tests/test_ListC.py
  U   Products.CMFTopic/trunk/Products/CMFTopic/tests/test_Topic.py
  U   Products.CMFTopic/trunk/Products/CMFTopic/tests/test_exportimport.py

-=-
Modified: Products.CMFTopic/trunk/Products/CMFTopic/tests/test_DateC.py
===================================================================
--- Products.CMFTopic/trunk/Products/CMFTopic/tests/test_DateC.py	2012-04-22 11:04:25 UTC (rev 125229)
+++ Products.CMFTopic/trunk/Products/CMFTopic/tests/test_DateC.py	2012-04-22 11:04:41 UTC (rev 125230)
@@ -34,20 +34,16 @@
 
 class FriendlyDateCriterionTests(CriterionTestCase, unittest.TestCase):
 
-    lessThanFiveDaysOld = { 'value': 5
-                          , 'operation': 'max'
-                          , 'daterange': 'old'
-                          }
+    lessThanFiveDaysOld = {'value': 5,
+                           'operation': 'max',
+                           'daterange': 'old'}
+    lessThanOneMonthAhead = {'value': 31,
+                             'operation': 'max',
+                             'daterange': 'ahead'}
+    today = {'value': 0,
+             'operation': 'within_day',
+             'daterange': 'ahead'}
 
-    lessThanOneMonthAhead = { 'value': 31
-                            , 'operation': 'max'
-                            , 'daterange': 'ahead'
-                            }
-    today = { 'value': 0
-            , 'operation': 'within_day'
-            , 'daterange': 'ahead'
-            }
-
     def setUp(self):
         self._now = DateTime()
         self._old_as_of = _replace_DC__as_of(lambda: self._now)
@@ -60,105 +56,104 @@
 
         return FriendlyDateCriterion
 
-    def test_Empty( self ):
+    def test_Empty(self):
         friendly = self._makeOne('foo', 'foofield')
 
-        self.assertEqual( friendly.getId(), 'foo' )
-        self.assertEqual( friendly.field, 'foofield' )
-        self.assertEqual( friendly.value, None )
-        self.assertEqual( friendly.operation, 'min' )
-        self.assertEqual( friendly.daterange, 'old' )
-        self.assertEqual( len( friendly.getCriteriaItems() ), 0 )
+        self.assertEqual(friendly.getId(), 'foo')
+        self.assertEqual(friendly.field, 'foofield')
+        self.assertEqual(friendly.value, None)
+        self.assertEqual(friendly.operation, 'min')
+        self.assertEqual(friendly.daterange, 'old')
+        self.assertEqual(len(friendly.getCriteriaItems()), 0)
 
-    def test_ListOfDefaultDates( self ):
+    def test_ListOfDefaultDates(self):
         friendly = self._makeOne('foo', 'foofield')
 
         d = friendly.defaultDateOptions()
-        self.assertEqual( d[0][0], 0 )
-        self.assertEqual( d[1][0], 1 )
-        self.assertEqual( d[2][0], 2 )
+        self.assertEqual(d[0][0], 0)
+        self.assertEqual(d[1][0], 1)
+        self.assertEqual(d[2][0], 2)
 
-    def test_Clear( self ):
+    def test_Clear(self):
         friendly = self._makeOne('foo', 'foofield')
 
-        friendly.edit( value=None )
-        self.assertEqual( friendly.value, None )
-        self.assertEqual( friendly.operation, 'min' )
-        self.assertEqual( friendly.daterange, 'old' )
+        friendly.edit(value=None)
+        self.assertEqual(friendly.value, None)
+        self.assertEqual(friendly.operation, 'min')
+        self.assertEqual(friendly.daterange, 'old')
 
-    def test_Basic( self ):
+    def test_Basic(self):
         friendly = self._makeOne('foo', 'foofield')
 
-        friendly.apply( self.lessThanFiveDaysOld )
-        self.assertEqual( friendly.value, 5 )
-        self.assertEqual( friendly.operation, 'max' )
-        self.assertEqual( friendly.daterange, 'old' )
+        friendly.apply(self.lessThanFiveDaysOld)
+        self.assertEqual(friendly.value, 5)
+        self.assertEqual(friendly.operation, 'max')
+        self.assertEqual(friendly.daterange, 'old')
 
-    def test_BadInput( self ):
+    def test_BadInput(self):
         friendly = self._makeOne('foo', 'foofield')
 
         # Bogus value
-        self.assertRaises( ValueError, friendly.edit, 'blah' )
+        self.assertRaises(ValueError, friendly.edit, 'blah')
 
         # Bogus operation
-        self.assertRaises( ValueError, friendly.edit, 4, 'min:max', 'old' )
+        self.assertRaises(ValueError, friendly.edit, 4, 'min:max', 'old')
 
         # Bogus daterange
-        self.assertRaises( ValueError, friendly.edit, 4, 'max', 'new' )
+        self.assertRaises(ValueError, friendly.edit, 4, 'max', 'new')
 
-    def test_StringAsValue( self ):
+    def test_StringAsValue(self):
         friendly = self._makeOne('foo', 'foofield')
 
-        friendly.edit( '4' )
-        self.assertEqual( friendly.value, 4 )
+        friendly.edit('4')
+        self.assertEqual(friendly.value, 4)
 
-        friendly.edit( '-4' )
-        self.assertEqual( friendly.value, -4 )
+        friendly.edit('-4')
+        self.assertEqual(friendly.value, -4)
 
-        friendly.edit( '' )
-        self.assertEqual( friendly.value, None )
+        friendly.edit('')
+        self.assertEqual(friendly.value, None)
 
-    def test_Today( self ):
+    def test_Today(self):
         friendly = self._makeOne('foo', 'foofield')
 
-        friendly.apply( self.today )
-        self.assertEqual( friendly.daterange, 'ahead' )
+        friendly.apply(self.today)
+        self.assertEqual(friendly.daterange, 'ahead')
 
         now = DateTime()
 
         result = friendly.getCriteriaItems()
-        self.assertEqual( len(result), 1 )
-        self.assertEqual( result[0][0], 'foofield' )
-        self.assertEqual( result[0][1]['query'],
-                          ( now.earliestTime(), now.latestTime() ) )
-        self.assertEqual( result[0][1]['range'], 'min:max' )
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0][0], 'foofield')
+        self.assertEqual(result[0][1]['query'],
+                         (now.earliestTime(), now.latestTime()))
+        self.assertEqual(result[0][1]['range'], 'min:max')
 
-    def test_FiveDaysOld( self ):
+    def test_FiveDaysOld(self):
         # This should create a query
         friendly = self._makeOne('foo', 'foofield')
 
-        friendly.apply( self.lessThanFiveDaysOld )
-        self.assertEqual( friendly.daterange, 'old' )
+        friendly.apply(self.lessThanFiveDaysOld)
+        self.assertEqual(friendly.daterange, 'old')
 
         result = friendly.getCriteriaItems()
-        self.assertEqual( len(result), 1 )
-        self.assertEqual( result[0][0], 'foofield' )
-        expect_earliest, expect_now = result[0][1]['query']
-        self.assertEqual( expect_earliest.Date(),
-                          ( DateTime() - 5 ).Date() )
-        self.assertEqual( result[0][1]['range'], 'min:max' )
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0][0], 'foofield')
+        expect_earliest, _expect_now = result[0][1]['query']
+        self.assertEqual(expect_earliest.Date(), (DateTime() - 5).Date())
+        self.assertEqual(result[0][1]['range'], 'min:max')
 
-    def test_OneMonthAhead( self ):
+    def test_OneMonthAhead(self):
         friendly = self._makeOne('foo', 'foofield')
 
-        friendly.apply( self.lessThanOneMonthAhead )
-        self.assertEqual( friendly.daterange, 'ahead' )
+        friendly.apply(self.lessThanOneMonthAhead)
+        self.assertEqual(friendly.daterange, 'ahead')
 
         result = friendly.getCriteriaItems()
         expect_now, expect_latest = result[0][1]['query']
-        self.assertEqual( expect_latest.Date(), ( DateTime() + 31 ).Date() )
-        self.assertEqual( expect_now.Date(), DateTime().Date() )
-        self.assertEqual( result[0][1]['range'], 'min:max' )
+        self.assertEqual(expect_latest.Date(), (DateTime() + 31).Date())
+        self.assertEqual(expect_now.Date(), DateTime().Date())
+        self.assertEqual(result[0][1]['range'], 'min:max')
 
 
 class FriendlyDateCriterionFunctionalTests(ZopeTestCase.FunctionalTestCase):
@@ -174,7 +169,7 @@
     def afterSetUp(self):
         setSite(self.app.site)
         self.site = self.app.site
-        self.site._setObject( 'topic', Topic('topic') )
+        self.site._setObject('topic', Topic('topic'))
         self.topic = self.site.topic
         self.topic.addCriterion('modified', 'Friendly Date Criterion')
         self.topic.addCriterion('portal_type', 'String Criterion')
@@ -186,9 +181,8 @@
 
         for i in self.day_diffs:
             dummy_id = 'dummy%i' % i
-            self.site._setObject( dummy_id, DummyContent( id=dummy_id
-                                                        , catalog=1
-                                                        ) )
+            self.site._setObject(dummy_id,
+                                 DummyContent(id=dummy_id, catalog=1))
             dummy_ob = getattr(self.site, dummy_id)
             dummy_ob.modified_date = self.now + i
             dummy_ob.reindexObject()
@@ -207,42 +201,35 @@
     def test_WithinDayAgo(self):
         # What items were modified "On the day X days ago"
         for diff in self.selectable_diffs:
-            self.criterion.edit( value=abs(diff)
-                               , operation='within_day'
-                               , daterange='old'
-                               )
+            self.criterion.edit(value=abs(diff),
+                                operation='within_day',
+                                daterange='old')
             results = self.topic.queryCatalog()
 
             # There is only one item with an modified date for this day
-            self.assertEquals(len(results), 1)
-            self.assertEquals( results[0].modified.Date()
-                             , (self.now-diff).Date()
-                             )
+            self.assertEqual(len(results), 1)
+            self.assertEqual(results[0].modified.Date(),
+                             (self.now - diff).Date())
 
     def test_WithinDayAhead(self):
         # What items were modified "On the day X days ahead"
         for diff in self.selectable_diffs:
-            self.criterion.edit( value=abs(diff)
-                               , operation='within_day'
-                               , daterange='ahead'
-                               )
+            self.criterion.edit(value=abs(diff),
+                                operation='within_day',
+                                daterange='ahead')
             results = self.topic.queryCatalog()
 
             # There is only one item with an modified date for this day
-            self.assertEquals(len(results), 1)
-            self.assertEquals( results[0].modified.Date()
-                             , (self.now+diff).Date()
-                             )
+            self.assertEqual(len(results), 1)
+            self.assertEqual(results[0].modified.Date(),
+                             (self.now + diff).Date())
 
     def test_MoreThanDaysAgo(self):
         # What items are modified "More than X days ago"
         resultset_size = len(self.nonzero_diffs)
 
         for diff in self.nonzero_diffs:
-            self.criterion.edit( value=diff
-                               , operation='min'
-                               , daterange='old'
-                               )
+            self.criterion.edit(value=diff, operation='min', daterange='old')
             results = self.topic.queryCatalog()
 
             # As we move up in our date difference range, we must find as
@@ -250,9 +237,9 @@
             # in our sequence of user-selectable time differences. As we
             # increase the "value", we actually move backwards in time, so
             # the expected count of results *decreases*
-            self.assertEquals(len(results), resultset_size)
+            self.assertEqual(len(results), resultset_size)
             for brain in results:
-                self.failUnless(brain.modified <= self.now-diff)
+                self.assertTrue(brain.modified <= self.now - diff)
 
             resultset_size -= 1
 
@@ -263,24 +250,18 @@
         # are not applied and the search is a simple
         # "everything in the future" search.
         resultset_size = len(self.selectable_diffs)
-        self.criterion.edit( value=0
-                           , operation='min'
-                           , daterange='old'
-                           )
+        self.criterion.edit(value=0, operation='min', daterange='old')
         results = self.topic.queryCatalog()
-        self.assertEquals(len(results), resultset_size)
+        self.assertEqual(len(results), resultset_size)
         for brain in results:
-            self.failUnless(brain.modified >= self.now)
+            self.assertTrue(brain.modified >= self.now)
 
     def test_MoreThanDaysAhead(self):
         # What items are modified "More than X days ahead"
         resultset_size = len(self.nonzero_diffs)
 
         for diff in self.nonzero_diffs:
-            self.criterion.edit( value=diff
-                               , operation='min'
-                               , daterange='ahead'
-                               )
+            self.criterion.edit(value=diff, operation='min', daterange='ahead')
             results = self.topic.queryCatalog()
 
             # As we move up in our date difference range, we must find as
@@ -288,9 +269,9 @@
             # in our sequence of user-selectable time differences. As we
             # increase the "value", we actually move formward in time, so
             # the expected count of results *decreases*
-            self.assertEquals(len(results), resultset_size)
+            self.assertEqual(len(results), resultset_size)
             for brain in results:
-                self.failUnless(brain.modified >= self.now+diff)
+                self.assertTrue(brain.modified >= self.now + diff)
 
             resultset_size -= 1
 
@@ -301,33 +282,27 @@
         # are not applied and the search is a simple
         # "everything in the future" search.
         resultset_size = len(self.selectable_diffs)
-        self.criterion.edit( value=0
-                           , operation='min'
-                           , daterange='ahead'
-                           )
+        self.criterion.edit(value=0, operation='min', daterange='ahead')
         results = self.topic.queryCatalog()
-        self.assertEquals(len(results), resultset_size)
+        self.assertEqual(len(results), resultset_size)
         for brain in results:
-            self.failUnless(brain.modified >= self.now)
+            self.assertTrue(brain.modified >= self.now)
 
     def test_LessThanDaysAgo(self):
         # What items are modified "Less than X days ago"
         resultset_size = 2
 
         for diff in self.nonzero_diffs:
-            self.criterion.edit( value=diff
-                               , operation='max'
-                               , daterange='old'
-                               )
+            self.criterion.edit(value=diff, operation='max', daterange='old')
             results = self.topic.queryCatalog()
 
             # With this query we are looking for items modified "less than
             # X days ago", meaning between the given time and now. As we move
             # through the selectable day values we increase the range to
             # search through and thus increase the resultset size.
-            self.assertEquals(len(results), resultset_size)
+            self.assertEqual(len(results), resultset_size)
             for brain in results:
-                self.failUnless(self.now-diff <= brain.modified <= self.now)
+                self.assertTrue(self.now - diff <= brain.modified <= self.now)
 
             resultset_size += 1
 
@@ -338,33 +313,27 @@
         # are not applied and the search is a simple
         # "everything in the past" search.
         resultset_size = len(self.selectable_diffs)
-        self.criterion.edit( value=0
-                           , operation='max'
-                           , daterange='old'
-                           )
+        self.criterion.edit(value=0, operation='max', daterange='old')
         results = self.topic.queryCatalog()
-        self.assertEquals(len(results), resultset_size)
+        self.assertEqual(len(results), resultset_size)
         for brain in results:
-            self.failUnless(brain.modified <= self.now)
+            self.assertTrue(brain.modified <= self.now)
 
     def test_LessThanDaysAhead(self):
         # What items are modified "Less than X days ahead"
         resultset_size = 2
 
         for diff in self.nonzero_diffs:
-            self.criterion.edit( value=diff
-                               , operation='max'
-                               , daterange='ahead'
-                               )
+            self.criterion.edit(value=diff, operation='max', daterange='ahead')
             results = self.topic.queryCatalog()
 
             # With this query we are looking for items modified "less than
             # X days ahead", meaning between now and the given time. As we move
             # through the selectable day values we increase the range to
             # search through and thus increase the resultset size.
-            self.assertEquals(len(results), resultset_size)
+            self.assertEqual(len(results), resultset_size)
             for brain in results:
-                self.failUnless(self.now+diff >= brain.modified >= self.now)
+                self.assertTrue(self.now + diff >= brain.modified >= self.now)
 
             resultset_size += 1
 
@@ -375,14 +344,11 @@
         # are not applied and the search is a simple
         # "everything in the past" search.
         resultset_size = len(self.selectable_diffs)
-        self.criterion.edit( value=0
-                           , operation='max'
-                           , daterange='ahead'
-                           )
+        self.criterion.edit(value=0, operation='max', daterange='ahead')
         results = self.topic.queryCatalog()
-        self.assertEquals(len(results), resultset_size)
+        self.assertEqual(len(results), resultset_size)
         for brain in results:
-            self.failUnless(brain.modified <= self.now)
+            self.assertTrue(brain.modified <= self.now)
 
 
 def test_suite():

Modified: Products.CMFTopic/trunk/Products/CMFTopic/tests/test_ListC.py
===================================================================
--- Products.CMFTopic/trunk/Products/CMFTopic/tests/test_ListC.py	2012-04-22 11:04:25 UTC (rev 125229)
+++ Products.CMFTopic/trunk/Products/CMFTopic/tests/test_ListC.py	2012-04-22 11:04:41 UTC (rev 125230)
@@ -26,56 +26,56 @@
 
         return ListCriterion
 
-    def test_Empty( self ):
+    def test_Empty(self):
         listc = self._makeOne('foo', 'foofield')
 
-        self.assertEqual( listc.getId(), 'foo' )
-        self.assertEqual( listc.field, 'foofield' )
-        self.assertEqual( listc.value, ('',) )
-        self.assertEqual( len(listc.getCriteriaItems()), 0 )
+        self.assertEqual(listc.getId(), 'foo')
+        self.assertEqual(listc.field, 'foofield')
+        self.assertEqual(listc.value, ('',))
+        self.assertEqual(len(listc.getCriteriaItems()), 0)
 
-    def test_Edit_withString( self ):
+    def test_Edit_withString(self):
         listc = self._makeOne('foo', 'foofield')
 
         listc.edit('bar\nbaz')
-        self.assertEqual( listc.getId(), 'foo' )
-        self.assertEqual( listc.field, 'foofield' )
-        self.assertEqual( listc.value, ( 'bar', 'baz' ) )
+        self.assertEqual(listc.getId(), 'foo')
+        self.assertEqual(listc.field, 'foofield')
+        self.assertEqual(listc.value, ('bar', 'baz'))
 
         items = listc.getCriteriaItems()
-        self.assertEqual( len( items ), 1 )
-        self.assertEqual( len( items[0] ), 2 )
-        self.assertEqual( items[0][0], 'foofield' )
-        self.assertEqual( items[0][1], ( 'bar', 'baz' ) )
+        self.assertEqual(len(items), 1)
+        self.assertEqual(len(items[0]), 2)
+        self.assertEqual(items[0][0], 'foofield')
+        self.assertEqual(items[0][1], ('bar', 'baz'))
 
-    def test_Edit_withList( self ):
+    def test_Edit_withList(self):
         listc = self._makeOne('foo', 'foofield')
 
-        abc = [ 'a', 'b', 'c' ]
-        listc.edit( abc )
+        abc = ['a', 'b', 'c']
+        listc.edit(abc)
 
         items = listc.getCriteriaItems()
-        self.failUnless( 'foofield' in map( lambda x: x[0], items ) )
-        self.failUnless( tuple( abc ) in map( lambda x: x[1], items ) )
+        self.assertTrue('foofield' in map(lambda x: x[0], items))
+        self.assertTrue(tuple(abc) in map(lambda x: x[1], items))
 
-    def test_operator( self ):
+    def test_operator(self):
         listc = self._makeOne('foo', 'foofield')
 
-        abc = [ 'a', 'b', 'c' ]
+        abc = ['a', 'b', 'c']
 
-        listc.edit( abc )
+        listc.edit(abc)
         items = listc.getCriteriaItems()
-        self.assertEqual( len( items ), 1 )
+        self.assertEqual(len(items), 1)
 
-        listc.edit( abc, 'or' )
+        listc.edit(abc, 'or')
         items = listc.getCriteriaItems()
-        self.assertEqual( len( items ), 2 )
-        self.failUnless( ( 'foofield_operator', 'or' ) in items )
+        self.assertEqual(len(items), 2)
+        self.assertTrue(('foofield_operator', 'or') in items)
 
-        listc.edit( abc, 'and' )
+        listc.edit(abc, 'and')
         items = listc.getCriteriaItems()
-        self.assertEqual( len( items ), 2 )
-        self.failUnless( ( 'foofield_operator', 'and' ) in items )
+        self.assertEqual(len(items), 2)
+        self.assertTrue(('foofield_operator', 'and') in items)
 
 
 def test_suite():

Modified: Products.CMFTopic/trunk/Products/CMFTopic/tests/test_Topic.py
===================================================================
--- Products.CMFTopic/trunk/Products/CMFTopic/tests/test_Topic.py	2012-04-22 11:04:25 UTC (rev 125229)
+++ Products.CMFTopic/trunk/Products/CMFTopic/tests/test_Topic.py	2012-04-22 11:04:41 UTC (rev 125230)
@@ -33,68 +33,61 @@
 from Products.CMFTopic.testing import FunctionalLayer
 
 
-class FauxBrain( Implicit ):
+class FauxBrain(Implicit):
 
-    def __init__( self, object ):
-
+    def __init__(self, object):
         self._object = object
 
-    def getObject( self ):
-
+    def getObject(self):
         return self._object
 
 
-class DummyDocument( Implicit ):
+class DummyDocument(Implicit):
 
-    def __init__( self, id ):
-
+    def __init__(self, id):
         self._id = id
 
-    def getId( self ):
-
+    def getId(self):
         return self._id
 
 
-class DummyCatalog( Implicit ):
+class DummyCatalog(Implicit):
 
-    def __init__( self, index_ids=() ):
-
+    def __init__(self, index_ids=()):
         self._objects = []
         self._index_ids = index_ids
         self._indexes = {}
 
         for index_id in index_ids:
-            self._indexes[ index_id ] = {}
+            self._indexes[index_id] = {}
 
-    def _index( self, obj, idxs=[] ):
-
+    def _index(self, obj, idxs=[]):
         marker = object()
-        self._objects.append( obj )
+        self._objects.append(obj)
 
-        rid = len( self._objects ) - 1
+        rid = len(self._objects) - 1
 
         for index_id in self._index_ids:
 
-            value = getattr( obj, index_id, marker )
+            value = getattr(obj, index_id, marker)
 
             if value is not marker:
                 for word in value.split():
-                    bucket = self._indexes[ index_id ].setdefault( word, [] )
-                    bucket.append( rid )
+                    bucket = self._indexes[index_id].setdefault(word, [])
+                    bucket.append(rid)
 
     indexObject = _index
 
     reindexObject = _index
 
-    def searchResults( self, REQUEST=None, **kw ):
-
+    def searchResults(self, REQUEST=None, **kw):
         limit = None
 
         criteria = kw.copy()
 
         if REQUEST is not None:
             for k, v in REQUEST:
-                criteria[ k ] = v
+                criteria[k] = v
 
         results = set(range(len(self._objects)))
 
@@ -109,19 +102,17 @@
         results = [ x for x in results ]
 
         if limit is not None:
-            results = results[ :limit ]
+            results = results[:limit]
 
-        return [ FauxBrain( self._objects[ rid ] ) for rid in results ]
+        return [ FauxBrain(self._objects[rid]) for rid in results ]
 
 
-class DummySyndicationTool( Implicit ):
+class DummySyndicationTool(Implicit):
 
-    def __init__( self, max_items ):
-
+    def __init__(self, max_items):
         self._max_items = max_items
 
-    def getMaxItems( self, object ):
-
+    def getMaxItems(self, object):
         return self._max_items
 
 
@@ -157,7 +148,7 @@
 
     def setUp(self):
         SecurityTest.setUp(self)
-        self.site = DummySite('site').__of__(self.root)
+        self.site = DummySite('site').__of__(self.app)
 
     def test_interfaces(self):
         from OFS.interfaces import IOrderedContainer
@@ -170,28 +161,28 @@
         verifyClass(ITopic, self._getTargetClass())
         verifyClass(IOrderedContainer, self._getTargetClass())
 
-    def test_Empty( self ):
+    def test_Empty(self):
         topic = self._makeOne('top')
 
         query = topic.buildQuery()
-        self.assertEqual( len( query ), 0 )
+        self.assertEqual(len(query), 0)
 
-    def test_Simple( self ):
+    def test_Simple(self):
         topic = self._makeOne('top')
-        topic.addCriterion( 'foo', 'String Criterion' )
-        topic.getCriterion( 'foo' ).edit( 'bar' )
+        topic.addCriterion('foo', 'String Criterion')
+        topic.getCriterion('foo').edit('bar')
 
         query = topic.buildQuery()
-        self.assertEqual( len(query), 1 )
-        self.assertEqual( query['foo'], 'bar' )
+        self.assertEqual(len(query), 1)
+        self.assertEqual(query['foo'], 'bar')
 
-        topic.addCriterion( 'baz', 'Integer Criterion' )
-        topic.getCriterion( 'baz' ).edit( 43 )
+        topic.addCriterion('baz', 'Integer Criterion')
+        topic.getCriterion('baz').edit(43)
 
         query = topic.buildQuery()
-        self.assertEqual( len( query ), 2 )
-        self.assertEqual( query[ 'foo' ], 'bar' )
-        self.assertEqual( query[ 'baz' ], 43 )
+        self.assertEqual(len(query), 2)
+        self.assertEqual(query['foo'], 'bar')
+        self.assertEqual(query['baz'], 43)
 
     def test_selfIndexing(self):
         # The Topic object is CatalogAware and should be in the catalog
@@ -203,9 +194,9 @@
         # set, so we should not have one result, for the Topic object itself.
         results = topic.queryCatalog()
 
-        self.assertEquals(len(results), 1)
-        self.assertEquals(results[0].getObject().getId(), topic.getId())
-        self.assertEquals(results[0].getObject(), topic)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].getObject().getId(), topic.getId())
+        self.assertEqual(results[0].getObject(), topic)
 
     def test_searchableText(self):
         # Test the catalog helper
@@ -213,88 +204,83 @@
         topic.edit(False, title='FOO', description='BAR')
 
         st = topic.SearchableText()
-        self.failUnless(st.find('BAR') != -1)
-        self.failUnless(st.find('FOO') != -1)
+        self.assertTrue(st.find('BAR') != -1)
+        self.assertTrue(st.find('FOO') != -1)
 
-    def test_queryCatalog_noop( self ):
-
+    def test_queryCatalog_noop(self):
         self._initSite()
-        self._initDocuments( **_DOCUMENTS )
+        self._initDocuments(**_DOCUMENTS)
         topic = self._makeOne('top')
 
         # Need to filter out the Topic object itself, which is also
         # CatalogAware and will index itself after instantiation.
         brains = [ x for x in topic.queryCatalog()
-                      if x.getObject().getId() != 'top' ]
+                   if x.getObject().getId() != 'top' ]
 
-        self.assertEqual( len( brains ), len( _DOCUMENTS ) )
+        self.assertEqual(len(brains), len(_DOCUMENTS))
 
         objects = [ brain.getObject() for brain in brains ]
 
         for object in objects:
-            self.failUnless( object.getId() in _DOCUMENTS.keys() )
-            self.failUnless( object.description in _DOCUMENTS.values() )
+            self.assertTrue(object.getId() in _DOCUMENTS.keys())
+            self.assertTrue(object.description in _DOCUMENTS.values())
 
-    def test_queryCatalog_simple( self ):
-
+    def test_queryCatalog_simple(self):
         WORD = 'something'
 
-        self._initSite( index_ids=( 'description', ) )
-        self._initDocuments( **_DOCUMENTS )
+        self._initSite(index_ids=('description',))
+        self._initDocuments(**_DOCUMENTS)
         topic = self._makeOne('top')
 
-        topic.addCriterion( 'description', 'String Criterion' )
-        topic.getCriterion( 'description' ).edit( WORD )
+        topic.addCriterion('description', 'String Criterion')
+        topic.getCriterion('description').edit(WORD)
 
         brains = topic.queryCatalog()
 
-        self.assertEqual( len( brains )
-                        , len( [ x for x in _DOCUMENTS.values()
-                                  if WORD in x ] ) )
+        self.assertEqual(len(brains),
+                         len([ x for x in _DOCUMENTS.values() if WORD in x ]))
 
         objects = [ brain.getObject() for brain in brains ]
 
         for object in objects:
-            self.failUnless( object.getId() in _DOCUMENTS.keys() )
-            self.failUnless( object.description in _DOCUMENTS.values() )
+            self.assertTrue(object.getId() in _DOCUMENTS.keys())
+            self.assertTrue(object.description in _DOCUMENTS.values())
 
-    def test_synContentValues_simple( self ):
-
+    def test_synContentValues_simple(self):
         self._initSite()
-        self._initDocuments( **_DOCUMENTS )
+        self._initDocuments(**_DOCUMENTS)
         topic = self._makeOne('top')
 
         #brains = topic.synContentValues()
         # Need to filter out the Topic object itself, which is also
         # CatalogAware and will index itself after instantiation.
         brains = [ x for x in topic.synContentValues()
-                      if x.getObject().getId() != 'top' ]
+                   if x.getObject().getId() != 'top' ]
 
-        self.assertEqual( len( brains ), len( _DOCUMENTS ) )
+        self.assertEqual(len(brains), len(_DOCUMENTS))
 
         objects = [ brain.getObject() for brain in brains ]
 
         for object in objects:
-            self.failUnless( object.getId() in _DOCUMENTS.keys() )
-            self.failUnless( object.description in _DOCUMENTS.values() )
+            self.assertTrue(object.getId() in _DOCUMENTS.keys())
+            self.assertTrue(object.description in _DOCUMENTS.values())
 
-    def test_synContentValues_limit( self ):
-
+    def test_synContentValues_limit(self):
         LIMIT = 3
 
-        self._initSite( max_items=LIMIT )
-        self._initDocuments( **_DOCUMENTS )
+        self._initSite(max_items=LIMIT)
+        self._initDocuments(**_DOCUMENTS)
         topic = self._makeOne('top')
 
         brains = topic.synContentValues()
 
-        self.assertEqual( len( brains ), LIMIT )
+        self.assertEqual(len(brains), LIMIT)
 
         objects = [ brain.getObject() for brain in brains ]
 
         for object in objects:
-            self.failUnless( object.getId() in _DOCUMENTS.keys() )
-            self.failUnless( object.description in _DOCUMENTS.values() )
+            self.assertTrue(object.getId() in _DOCUMENTS.keys())
+            self.assertTrue(object.description in _DOCUMENTS.values())
 
 
 class TestTopicFunctional(ZopeTestCase.FunctionalTestCase):
@@ -306,38 +292,38 @@
         self.app.site.setupCurrentSkin(self.app.REQUEST)
         newSecurityManager(None, UnrestrictedUser('god', '', ['Manager'], ''))
 
-    def test_Nested( self ):
+    def test_Nested(self):
         self.app.site.invokeFactory('Topic', 'top')
         topic = self.app.site.top
 
-        topic.addCriterion( 'foo', 'String Criterion' )
-        topic.getCriterion( 'foo' ).edit( 'bar' )
+        topic.addCriterion('foo', 'String Criterion')
+        topic.getCriterion('foo').edit('bar')
 
-        topic.addSubtopic( 'qux' )
+        topic.addSubtopic('qux')
         subtopic = topic.qux
 
-        subtopic.addCriterion( 'baz', 'String Criterion' )
-        subtopic.getCriterion( 'baz' ).edit( 'bam' )
+        subtopic.addCriterion('baz', 'String Criterion')
+        subtopic.getCriterion('baz').edit('bam')
 
         query = subtopic.buildQuery()
-        self.assertEqual( len( query ), 2 )
-        self.assertEqual( query['foo'], 'bar' )
-        self.assertEqual( query['baz'], 'bam' )
+        self.assertEqual(len(query), 2)
+        self.assertEqual(query['foo'], 'bar')
+        self.assertEqual(query['baz'], 'bam')
 
         subtopic.acquireCriteria = 0
         query = subtopic.buildQuery()
-        self.assertEqual( len( query ), 1 )
-        self.assertEqual( query['baz'], 'bam' )
+        self.assertEqual(len(query), 1)
+        self.assertEqual(query['baz'], 'bam')
 
 
-_DOCUMENTS = \
-{ 'one'     : "something in the way she moves"
-, 'two'     : "I don't know much about history"
-, 'three'   : "something about Mary"
-, 'four'    : "something tells me I'm in love"
-, 'five'    : "there's a certain wonderful something"
-, 'six'     : "gonna wash that man right out of my hair"
-, 'seven'   : "I'm so much in love"
+_DOCUMENTS = {
+    'one': "something in the way she moves",
+    'two': "I don't know much about history",
+    'three': "something about Mary",
+    'four': "something tells me I'm in love",
+    'five': "there's a certain wonderful something",
+    'six': "gonna wash that man right out of my hair",
+    'seven': "I'm so much in love",
 }
 
 

Modified: Products.CMFTopic/trunk/Products/CMFTopic/tests/test_exportimport.py
===================================================================
--- Products.CMFTopic/trunk/Products/CMFTopic/tests/test_exportimport.py	2012-04-22 11:04:25 UTC (rev 125229)
+++ Products.CMFTopic/trunk/Products/CMFTopic/tests/test_exportimport.py	2012-04-22 11:04:41 UTC (rev 125230)
@@ -66,7 +66,7 @@
         return topic
 
     def test_listExportableItems(self):
-        topic = self._makeTopic('lEI', False).__of__(self.root)
+        topic = self._makeTopic('lEI', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         self.assertEqual(len(adapter.listExportableItems()), 0)
@@ -74,32 +74,32 @@
         self.assertEqual(len(adapter.listExportableItems()), 0)
 
     def test__getExportInfo_empty(self):
-        topic = self._makeTopic('empty', False).__of__(self.root)
+        topic = self._makeTopic('empty', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         info = adapter._getExportInfo()
         self.assertEqual(len(info['criteria']), 0)
 
     def test_export_empty(self):
-        topic = self._makeTopic('empty', False).__of__(self.root)
+        topic = self._makeTopic('empty', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyExportContext(topic)
         adapter.export(context, 'test', False)
 
-        self.assertEqual( len( context._wrote ), 2 )
-        filename, text, content_type = context._wrote[ 0 ]
-        self.assertEqual( filename, 'test/empty/.objects' )
-        self.assertEqual( text, '' )
-        self.assertEqual( content_type, 'text/comma-separated-values' )
+        self.assertEqual(len(context._wrote), 2)
+        filename, text, content_type = context._wrote[0]
+        self.assertEqual(filename, 'test/empty/.objects')
+        self.assertEqual(text, '')
+        self.assertEqual(content_type, 'text/comma-separated-values')
 
-        filename, text, content_type = context._wrote[ 1 ]
-        self.assertEqual( filename, 'test/empty/criteria.xml' )
-        self._compareDOM( text, _EMPTY_TOPIC_CRITERIA )
-        self.assertEqual( content_type, 'text/xml' )
+        filename, text, content_type = context._wrote[1]
+        self.assertEqual(filename, 'test/empty/criteria.xml')
+        self._compareDOM(text, _EMPTY_TOPIC_CRITERIA)
+        self.assertEqual(content_type, 'text/xml')
 
     def test__getExportInfo_with_criteria(self):
-        topic = self._makeTopic('with_criteria', True).__of__(self.root)
+        topic = self._makeTopic('with_criteria', True).__of__(self.app)
         adapter = self._makeOne(topic)
 
         info = adapter._getExportInfo()
@@ -117,7 +117,7 @@
             self.assertEqual(dict(found['attributes']), attributes)
 
     def test_export_with_string_criterion(self):
-        topic = self._makeTopic('with_string', False).__of__(self.root)
+        topic = self._makeTopic('with_string', False).__of__(self.app)
         data = _CRITERIA_DATA[0]
         topic.addCriterion(data[0], data[1])
         topic.getCriterion(data[0]).edit(**data[2])
@@ -126,19 +126,19 @@
         context = DummyExportContext(topic)
         adapter.export(context, 'test', False)
 
-        self.assertEqual( len( context._wrote ), 2 )
-        filename, text, content_type = context._wrote[ 0 ]
-        self.assertEqual( filename, 'test/with_string/.objects' )
-        self.assertEqual( text, '' )
-        self.assertEqual( content_type, 'text/comma-separated-values' )
+        self.assertEqual(len(context._wrote), 2)
+        filename, text, content_type = context._wrote[0]
+        self.assertEqual(filename, 'test/with_string/.objects')
+        self.assertEqual(text, '')
+        self.assertEqual(content_type, 'text/comma-separated-values')
 
-        filename, text, content_type = context._wrote[ 1 ]
-        self.assertEqual( filename, 'test/with_string/criteria.xml' )
-        self._compareDOM( text, _STRING_TOPIC_CRITERIA )
-        self.assertEqual( content_type, 'text/xml' )
+        filename, text, content_type = context._wrote[1]
+        self.assertEqual(filename, 'test/with_string/criteria.xml')
+        self._compareDOM(text, _STRING_TOPIC_CRITERIA)
+        self.assertEqual(content_type, 'text/xml')
 
     def test_export_with_integer_criterion(self):
-        topic = self._makeTopic('with_integer', False).__of__(self.root)
+        topic = self._makeTopic('with_integer', False).__of__(self.app)
         data = _CRITERIA_DATA[1]
         topic.addCriterion(data[0], data[1])
         topic.getCriterion(data[0]).edit(**data[2])
@@ -147,19 +147,19 @@
         context = DummyExportContext(topic)
         adapter.export(context, 'test', False)
 
-        self.assertEqual( len( context._wrote ), 2 )
-        filename, text, content_type = context._wrote[ 0 ]
-        self.assertEqual( filename, 'test/with_integer/.objects' )
-        self.assertEqual( text, '' )
-        self.assertEqual( content_type, 'text/comma-separated-values' )
+        self.assertEqual(len(context._wrote), 2)
+        filename, text, content_type = context._wrote[0]
+        self.assertEqual(filename, 'test/with_integer/.objects')
+        self.assertEqual(text, '')
+        self.assertEqual(content_type, 'text/comma-separated-values')
 
-        filename, text, content_type = context._wrote[ 1 ]
-        self.assertEqual( filename, 'test/with_integer/criteria.xml' )
-        self._compareDOM( text, _INTEGER_TOPIC_CRITERIA )
-        self.assertEqual( content_type, 'text/xml' )
+        filename, text, content_type = context._wrote[1]
+        self.assertEqual(filename, 'test/with_integer/criteria.xml')
+        self._compareDOM(text, _INTEGER_TOPIC_CRITERIA)
+        self.assertEqual(content_type, 'text/xml')
 
     def test_export_with_date_criterion(self):
-        topic = self._makeTopic('with_date', False).__of__(self.root)
+        topic = self._makeTopic('with_date', False).__of__(self.app)
         data = _CRITERIA_DATA[2]
         topic.addCriterion(data[0], data[1])
         topic.getCriterion(data[0]).edit(**data[2])
@@ -168,19 +168,19 @@
         context = DummyExportContext(topic)
         adapter.export(context, 'test', False)
 
-        self.assertEqual( len( context._wrote ), 2 )
-        filename, text, content_type = context._wrote[ 0 ]
-        self.assertEqual( filename, 'test/with_date/.objects' )
-        self.assertEqual( text, '' )
-        self.assertEqual( content_type, 'text/comma-separated-values' )
+        self.assertEqual(len(context._wrote), 2)
+        filename, text, content_type = context._wrote[0]
+        self.assertEqual(filename, 'test/with_date/.objects')
+        self.assertEqual(text, '')
+        self.assertEqual(content_type, 'text/comma-separated-values')
 
-        filename, text, content_type = context._wrote[ 1 ]
-        self.assertEqual( filename, 'test/with_date/criteria.xml' )
-        self._compareDOM( text, _DATE_TOPIC_CRITERIA )
-        self.assertEqual( content_type, 'text/xml' )
+        filename, text, content_type = context._wrote[1]
+        self.assertEqual(filename, 'test/with_date/criteria.xml')
+        self._compareDOM(text, _DATE_TOPIC_CRITERIA)
+        self.assertEqual(content_type, 'text/xml')
 
     def test_export_with_list_criterion(self):
-        topic = self._makeTopic('with_list', False).__of__(self.root)
+        topic = self._makeTopic('with_list', False).__of__(self.app)
         data = _CRITERIA_DATA[3]
         topic.addCriterion(data[0], data[1])
         topic.getCriterion(data[0]).edit(**data[2])
@@ -189,19 +189,19 @@
         context = DummyExportContext(topic)
         adapter.export(context, 'test', False)
 
-        self.assertEqual( len( context._wrote ), 2 )
-        filename, text, content_type = context._wrote[ 0 ]
-        self.assertEqual( filename, 'test/with_list/.objects' )
-        self.assertEqual( text, '' )
-        self.assertEqual( content_type, 'text/comma-separated-values' )
+        self.assertEqual(len(context._wrote), 2)
+        filename, text, content_type = context._wrote[0]
+        self.assertEqual(filename, 'test/with_list/.objects')
+        self.assertEqual(text, '')
+        self.assertEqual(content_type, 'text/comma-separated-values')
 
-        filename, text, content_type = context._wrote[ 1 ]
-        self.assertEqual( filename, 'test/with_list/criteria.xml' )
-        self._compareDOM( text, _LIST_TOPIC_CRITERIA )
-        self.assertEqual( content_type, 'text/xml' )
+        filename, text, content_type = context._wrote[1]
+        self.assertEqual(filename, 'test/with_list/criteria.xml')
+        self._compareDOM(text, _LIST_TOPIC_CRITERIA)
+        self.assertEqual(content_type, 'text/xml')
 
     def test_export_with_sort_criterion(self):
-        topic = self._makeTopic('with_sort', False).__of__(self.root)
+        topic = self._makeTopic('with_sort', False).__of__(self.app)
         data = _CRITERIA_DATA[4]
         topic.addCriterion(data[0], data[1])
         topic.getCriterion(data[0]).edit(**data[2])
@@ -210,19 +210,19 @@
         context = DummyExportContext(topic)
         adapter.export(context, 'test', False)
 
-        self.assertEqual( len( context._wrote ), 2 )
-        filename, text, content_type = context._wrote[ 0 ]
-        self.assertEqual( filename, 'test/with_sort/.objects' )
-        self.assertEqual( text, '' )
-        self.assertEqual( content_type, 'text/comma-separated-values' )
+        self.assertEqual(len(context._wrote), 2)
+        filename, text, content_type = context._wrote[0]
+        self.assertEqual(filename, 'test/with_sort/.objects')
+        self.assertEqual(text, '')
+        self.assertEqual(content_type, 'text/comma-separated-values')
 
-        filename, text, content_type = context._wrote[ 1 ]
-        self.assertEqual( filename, 'test/with_sort/criteria.xml' )
-        self._compareDOM( text, _SORT_TOPIC_CRITERIA )
-        self.assertEqual( content_type, 'text/xml' )
+        filename, text, content_type = context._wrote[1]
+        self.assertEqual(filename, 'test/with_sort/criteria.xml')
+        self._compareDOM(text, _SORT_TOPIC_CRITERIA)
+        self.assertEqual(content_type, 'text/xml')
 
     def test_export_with_mixed_criteria(self):
-        topic = self._makeTopic('with_mixed', False).__of__(self.root)
+        topic = self._makeTopic('with_mixed', False).__of__(self.app)
         for index in 0, 2, 4:
             data = _CRITERIA_DATA[index]
             topic.addCriterion(data[0], data[1])
@@ -232,19 +232,19 @@
         context = DummyExportContext(topic)
         adapter.export(context, 'test', False)
 
-        self.assertEqual( len( context._wrote ), 2 )
-        filename, text, content_type = context._wrote[ 0 ]
-        self.assertEqual( filename, 'test/with_mixed/.objects' )
-        self.assertEqual( text, '' )
-        self.assertEqual( content_type, 'text/comma-separated-values' )
+        self.assertEqual(len(context._wrote), 2)
+        filename, text, content_type = context._wrote[0]
+        self.assertEqual(filename, 'test/with_mixed/.objects')
+        self.assertEqual(text, '')
+        self.assertEqual(content_type, 'text/comma-separated-values')
 
-        filename, text, content_type = context._wrote[ 1 ]
-        self.assertEqual( filename, 'test/with_mixed/criteria.xml' )
-        self._compareDOM( text, _MIXED_TOPIC_CRITERIA )
-        self.assertEqual( content_type, 'text/xml' )
+        filename, text, content_type = context._wrote[1]
+        self.assertEqual(filename, 'test/with_mixed/criteria.xml')
+        self._compareDOM(text, _MIXED_TOPIC_CRITERIA)
+        self.assertEqual(content_type, 'text/xml')
 
     def test_import_empty_with_string_criterion(self):
-        topic = self._makeTopic('empty', False).__of__(self.root)
+        topic = self._makeTopic('empty', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyImportContext(topic, encoding='ascii')
@@ -264,7 +264,7 @@
         self.assertEqual(criterion.value, expected[2]['value'])
 
     def test_import_empty_with_integer_criterion(self):
-        topic = self._makeTopic('empty', False).__of__(self.root)
+        topic = self._makeTopic('empty', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyImportContext(topic, encoding='ascii')
@@ -285,7 +285,7 @@
         self.assertEqual(criterion.direction, expected[2]['direction'])
 
     def test_import_empty_with_date_criterion(self):
-        topic = self._makeTopic('empty', False).__of__(self.root)
+        topic = self._makeTopic('empty', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyImportContext(topic, encoding='ascii')
@@ -307,7 +307,7 @@
         self.assertEqual(criterion.daterange, expected[2]['daterange'])
 
     def test_import_empty_with_list_criterion(self):
-        topic = self._makeTopic('empty', False).__of__(self.root)
+        topic = self._makeTopic('empty', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyImportContext(topic, encoding='ascii')
@@ -328,7 +328,7 @@
         self.assertEqual(criterion.operator, expected[2]['operator'])
 
     def test_import_empty_with_sort_criterion(self):
-        topic = self._makeTopic('empty', False).__of__(self.root)
+        topic = self._makeTopic('empty', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyImportContext(topic, encoding='ascii')
@@ -349,7 +349,7 @@
         self.assertEqual(criterion.reversed, bool(expected[2]['reversed']))
 
     def test_import_empty_with_mixed_criterion(self):
-        topic = self._makeTopic('empty', False).__of__(self.root)
+        topic = self._makeTopic('empty', False).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyImportContext(topic, encoding='ascii')
@@ -389,7 +389,7 @@
 
     def test_import_without_purge_leaves_existing_criteria(self):
 
-        topic = self._makeTopic('with_criteria', True).__of__(self.root)
+        topic = self._makeTopic('with_criteria', True).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyImportContext(topic, purge=False)
@@ -402,7 +402,7 @@
 
     def test_import_with_purge_removes_existing_criteria(self):
 
-        topic = self._makeTopic('with_criteria', True).__of__(self.root)
+        topic = self._makeTopic('with_criteria', True).__of__(self.app)
         adapter = self._makeOne(topic)
 
         context = DummyImportContext(topic, purge=True)



More information about the checkins mailing list