Delete converters, move unit tests to test_fields, add new additional test cases.

cms/djangoapps/contentstore/tests/test_course_settings.py

 import datetime
 import json
 import copy
-from util import converters
-from util.converters import jsdate_to_time
 
 from django.contrib.auth.models import User
 from django.test.client import Client
@@ -15,69 +13,13 @@ from models.settings.course_details import (CourseDetails,
 from models.settings.course_grading import CourseGradingModel
 from contentstore.utils import get_modulestore
 
-from django.test import TestCase
 from .utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 
 from models.settings.course_metadata import CourseMetadata
 from xmodule.modulestore.xml_importer import import_from_xml
 from xmodule.modulestore.django import modulestore
-import time
-
-
-# YYYY-MM-DDThh:mm:ss.s+/-HH:MM
-class ConvertersTestCase(TestCase):
-    @staticmethod
-    def struct_to_datetime(struct_time):
-        return datetime.datetime(struct_time.tm_year, struct_time.tm_mon,
-            struct_time.tm_mday, struct_time.tm_hour,
-            struct_time.tm_min, struct_time.tm_sec, tzinfo=UTC())
-
-    def compare_dates(self, date1, date2, expected_delta):
-        dt1 = ConvertersTestCase.struct_to_datetime(date1)
-        dt2 = ConvertersTestCase.struct_to_datetime(date2)
-        self.assertEqual(dt1 - dt2, expected_delta, str(date1) + "-"
-            + str(date2) + "!=" + str(expected_delta))
-
-    def test_iso_to_struct(self):
-        '''Test conversion from iso compatible date strings to struct_time'''
-        self.compare_dates(converters.jsdate_to_time("2013-01-01"),
-            converters.jsdate_to_time("2012-12-31"),
-            datetime.timedelta(days=1))
-        self.compare_dates(converters.jsdate_to_time("2013-01-01T00"),
-            converters.jsdate_to_time("2012-12-31T23"),
-            datetime.timedelta(hours=1))
-        self.compare_dates(converters.jsdate_to_time("2013-01-01T00:00"),
-            converters.jsdate_to_time("2012-12-31T23:59"),
-            datetime.timedelta(minutes=1))
-        self.compare_dates(converters.jsdate_to_time("2013-01-01T00:00:00"),
-            converters.jsdate_to_time("2012-12-31T23:59:59"),
-            datetime.timedelta(seconds=1))
-        self.compare_dates(converters.jsdate_to_time("2013-01-01T00:00:00Z"),
-            converters.jsdate_to_time("2012-12-31T23:59:59Z"),
-            datetime.timedelta(seconds=1))
-        self.compare_dates(
-            converters.jsdate_to_time("2012-12-31T23:00:01-01:00"),
-            converters.jsdate_to_time("2013-01-01T00:00:00+01:00"),
-            datetime.timedelta(hours=1, seconds=1))
-
-    def test_struct_to_iso(self):
-        '''
-        Test converting time reprs to iso dates
-        '''
-        self.assertEqual(
-            converters.time_to_isodate(
-                time.strptime("2012-12-31T23:59:59Z", "%Y-%m-%dT%H:%M:%SZ")),
-            "2012-12-31T23:59:59Z")
-        self.assertEqual(
-            converters.time_to_isodate(
-                jsdate_to_time("2012-12-31T23:59:59Z")),
-            "2012-12-31T23:59:59Z")
-        self.assertEqual(
-            converters.time_to_isodate(
-                jsdate_to_time("2012-12-31T23:00:01-01:00")),
-            "2013-01-01T00:00:01Z")
-
+from xmodule.fields import Date
 
 class CourseTestCase(ModuleStoreTestCase):
     def setUp(self):
@@ -206,17 +148,24 @@ class CourseDetailsViewTest(CourseTestCase):
         self.assertEqual(details['intro_video'], encoded.get('intro_video', None), context + " intro_video not ==")
         self.assertEqual(details['effort'], encoded['effort'], context + " efforts not ==")
 
+    @staticmethod
+    def struct_to_datetime(struct_time):
+        return datetime.datetime(struct_time.tm_year, struct_time.tm_mon,
+            struct_time.tm_mday, struct_time.tm_hour,
+            struct_time.tm_min, struct_time.tm_sec, tzinfo=UTC())
+
     def compare_date_fields(self, details, encoded, context, field):
         if details[field] is not None:
+            date = Date()
             if field in encoded and encoded[field] is not None:
-                encoded_encoded = jsdate_to_time(encoded[field])
-                dt1 = ConvertersTestCase.struct_to_datetime(encoded_encoded)
+                encoded_encoded = date.from_json(encoded[field])
+                dt1 = CourseDetailsViewTest.struct_to_datetime(encoded_encoded)
 
                 if isinstance(details[field], datetime.datetime):
                     dt2 = details[field]
                 else:
-                    details_encoded = jsdate_to_time(details[field])
-                    dt2 = ConvertersTestCase.struct_to_datetime(details_encoded)
+                    details_encoded = date.from_json(details[field])
+                    dt2 = CourseDetailsViewTest.struct_to_datetime(details_encoded)
 
                 expected_delta = datetime.timedelta(0)
                 self.assertEqual(dt1 - dt2, expected_delta, str(dt1) + "!=" + str(dt2) + " at " + context)

cms/djangoapps/models/settings/course_details.py

-from xmodule.modulestore.django import modulestore
 from xmodule.modulestore import Location
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from xmodule.modulestore.inheritance import own_metadata
 import json
 from json.encoder import JSONEncoder
 import time
+import calendar
 from contentstore.utils import get_modulestore
-from util.converters import jsdate_to_time, time_to_date
 from models.settings import course_grading
 from contentstore.utils import update_item
+from xmodule.fields import Date
 import re
 import logging
 
@@ -81,8 +81,14 @@ class CourseDetails(object):
 
         dirty = False
 
+        # In the descriptor's setter, the date is converted to JSON using Date's to_json method.
+        # Calling to_json on something that is already JSON doesn't work. Since reaching directly
+        # into the model is nasty, convert the JSON Date to a Python date, which is what the
+        # setter expects as input.
+        date = Date()
+
         if 'start_date' in jsondict:
-            converted = jsdate_to_time(jsondict['start_date'])
+            converted = date.from_json(jsondict['start_date'])
         else:
             converted = None
         if converted != descriptor.start:
@@ -90,7 +96,7 @@ class CourseDetails(object):
             descriptor.start = converted
 
         if 'end_date' in jsondict:
-            converted = jsdate_to_time(jsondict['end_date'])
+            converted = date.from_json(jsondict['end_date'])
         else:
             converted = None
 
@@ -99,7 +105,7 @@ class CourseDetails(object):
             descriptor.end = converted
 
         if 'enrollment_start' in jsondict:
-            converted = jsdate_to_time(jsondict['enrollment_start'])
+            converted = date.from_json(jsondict['enrollment_start'])
         else:
             converted = None
 
@@ -108,7 +114,7 @@ class CourseDetails(object):
             descriptor.enrollment_start = converted
 
         if 'enrollment_end' in jsondict:
-            converted = jsdate_to_time(jsondict['enrollment_end'])
+            converted = date.from_json(jsondict['enrollment_end'])
         else:
             converted = None
 
@@ -172,12 +178,20 @@ class CourseDetails(object):
 
 # TODO move to a more general util? Is there a better way to do the isinstance model check?
 class CourseSettingsEncoder(json.JSONEncoder):
+    @staticmethod
+    def time_to_date(time_obj):
+        """
+        Convert a time.time_struct to a true universal time (can pass to js Date
+        constructor)
+        """
+        return calendar.timegm(time_obj) * 1000
+
     def default(self, obj):
         if isinstance(obj, CourseDetails) or isinstance(obj, course_grading.CourseGradingModel):
             return obj.__dict__
         elif isinstance(obj, Location):
             return obj.dict()
         elif isinstance(obj, time.struct_time):
-            return time_to_date(obj)
+            return CourseSettingsEncoder.time_to_date(obj)
         else:
             return JSONEncoder.default(self, obj)

cms/djangoapps/models/settings/course_grading.py

 from xmodule.modulestore import Location
 from contentstore.utils import get_modulestore
-import re
-from util import converters
 from datetime import timedelta
 
 

common/djangoapps/util/converters.py

-import time
-import datetime
-import calendar
-import dateutil.parser
-
-
-def time_to_date(time_obj):
-    """
-    Convert a time.time_struct to a true universal time (can pass to js Date
-    constructor)
-    """
-    return calendar.timegm(time_obj) * 1000
-
-
-def time_to_isodate(source):
-    '''Convert to an iso date'''
-    if isinstance(source, time.struct_time):
-        return time.strftime('%Y-%m-%dT%H:%M:%SZ', source)
-    elif isinstance(source, datetime):
-        return source.isoformat() + 'Z'
-
-
-def jsdate_to_time(field):
-    """
-    Convert a universal time (iso format) or msec since epoch to a time obj
-    """
-    if field is None:
-        return field
-    elif isinstance(field, basestring):
-        d = dateutil.parser.parse(field)
-        return d.utctimetuple()
-    elif isinstance(field, (int, long, float)):
-        return time.gmtime(field / 1000)
-    elif isinstance(field, time.struct_time):
-        return field
-    else:
-        raise ValueError("Couldn't convert %r to time" % field)

common/lib/xmodule/xmodule/fields.py

@@ -14,7 +14,6 @@ class Date(ModelType):
     '''
     Date fields know how to parse and produce json (iso) compatible formats.
     '''
-    # NB: these are copies of util.converters.*
     def from_json(self, field):
         """
         Parse an optional metadata key containing a time: if present, complain

common/lib/xmodule/xmodule/tests/test_fields.py

+"""Tests for Date class defined in fields.py."""
+import datetime
+import unittest
+from django.utils.timezone import UTC
+from xmodule.fields import Date
+import time
+
+class DateTest(unittest.TestCase):
+    date = Date()
+
+    @staticmethod
+    def struct_to_datetime(struct_time):
+        return datetime.datetime(struct_time.tm_year, struct_time.tm_mon,
+            struct_time.tm_mday, struct_time.tm_hour,
+            struct_time.tm_min, struct_time.tm_sec, tzinfo=UTC())
+
+    def compare_dates(self, date1, date2, expected_delta):
+        dt1 = DateTest.struct_to_datetime(date1)
+        dt2 = DateTest.struct_to_datetime(date2)
+        self.assertEqual(dt1 - dt2, expected_delta, str(date1) + "-"
+                                                    + str(date2) + "!=" + str(expected_delta))
+
+    def test_from_json(self):
+        '''Test conversion from iso compatible date strings to struct_time'''
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01"),
+            DateTest.date.from_json("2012-12-31"),
+            datetime.timedelta(days=1))
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01T00"),
+            DateTest.date.from_json("2012-12-31T23"),
+            datetime.timedelta(hours=1))
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01T00:00"),
+            DateTest.date.from_json("2012-12-31T23:59"),
+            datetime.timedelta(minutes=1))
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01T00:00:00"),
+            DateTest.date.from_json("2012-12-31T23:59:59"),
+            datetime.timedelta(seconds=1))
+        self.compare_dates(
+            DateTest.date.from_json("2013-01-01T00:00:00Z"),
+            DateTest.date.from_json("2012-12-31T23:59:59Z"),
+            datetime.timedelta(seconds=1))
+        self.compare_dates(
+            DateTest.date.from_json("2012-12-31T23:00:01-01:00"),
+            DateTest.date.from_json("2013-01-01T00:00:00+01:00"),
+            datetime.timedelta(hours=1, seconds=1))
+
+    def test_return_None(self):
+        self.assertIsNone(DateTest.date.from_json(""))
+        self.assertIsNone(DateTest.date.from_json(None))
+        self.assertIsNone(DateTest.date.from_json(['unknown value']))
+
+    def test_old_due_date_format(self):
+        current = datetime.datetime.today()
+        self.assertEqual(
+            time.struct_time((current.year, 3, 12, 12, 0, 0, 1, 71, 0)),
+            DateTest.date.from_json("March 12 12:00"))
+        self.assertEqual(
+            time.struct_time((current.year, 12, 4, 16, 30, 0, 2, 338, 0)),
+            DateTest.date.from_json("December 4 16:30"))
+
+    def test_to_json(self):
+        '''
+        Test converting time reprs to iso dates
+        '''
+        self.assertEqual(
+            DateTest.date.to_json(
+                time.strptime("2012-12-31T23:59:59Z", "%Y-%m-%dT%H:%M:%SZ")),
+            "2012-12-31T23:59:59Z")
+        self.assertEqual(
+            DateTest.date.to_json(
+                DateTest.date.from_json("2012-12-31T23:59:59Z")),
+            "2012-12-31T23:59:59Z")
+        self.assertEqual(
+            DateTest.date.to_json(
+                DateTest.date.from_json("2012-12-31T23:00:01-01:00")),
+            "2013-01-01T00:00:01Z")
+