[SQL-CVS] r525 - in trunk/SQLObject: sqlobject tests

[<sub...@co...>]

Author: phd
Date: 2005-01-09 16:54:03 +0000 (Sun, 09 Jan 2005)
New Revision: 525

Modified:
   trunk/SQLObject/sqlobject/col.py
   trunk/SQLObject/tests/test_sqlobject.py
Log:
A lot of minor improvements and bug fixes in date/time validators and tests.
Added tests for MXDateTimeValidator.


Modified: trunk/SQLObject/sqlobject/col.py
===================================================================
--- trunk/SQLObject/sqlobject/col.py	2005-01-09 11:38:33 UTC (rev 524)
+++ trunk/SQLObject/sqlobject/col.py	2005-01-09 16:54:03 UTC (rev 525)
@@ -46,9 +46,12 @@
     default_datetime_implementation = None
 
 __all__ = ["datetime_available", "mxdatetime_available",
-    "DATETIME_IMPLEMENTATION", "MXDATETIME_IMPLEMENTATION",
     "default_datetime_implementation"
 ]
+if datetime_available:
+    __all__.append("DATETIME_IMPLEMENTATION")
+if mxdatetime_available:
+    __all__.append("MXDATETIME_IMPLEMENTATION")
 
 ########################################
 ## Columns
@@ -658,82 +661,85 @@
     baseClass = SOEnumCol
 
 
-class DateTimeValidator(validators.DateValidator):
-    def fromPython(self, value, state):
-        if value is None:
-            return None
-        if isinstance(value, (datetime.date, datetime.datetime)):
-            return value
-        if hasattr(value, "strftime"):
-            return value.strftime(self.format)
-        raise validators.InvalidField("expected a datetime in the DateTimeCol '%s', got %s instead" % \
-            (self.name, type(value)), value, state)
+if datetime_available:
+    class DateTimeValidator(validators.DateValidator):
+        def fromPython(self, value, state):
+            if value is None:
+                return None
+            if isinstance(value, (datetime.date, datetime.datetime)):
+                return value
+            if hasattr(value, "strftime"):
+                return value.strftime(self.format)
+            raise validators.InvalidField("expected a datetime in the DateTimeCol '%s', got %s instead" % \
+                (self.name, type(value)), value, state)
 
-    def toPython(self, value, state):
-        if value is None:
-            return None
-        if isinstance(value, (datetime.date, datetime.datetime)):
-            return value
-        if mxdatetime_available: # convert mxDateTime instance to datetime
-            if isinstance(value, DateTimeType):
+        def toPython(self, value, state):
+            if value is None:
+                return None
+            if isinstance(value, (datetime.date, datetime.datetime)):
+                return value
+            if mxdatetime_available and isinstance(value, DateTimeType):
+                # convert mxDateTime instance to datetime
                 if ("%H" in self.format) or ("%T" in self.format):
                     return datetime.datetime(value.year, value.month, value.day,
                         value.hour, value.minute, value.second)
                 else:
                     return datetime.date(value.year, value.month, value.day)
