Unfutz naive timezon issues.

src/Products/PluginIndexes/DateRangeIndex/tests/test_DateRangeIndex.py

@@ -16,14 +16,6 @@ $Id$
 """
 
 import unittest
-import Testing
-import Zope2
-Zope2.startup()
-
-import sys
-
-from Products.PluginIndexes.DateRangeIndex.DateRangeIndex import DateRangeIndex
-
 
 class Dummy:
 
@@ -74,11 +66,22 @@ def matchingDummies( value ):
 
 class DRI_Tests( unittest.TestCase ):
 
-    def setUp( self ):
-        pass
 
-    def tearDown( self ):
-        pass
+    def _getTargetClass(self):
+        from Products.PluginIndexes.DateRangeIndex.DateRangeIndex \
+            import DateRangeIndex
+        return DateRangeIndex
+
+    def _makeOne(self,
+                 id,
+                 since_field=None,
+                 until_field=None,
+                 caller=None,
+                 extra=None,
+                ):
+        klass = self._getTargetClass()
+        return klass(id, since_field, until_field, caller, extra)
+
 
     def test_z3interfaces(self):
         from Products.PluginIndexes.interfaces import IDateRangeIndex
@@ -87,14 +90,14 @@ class DRI_Tests( unittest.TestCase ):
         from Products.PluginIndexes.interfaces import IUniqueValueIndex
         from zope.interface.verify import verifyClass
 
-        verifyClass(IDateRangeIndex, DateRangeIndex)
-        verifyClass(IPluggableIndex, DateRangeIndex)
-        verifyClass(ISortIndex, DateRangeIndex)
-        verifyClass(IUniqueValueIndex, DateRangeIndex)
+        verifyClass(IDateRangeIndex, self._getTargetClass())
+        verifyClass(IPluggableIndex, self._getTargetClass())
+        verifyClass(ISortIndex, self._getTargetClass())
+        verifyClass(IUniqueValueIndex, self._getTargetClass())
 
     def test_empty( self ):
 
-        empty = DateRangeIndex( 'empty' )
+        empty = self._makeOne( 'empty' )
 
         self.failUnless(empty.getEntryForObject( 1234 ) is None)
         empty.unindex_object( 1234 ) # shouldn't throw
@@ -111,18 +114,18 @@ class DRI_Tests( unittest.TestCase ):
 
     def test_retrieval( self ):
 
-        work = DateRangeIndex( 'work', 'start', 'stop' )
+        index = self._makeOne( 'work', 'start', 'stop' )
 
         for i in range( len( dummies ) ):
-            work.index_object( i, dummies[i] )
+            index.index_object( i, dummies[i] )
 
         for i in range( len( dummies ) ):
-            self.assertEqual(work.getEntryForObject( i ), dummies[i].datum())
+            self.assertEqual(index.getEntryForObject( i ), dummies[i].datum())
 
         for value in range( -1, 15 ):
 
             matches = matchingDummies( value )
-            results, used = work._apply_index( { 'work' : value } )
+            results, used = index._apply_index( { 'work' : value } )
             self.assertEqual(used, ( 'start', 'stop' ))
 
             self.assertEqual(len( matches ), len( results ))
@@ -130,43 +133,84 @@ class DRI_Tests( unittest.TestCase ):
             matches.sort( lambda x, y: cmp( x.name(), y.name() ) )
 
             for result, match in map( None, results, matches ):
-                self.assertEqual(work.getEntryForObject(result), match.datum())
+                self.assertEqual(index.getEntryForObject(result), match.datum())
 
     def test_longdates( self ):
         self.assertRaises(OverflowError, self._badlong )
 
     def _badlong(self):
-        work = DateRangeIndex ('work', 'start', 'stop' )
+        import sys
+        index = self._makeOne ('work', 'start', 'stop' )
         bad = Dummy( 'bad', long(sys.maxint) + 1, long(sys.maxint) + 1 )
-        work.index_object( 0, bad )
+        index.index_object( 0, bad )
 
     def test_datetime(self):
         from datetime import datetime
+        from DateTime.DateTime import DateTime
+        from Products.PluginIndexes.DateIndex.tests.test_DateIndex \
+            import _getEastern
+        before = datetime(2009, 7, 11, 0, 0, tzinfo=_getEastern())
+        start = datetime(2009, 7, 13, 5, 15, tzinfo=_getEastern())
+        between = datetime(2009, 7, 13, 5, 45, tzinfo=_getEastern())
+        stop = datetime(2009, 7, 13, 6, 30, tzinfo=_getEastern())
+        after = datetime(2009, 7, 14, 0, 0, tzinfo=_getEastern())
+
+        dummy = Dummy('test', start, stop)
+        index = self._makeOne( 'work', 'start', 'stop' )
+        index.index_object(0, dummy)
+
+        self.assertEqual(index.getEntryForObject(0),
+                        (DateTime(start).millis() / 60000,
+                         DateTime(stop).millis() / 60000))
+
+        results, used = index._apply_index( { 'work' : before } )
+        self.assertEqual(len(results), 0)
+
+        results, used = index._apply_index( { 'work' : start } )
+        self.assertEqual(len(results), 1)
+
+        results, used = index._apply_index( { 'work' : between } )
+        self.assertEqual(len(results), 1)
+
+        results, used = index._apply_index( { 'work' : stop } )
+        self.assertEqual(len(results), 1)
+
+        results, used = index._apply_index( { 'work' : after } )
+        self.assertEqual(len(results), 0)
+
+    def test_datetime_naive_timezone(self):
+        from datetime import datetime
+        from DateTime.DateTime import DateTime
+        from Products.PluginIndexes.DateIndex.DateIndex import Local
         before = datetime(2009, 7, 11, 0, 0)
         start = datetime(2009, 7, 13, 5, 15)
+        start_local = datetime(2009, 7, 13, 5, 15, tzinfo=Local)
         between = datetime(2009, 7, 13, 5, 45)
         stop = datetime(2009, 7, 13, 6, 30)
+        stop_local = datetime(2009, 7, 13, 6, 30, tzinfo=Local)
         after = datetime(2009, 7, 14, 0, 0)
 
         dummy = Dummy('test', start, stop)
-        work = DateRangeIndex( 'work', 'start', 'stop' )
-        work.index_object(0, dummy)
+        index = self._makeOne( 'work', 'start', 'stop' )
+        index.index_object(0, dummy)
 
-        self.assertEqual(work.getEntryForObject(0), (20790915, 20790990))
+        self.assertEqual(index.getEntryForObject(0),
+                        (DateTime(start_local).millis() / 60000,
+                         DateTime(stop_local).millis() / 60000))
 
-        results, used = work._apply_index( { 'work' : before } )
+        results, used = index._apply_index( { 'work' : before } )
         self.assertEqual(len(results), 0)
 
-        results, used = work._apply_index( { 'work' : start } )
+        results, used = index._apply_index( { 'work' : start } )
         self.assertEqual(len(results), 1)
 
-        results, used = work._apply_index( { 'work' : between } )
+        results, used = index._apply_index( { 'work' : between } )
         self.assertEqual(len(results), 1)
 
-        results, used = work._apply_index( { 'work' : stop } )
+        results, used = index._apply_index( { 'work' : stop } )
         self.assertEqual(len(results), 1)
 
-        results, used = work._apply_index( { 'work' : after } )
+        results, used = index._apply_index( { 'work' : after } )
         self.assertEqual(len(results), 0)