diff --git a/webapp/tests/test_attime.py b/webapp/tests/test_attime.py
index 8ddd1b9a0..d26b6f2de 100644
--- a/webapp/tests/test_attime.py
+++ b/webapp/tests/test_attime.py
@@ -11,102 +11,107 @@
 import pytz
 import mock
 
+def make_aware(dt, timezone):
+    if hasattr(timezone, 'localize'):
+        return timezone.localize(dt)
+    else:
+        return dt.replace(tzinfo=timezone)
 
 def mockDateTime(year, month, day, hour, minute, second):
     class MockedDateTime(datetime):
         @classmethod
         def now(cls, tzinfo=None):
             if tzinfo:
-                return tzinfo.localize(cls(year, month, day, hour, minute, second))
+                return make_aware(cls(year, month, day, hour, minute, second), tzinfo)
             return cls(year, month, day, hour, minute, second)
 
     return MockedDateTime
 
-
 @mock.patch('graphite.render.attime.datetime', mockDateTime(2015, 3, 8, 12, 0, 0))
 class ATTimeTimezoneTests(TestCase):
     default_tz = timezone.get_current_timezone()
     specified_tz = pytz.timezone("America/Los_Angeles")
-    MOCK_DATE = specified_tz.localize(datetime(2015, 1, 1, 11, 00))
+    MOCK_DATE = make_aware(datetime(2015, 1, 1, 11, 00), specified_tz)
 
     def test_should_return_absolute_time(self):
         time_string = '12:0020150308'
-        expected_time = self.default_tz.localize(datetime.strptime(time_string,'%H:%M%Y%m%d'))
+        expected_time = make_aware(datetime.strptime(time_string,'%H:%M%Y%m%d'), self.default_tz)
         actual_time = parseATTime(time_string)
         self.assertEqual(actual_time, expected_time)
 
     def test_absolute_time_should_respect_tz(self):
         time_string = '12:0020150308'