-        try:
-            stime = time.strptime(value, self.format)
-        except:
-            raise validators.InvalidField("expected an ISO date/time string in the DateTimeCol '%s', got %s instead" % \
+            try:
+                stime = time.strptime(value, self.format)
+            except:
+                raise validators.InvalidField("expected an date/time string of the '%s' format in the DateTimeCol '%s', got %s instead" % \
+                    (self.format, self.name, type(value)), value, state)
+            secs = time.mktime(stime)
+            return datetime.datetime.fromtimestamp(secs)
+
+if mxdatetime_available:
+    class MXDateTimeValidator(validators.DateValidator):
+        def fromPython(self, value, state):
+            if value is None:
+                return None
+            if isinstance(value, DateTimeType):
+                return value
+            if hasattr(value, "strftime"):
+                return value.strftime(self.format)
+            raise validators.InvalidField("expected a mxDateTime in the DateTimeCol '%s', got %s instead" % \
                 (self.name, type(value)), value, state)
-        secs = time.mktime(stime)
-        return datetime.datetime.fromtimestamp(secs)
 
-class MXDateTimeValidator(validators.DateValidator):
-    def fromPython(self, value, state):
-        if value is None:
-            return None
-        if isinstance(value, DateTimeType):
-            return value
-        if hasattr(value, "strftime"):
-            return value.strftime(self.format)
-        raise validators.InvalidField("expected a mxDateTime in the DateTimeCol '%s', got %s instead" % \
-            (self.name, type(value)), value, state)
-
-    def toPython(self, value, state):
-        if value is None:
-            return None
-        if isinstance(value, DateTimeType):
-            return value
-        if datetime_available: # convert datetime instance to mxDateTime
-            if isinstance(value, (datetime.date, datetime.datetime)):
-                if hasattr(value, "hour"):
+        def toPython(self, value, state):
+            if value is None:
+                return None
+            if isinstance(value, DateTimeType):
+                return value
+            if datetime_available: # convert datetime instance to mxDateTime
+                if isinstance(value, datetime.datetime):
                     return DateTime.DateTime(value.year, value.month, value.day,
                         value.hour, value.minute, value.second)
-                else:
+                elif isinstance(value, datetime.date):
                     return DateTime.Date(value.year, value.month, value.day)
-        try:
-            stime = time.strptime(value, self.format)
-        except:
-            raise validators.InvalidField("expected an ISO date/time string in the DateTimeCol '%s', got %s instead" % \
-                (self.name, type(value)), value, state)
-        return DateTime.DateTime.mktime(stime)
+            try:
+                stime = time.strptime(value, self.format)
+            except:
+                raise validators.InvalidField("expected an date/time string of the '%s' format in the DateTimeCol '%s', got %s instead" % \
+                    (self.format, self.name, type(value)), value, state)
+            return DateTime.mktime(stime)
 
 class SODateTimeCol(SOCol):
-    if default_datetime_implementation == DATETIME_IMPLEMENTATION:
-        validatorClass = DateTimeValidator # can be overriden in descendants
-    elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
-        validatorClass = MXDateTimeValidator # can be overriden in descendants
     datetimeFormat = '%Y-%m-%d %H:%M:%S'
 
     def __init__(self, **kw):
+        datetimeFormat = popKey(kw, 'datetimeFormat')
+        if datetimeFormat: self.datetimeFormat = datetimeFormat
         SOCol.__init__(self, **kw)
         if default_datetime_implementation:
             self.validator = validators.All.join(self.createValidator(), self.validator)
 
     def createValidator(self):
         """Create a validator for the column. Can be overriden in descendants."""
-        return self.validatorClass(name=self.name, format=self.datetimeFormat)
+        if default_datetime_implementation == DATETIME_IMPLEMENTATION:
+            validatorClass = DateTimeValidator
+        elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
+            validatorClass = MXDateTimeValidator
+        return validatorClass(name=self.name, format=self.datetimeFormat)
 
     def _mysqlType(self):
         return 'DATETIME'
@@ -757,20 +763,22 @@
     baseClass = SODateTimeCol
 
 class SODateCol(SOCol):
-    if default_datetime_implementation == DATETIME_IMPLEMENTATION:
-        validatorClass = DateTimeValidator # can be overriden in descendants
-    elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
-        validatorClass = MXDateTimeValidator # can be overriden in descendants
     dateFormat = '%Y-%m-%d'
 
     def __init__(self, **kw):
+        dateFormat = popKey(kw, 'dateFormat')
+        if dateFormat: self.dateFormat = dateFormat
         SOCol.__init__(self, **kw)
         if default_datetime_implementation:
             self.validator = validators.All.join(self.createValidator(), self.validator)
 
     def createValidator(self):
         """Create a validator for the column. Can be overriden in descendants."""
-        return self.validatorClass(name=self.name, format=self.dateFormat)
+        if default_datetime_implementation == DATETIME_IMPLEMENTATION:
+            validatorClass = DateTimeValidator
+        elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
+            validatorClass = MXDateTimeValidator
+        return validatorClass(name=self.name, format=self.dateFormat)
 
     def _mysqlType(self):
         return 'DATE'

Modified: trunk/SQLObject/tests/test_sqlobject.py
===================================================================
--- trunk/SQLObject/tests/test_sqlobject.py	2005-01-09 11:38:33 UTC (rev 524)
+++ trunk/SQLObject/tests/test_sqlobject.py	2005-01-09 16:54:03 UTC (rev 525)
@@ -17,6 +17,7 @@
 
 from SQLObjectTest import *
 from sqlobject import *
+from sqlobject import col
 from sqlobject.include import validators
 from sqlobject import classregistry
 if default_datetime_implementation == DATETIME_IMPLEMENTATION:
@@ -1292,23 +1293,57 @@
 ## Date/time columns
 ########################################
 
-class DateTime1(SQLObject):
-    col1 = DateCol()
-    col2 = DateTimeCol()
+if datetime_available:
+    col.default_datetime_implementation = DATETIME_IMPLEMENTATION
+    from datetime import date, datetime
 
-class DateTimeTest(SQLObjectTest):
+    class DateTime1(SQLObject):
+        col1 = DateCol()
+        col2 = DateTimeCol()
 
-    classes = [DateTime1]
+    class DateTimeTest1(SQLObjectTest):
 
-    def testNow(self):
-        _now = now()
-        dt1 = DateTime1(col1=_now, col2=_now)
+        classes = [DateTime1]
 
-        today_str = _now.strftime(SODateCol.dateFormat)
-        now_str = _now.strftime(SODateTimeCol.datetimeFormat)
-        self.assertEqual(str(dt1.col1), today_str)
-        self.assertEqual(str(dt1.col2), now_str)
+        def testDateTime(self):
+            _now = now()
+            dt1 = DateTime1(col1=_now, col2=_now)
 
+            date_type = date
+            datetime_type = datetime
+            self.assertEqual(type(dt1.col1), date_type)
+            self.assertEqual(type(dt1.col2), datetime_type)
+
+            today_str = _now.strftime("%Y-%m-%d")
+            now_str = _now.strftime("%Y-%m-%d %T")
+            self.assertEqual(str(dt1.col1), today_str)
+            self.assertEqual(str(dt1.col2), now_str)
+
+if mxdatetime_available:
+    col.default_datetime_implementation = MXDATETIME_IMPLEMENTATION
+
+    class DateTime2(SQLObject):
+        col1 = DateCol()
+        col2 = DateTimeCol()
+
+    class DateTimeTest2(SQLObjectTest):
+
+        classes = [DateTime2]
+
+        def testMxDateTime(self):
+            _now = now()
+            dt2 = DateTime2(col1=_now, col2=_now)
+
+            date_type = col.DateTimeType
+            datetime_type = col.DateTimeType
+            self.assertEqual(type(dt2.col1), date_type)
+            self.assertEqual(type(dt2.col2), datetime_type)
+
+            today_str = _now.strftime("%Y-%m-%d 00:00:00.00")
+            now_str = _now.strftime("%Y-%m-%d %T.00")
+            self.assertEqual(str(dt2.col1), today_str)
+            self.assertEqual(str(dt2.col2), now_str)
+
 ########################################
 ## Run from command-line:
 ########################################