-        expected_time = self.specified_tz.localize(datetime.strptime(time_string, '%H:%M%Y%m%d'))
+        expected_time = make_aware(datetime.strptime(time_string, '%H:%M%Y%m%d'), self.specified_tz)
         actual_time = parseATTime(time_string, self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_should_return_absolute_time_short(self):
         time_string = '9:0020150308'
-        expected_time = self.default_tz.localize(datetime.strptime(time_string,'%H:%M%Y%m%d'))
+        expected_time = make_aware(datetime.strptime(time_string,'%H:%M%Y%m%d'), self.default_tz)
         actual_time = parseATTime(time_string)
         self.assertEqual(actual_time, expected_time)
 
     def test_absolute_time_should_respect_tz_short(self):
         time_string = '9:0020150308'
-        expected_time = self.specified_tz.localize(datetime.strptime(time_string, '%H:%M%Y%m%d'))
+        expected_time = make_aware(datetime.strptime(time_string, '%H:%M%Y%m%d'), self.specified_tz)
         actual_time = parseATTime(time_string, self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_absolute_time_YYYYMMDD(self):
         time_string = '20150110'
-        expected_time = self.specified_tz.localize(datetime.strptime(time_string, '%Y%m%d'))
+        expected_time = make_aware(datetime.strptime(time_string, '%Y%m%d'), self.specified_tz)
         actual_time = parseATTime(time_string, self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_midnight(self):
-        expected_time = self.specified_tz.localize(datetime.strptime("0:00_20150308", '%H:%M_%Y%m%d'))
+        expected_time = make_aware(datetime.strptime("0:00_20150308", '%H:%M_%Y%m%d'), self.specified_tz)
         actual_time = parseATTime("midnight", self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_offset_with_tz(self):
-        expected_time = self.specified_tz.localize(datetime.strptime("1:00_20150308", '%H:%M_%Y%m%d'))
+        expected_time = make_aware(datetime.strptime("1:00_20150308", '%H:%M_%Y%m%d'), self.specified_tz)
         actual_time = parseATTime("midnight+1h", self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_relative_day_with_tz(self):
-        expected_time = self.specified_tz.localize(datetime.strptime("0:00_20150309", '%H:%M_%Y%m%d'))
+        expected_time = make_aware(datetime.strptime("0:00_20150309", '%H:%M_%Y%m%d'), self.specified_tz)
         actual_time = parseATTime("midnight_tomorrow", self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_relative_day_and_offset_with_tz(self):
-        expected_time = self.specified_tz.localize(datetime.strptime("3:00_20150309", '%H:%M_%Y%m%d'))
+        expected_time = make_aware(datetime.strptime("3:00_20150309", '%H:%M_%Y%m%d'), self.specified_tz)
         actual_time = parseATTime("midnight_tomorrow+3h", self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_should_return_current_time(self):
-        expected_time = self.default_tz.localize(datetime.strptime("12:00_20150308", '%H:%M_%Y%m%d'))
+        expected_time = make_aware(datetime.strptime("12:00_20150308", '%H:%M_%Y%m%d'), self.default_tz)
         actual_time = parseATTime("now")
         self.assertEqual(actual_time, expected_time)
 
     def test_now_should_respect_tz(self):
-        expected_time = self.specified_tz.localize(datetime.strptime("12:00_20150308", '%H:%M_%Y%m%d'))
+        expected_time = make_aware(datetime.strptime("12:00_20150308", '%H:%M_%Y%m%d'), self.specified_tz)
         actual_time = parseATTime("now", self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_relative_time_in_alternate_zone(self):
-        expected_time = self.specified_tz.localize(datetime.strptime("11:00_20150308", '%H:%M_%Y%m%d'))
+        expected_time = make_aware(datetime.strptime("11:00_20150308", '%H:%M_%Y%m%d'), self.specified_tz)
         actual_time = parseATTime("-1h", self.specified_tz)
         self.assertEqual(actual_time.hour, expected_time.hour)
 
     def test_should_handle_dst_boundary(self):
-        expected_time = self.specified_tz.localize(datetime.strptime("04:00_20150308", '%H:%M_%Y%m%d'))
+        expected_time = make_aware(datetime.strptime("04:00_20150308", '%H:%M_%Y%m%d'), self.specified_tz)
         actual_time = parseATTime("midnight+3h", self.specified_tz)
         self.assertEqual(actual_time, expected_time)
 
     def test_parse_naive_datetime(self):
         time_ref = parseATTime(datetime(self.MOCK_DATE.year, self.MOCK_DATE.month, self.MOCK_DATE.day, 8, 50), self.specified_tz)
-        expected = self.specified_tz.localize(datetime(self.MOCK_DATE.year, self.MOCK_DATE.month, self.MOCK_DATE.day, 8, 50))
+        expected = make_aware(datetime(self.MOCK_DATE.year, self.MOCK_DATE.month, self.MOCK_DATE.day, 8, 50), self.specified_tz)
         self.assertEqual(time_ref, expected)
 
     def test_parse_zone_aware_datetime(self):
-        time_ref = parseATTime(self.specified_tz.localize(datetime(self.MOCK_DATE.year, self.MOCK_DATE.month, self.MOCK_DATE.day, 8, 50)), self.specified_tz)
-        expected = self.specified_tz.localize(datetime(self.MOCK_DATE.year, self.MOCK_DATE.month, self.MOCK_DATE.day, 8, 50))
+        aware_dt = make_aware(datetime(self.MOCK_DATE.year, self.MOCK_DATE.month, self.MOCK_DATE.day, 8, 50), self.specified_tz)
+        time_ref = parseATTime(aware_dt, self.specified_tz)
+        expected = make_aware(datetime(self.MOCK_DATE.year, self.MOCK_DATE.month, self.MOCK_DATE.day, 8, 50), self.specified_tz)
         self.assertEqual(time_ref, expected)