def testSprintWithTimezoneDifference(self):
"""Tests the sprint creation and manipulation with Timezone
differences"""
# Create a Sprint from Berlin with Daylight risk in Summer
berlin_tz = get_timezone('GMT +2:00') # 'Europe/Berlin'
start_in_berlin = normalize_date(now(tz=berlin_tz))
cmd_create = SprintController.CreateSprintCommand(self.env,
name='TimezoneSprint',
milestone='MyRelease',
team=self.team.name,
start=start_in_berlin,
duration=15)
sprint = self.controller.process_command(cmd_create)
# now reload the sprint and check if the date is still valid
# and has been correctly saved... but we will read from San
# Francisco
sf_tz = get_timezone('GMT -7:00') # 'US/Pacific'
# obvious, but you never know what pytz timezone does with the
# daylight saving.
self.assert_equals(start_in_berlin,
start_in_berlin.astimezone(sf_tz))
# check that the sprint.start is in UTC timezone
self.assert_equals(timedelta(0), sprint.start.utcoffset())
self.assert_equals(start_in_berlin,
sprint.start.astimezone(berlin_tz))
# now we read it as UTC and we create a SF timezone datetime
start_in_sf = sprint.start.astimezone(sf_tz)
# Python should compare the UTC value of the datetimes
self.assert_equals(start_in_berlin, start_in_sf)
def testSprintWithTimezoneDifference(self):
"""Tests the sprint creation and manipulation with Timezone
differences"""
# Create a Sprint from Berlin with Daylight risk in Summer
berlin_tz = get_timezone('GMT +2:00') # 'Europe/Berlin'
start_in_berlin = normalize_date(now(tz=berlin_tz))
cmd_create = SprintController.CreateSprintCommand(
self.env,
name='TimezoneSprint',
milestone='MyRelease',
team=self.team.name,
start=start_in_berlin,
duration=15)
sprint = self.controller.process_command(cmd_create)
# now reload the sprint and check if the date is still valid
# and has been correctly saved... but we will read from San
# Francisco
sf_tz = get_timezone('GMT -7:00') # 'US/Pacific'
# obvious, but you never know what pytz timezone does with the
# daylight saving.
self.assert_equals(start_in_berlin, start_in_berlin.astimezone(sf_tz))
# check that the sprint.start is in UTC timezone
self.assert_equals(timedelta(0), sprint.start.utcoffset())
self.assert_equals(start_in_berlin, sprint.start.astimezone(berlin_tz))
# now we read it as UTC and we create a SF timezone datetime
start_in_sf = sprint.start.astimezone(sf_tz)
# Python should compare the UTC value of the datetimes
self.assert_equals(start_in_berlin, start_in_sf)
def testUTCDayTimeConversions(self):
"""Tests the UTC Datetime conversion, using timezone and utcoffsets"""
bangkok_tz = get_timezone('GMT +7:00')
now_in_bangkok = to_datetime(datetime(2009, 7, 11, 2, 30, tzinfo=bangkok_tz))
midnight_in_bangkok = dt.midnight(now_in_bangkok)
midnight_in_bangkok_as_utc = dt.midnight_with_utc_shift(now_in_bangkok)
self.assert_equals(midnight_in_bangkok, midnight_in_bangkok_as_utc)
def test_parse_date_dst(self):
tz = datefmt.get_timezone('Europe/Zurich')
t_utc = datetime.datetime(2009, 8, 1, 10, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-08-01T12:00:00', tz))
self.assertEqual(t_utc,
datefmt.parse_date('2009-08-01 12:00:00', tz))
def test_days_without_capacity_respect_given_timestamp(self):
team = self._create_team_with_weekends_off()
end = now(utc)
start = end - timedelta(days=7)
bangkok_tz = get_timezone('GMT +7:00')
days_without_capacity = team.capacity(bangkok_tz).days_without_capacity_in_interval(start, end)
self.assert_equals(bangkok_tz, days_without_capacity[0].tzinfo)
def test_ticks_are_at_midnight_in_viewers_timezone(self):
viewer_timezone = get_timezone("GMT -4:00")
ticks = self._generate_ticks_in_interval(self.yesterday, self.now, viewer_timezone)
for tick in ticks:
self.assert_equals(0, tick.hour) # should all be on midnight
self.assert_equals(0, tick.minute)
self.assert_equals(viewer_timezone, tick.tzinfo)
def _create_request(self):
languages = filter(None, [self.config.get('trac', 'default_language')])
if languages:
locale = _parse_locale(languages[0])
else:
locale = None
tzname = self.config.get('trac', 'default_timezone')
tz = get_timezone(tzname) or localtz
environ = {'REQUEST_METHOD': 'POST', 'REMOTE_ADDR': '127.0.0.1',
'SERVER_NAME': 'localhost', 'SERVER_PORT': '80',
'wsgi.url_scheme': 'http',
'trac.base_url': self.env.abs_href()}
if languages:
environ['HTTP_ACCEPT_LANGUAGE'] = ','.join(languages)
req = Request(environ, lambda *args, **kwargs: None)
req.arg_list = ()
req.args = {}
req.authname = 'anonymous'
req.session = FakeSession({'dateinfo': 'absolute'})
req.perm = MockPerm()
req.href = req.abs_href
req.locale = locale
req.lc_time = locale
req.tz = tz
req.chrome = {'notices': [], 'warnings': []}
return req
def test_trend_line_until_end_of_sprint(self):
self.assert_true(self.sprint.is_currently_running)
berlin = get_timezone('GMT +2:00')
trend_line = self.get_times_from_chart('trend_data', tz=berlin)
self.assert_not_equals(0, len(trend_line))
self.assert_time_equals(self.sprint.end, trend_line[-1])
def test_trend_line_until_end_of_sprint(self):
self.assert_true(self.sprint.is_currently_running)
berlin = get_timezone('GMT +2:00')
trend_line = self.get_times_from_chart('trend_data', tz=berlin)
self.assert_not_equals(0, len(trend_line))
self.assert_time_equals(self.sprint.end, trend_line[-1])
def test_parse_date_dst(self):
tz = datefmt.get_timezone('Europe/Zurich')
t_utc = datetime.datetime(2009, 8, 1, 10, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-08-01T12:00:00', tz))
self.assertEqual(t_utc,
datefmt.parse_date('2009-08-01 12:00:00', tz))
def test_only_one_point_for_today(self):
# this is the crazy burndown chart regression test
self.assert_true(self.sprint.is_currently_running)
bangkok = get_timezone('GMT +7:00')
times = self.get_times_from_chart(tz=bangkok)
self.assert_smaller_than(times[-2], times[-1])
self.assert_time_equals(now(), times[-1])
def test_only_one_point_for_today(self):
# this is the crazy burndown chart regression test
self.assert_true(self.sprint.is_currently_running)
bangkok = get_timezone('GMT +7:00')
times = self.get_times_from_chart(tz=bangkok)
self.assert_smaller_than(times[-2], times[-1])
self.assert_time_equals(now(), times[-1])
def test_ticks_are_at_midnight_in_viewers_timezone(self):
viewer_timezone = get_timezone("GMT -4:00")
ticks = self._generate_ticks_in_interval(self.yesterday, self.now,
viewer_timezone)
for tick in ticks:
self.assert_equals(0, tick.hour) # should all be on midnight
self.assert_equals(0, tick.minute)
self.assert_equals(viewer_timezone, tick.tzinfo)
def test_can_parse_subsecond_precision_datetimes(self):
self.assert_equals(
datetime(2010, 9, 23, 13, 12, 24, 5482),
datetime_str_to_datetime('2010-09-23 13:12:24.005482'))
berlin = get_timezone('GMT +2:00')
self.assert_equals(
datetime(2010, 9, 23, 13, 12, 24, 305482, tzinfo=berlin),
datetime_str_to_datetime('2010-09-23 13:12:24.305482+02:00'))
def timezone(self):
"timezone object as set in user preferences, or server timezone"
if not hasattr(self, '_cached_timezone'):
timezone_name = get_user_attribute_from_session(
self.env, 'tz', self.name)
self._cached_timezone = timezone_name and get_timezone(
timezone_name) or localtz
return self._cached_timezone
def test_can_parse_datetime_str_with_tz(self):
self.assert_equals(datetime(2009, 9, 10, 14, 55, 11, tzinfo=utc),
datetime_str_to_datetime('2009-09-10 14:55:11+00:00'))
berlin = get_timezone('GMT +2:00')
self.assert_equals(datetime(2009, 9, 10, 14, 55, 11, tzinfo=berlin),
datetime_str_to_datetime('2009-09-10 14:55:11+02:00'))
teheran = FixedOffset(3*60+30, 'GMT +3:30')
self.assert_equals(datetime(2009, 9, 10, 14, 55, 11, tzinfo=teheran),
datetime_str_to_datetime('2009-09-10 14:55:11+03:30'))
def test_can_access_timezone_in_session_table(self):
timezone_name = "GMT +7:00"
timezone_offset = timedelta(hours=7)
timezone = get_timezone(timezone_name)
self.assert_equals(timezone_offset, timezone.utcoffset(None))
set_user_attribute_in_session(self.env, 'tz', timezone_name, 'tm')
member = self.tmm.create(name='tm')
self.assert_equals(timezone_offset, member.timezone().utcoffset(None))
def test_can_deal_with_different_timezones_for_dates(self):
# Actually Bangkok has no summer/winter time so that's ideal to test
# even with trac's own timezones which don't know anything about dst.
bangkok_tz = get_timezone('GMT +7:00')
times = self.get_times_from_chart(tz=bangkok_tz)
start_in_bangkok = self.sprint.start.astimezone(bangkok_tz)
self.assert_equals(start_in_bangkok, times[0])
bankok_now = now().astimezone(bangkok_tz)
self.assert_time_equals(bankok_now, times[-1])
def test_can_deal_with_different_timezones_for_dates(self):
# Actually Bangkok has no summer/winter time so that's ideal to test
# even with trac's own timezones which don't know anything about dst.
bangkok_tz = get_timezone('GMT +7:00')
times = self.get_times_from_chart(tz=bangkok_tz)
start_in_bangkok = self.sprint.start.astimezone(bangkok_tz)
self.assert_equals(start_in_bangkok, times[0])
bankok_now = now().astimezone(bangkok_tz)
self.assert_time_equals(bankok_now, times[-1])
def test_today_is_relative_to_the_users_timezone(self):
self.assert_true(self.sprint.is_currently_running)
bangkok_tz = get_timezone('GMT +7:00')
times = self.get_chart_data('utc_today_data', tz=bangkok_tz, storage='data')[0]
self.assert_equals(2, len(times))
# Now we test that midnight in bangkok is normalized as UTC data with
# offset
now_in_bangkok = self.now.astimezone(bangkok_tz)
today_start_in_bangkok = midnight(now_in_bangkok)
self.assert_equals(today_start_in_bangkok, times[0])
self.assert_equals(today_start_in_bangkok + timedelta(days=1), times[1])
def runTest(self):
self._tester.login_as(Usernames.admin)
milestone_name = \
self._tester.create_milestone(self.testname() + 'Milestone')
admin_tz = get_timezone('GMT +2:00')
self._tester.set_timezone_for_current_user('GMT +2:00')
start = datetime(2009, 07, 06, 8, 00, tzinfo=utc)
sprint_name = self.testname() + 'Sprint'
self._tester.create_sprint_via_admin(sprint_name,
start=start,
duration=5,
milestone=milestone_name,
tz=admin_tz)
self._tester.login_as(Usernames.team_member)
bangkok_tz = get_timezone('GMT +7:00')
self._tester.set_timezone_for_current_user(bangkok_tz.zone)
self.go_to_sprint_detail_page()
expected_datestring = format_datetime(start, tzinfo=bangkok_tz)
tc.find('started the %s' % expected_datestring, flags='i')
def test_can_parse_datetime_str_with_tz(self):
self.assert_equals(
datetime(2009, 9, 10, 14, 55, 11, tzinfo=utc),
datetime_str_to_datetime('2009-09-10 14:55:11+00:00'))
berlin = get_timezone('GMT +2:00')
self.assert_equals(
datetime(2009, 9, 10, 14, 55, 11, tzinfo=berlin),
datetime_str_to_datetime('2009-09-10 14:55:11+02:00'))
teheran = FixedOffset(3 * 60 + 30, 'GMT +3:30')
self.assert_equals(
datetime(2009, 9, 10, 14, 55, 11, tzinfo=teheran),
datetime_str_to_datetime('2009-09-10 14:55:11+03:30'))
def test_capacity_can_take_timezone_parameter(self):
team, member = self.team_with_one_member()
self._set_default_capacity_for_member(0, member)
set_user_attribute_in_session(self.env, 'tz', 'GMT', member.name)
self.set_hours_for_day_on_team_member(9, today(member.timezone()), member)
viewer_timezone = get_timezone('GMT -12:00')
capacitator = team.capacity(viewer_timezone)
# Need to take the member timezone for start and end, to make sure that we really cut off all
# workhours he has on the previous day - even though they would be on the current day when
# viewed from the viewers timezone.
hourly_capacities = capacitator.hourly_capacities_in_interval(today(tz=member.timezone()), tomorrow(tz=member.timezone()))
self.assert_length(7, hourly_capacities)
def test_today_is_relative_to_the_users_timezone(self):
self.assert_true(self.sprint.is_currently_running)
bangkok_tz = get_timezone('GMT +7:00')
times = self.get_chart_data('utc_today_data',
tz=bangkok_tz,
storage='data')[0]
self.assert_equals(2, len(times))
# Now we test that midnight in bangkok is normalized as UTC data with
# offset
now_in_bangkok = self.now.astimezone(bangkok_tz)
today_start_in_bangkok = midnight(now_in_bangkok)
self.assert_equals(today_start_in_bangkok, times[0])
self.assert_equals(today_start_in_bangkok + timedelta(days=1),
times[1])
def test_weekends_are_relative_to_the_users_timezone(self):
self.sprint.start = datetime(2009, 6, 23, 7, 0, tzinfo=utc)
self.sprint.end = datetime(2009, 7, 6, 19, 0, tzinfo=utc)
self.sprint.save()
bangkok_tz = get_timezone('GMT +7:00')
times = self.get_times_from_chart('weekend_data', tz=bangkok_tz)
self.assert_equals(4, len(times))
first_weekend = [datetime(2009, 6, 27, 0, 0, tzinfo=bangkok_tz),
datetime(2009, 6, 28, 0, 0, tzinfo=bangkok_tz),]
self.assert_equals(first_weekend, times[0:2])
second_weekend = [datetime(2009, 7, 4, 0, 0, tzinfo=bangkok_tz),
datetime(2009, 7, 5, 0, 0, tzinfo=bangkok_tz),]
self.assert_equals(second_weekend, times[2:])
def test_parse_date_usec(self):
tz = datefmt.get_timezone('GMT +1:00')
t_utc = datetime.datetime(2009, 12, 1, 11, 0, 0, 98765, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T12:00:00.098765', tz))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T12:00:00,098765', tz))
self.assertEqual(datetime.datetime(2009, 12, 1, 11, 0, 0, 98700,
datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.0987', tz))
self.assertEqual(datetime.datetime(2009, 12, 1, 11, 0, 0, 90000,
datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.09', tz))
self.assertEqual(datetime.datetime(2009, 12, 1, 11, 0, 0, 0,
datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.0', tz))
def test_parse_date_usec(self):
tz = datefmt.get_timezone('GMT +1:00')
t_utc = datetime.datetime(2009, 12, 1, 11, 0, 0, 98765, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T12:00:00.098765', tz))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T12:00:00,098765', tz))
self.assertEqual(
datetime.datetime(2009, 12, 1, 11, 0, 0, 98700, datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.0987', tz))
self.assertEqual(
datetime.datetime(2009, 12, 1, 11, 0, 0, 90000, datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.09', tz))
self.assertEqual(
datetime.datetime(2009, 12, 1, 11, 0, 0, 0, datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.0', tz))
def test_parse_date_across_dst_boundary(self):
tz = datefmt.get_timezone("Europe/Zurich")
# DST start - 31 March, 02:00
format = "%Y-%m-%d %H:%M:%S %Z%z"
expected = "2002-03-31 03:30:00 CEST+0200"
# iso8601
t = datefmt.parse_date("2002-03-31T02:30:00", tz)
self.assertEqual(expected, t.strftime(format))
# strptime
t = datetime.datetime(2002, 3, 31, 2, 30)
t = datefmt.parse_date(t.strftime("%x %X"), tz)
self.assertEqual(expected, t.strftime(format))
# i18n datetime
if Locale:
en_US = Locale.parse("en_US")
t = datefmt.parse_date("Mar 31, 2002 02:30", tz, en_US)
self.assertEqual(expected, t.strftime(format))
def test_parse_date_across_dst_boundary(self):
tz = datefmt.get_timezone('Europe/Zurich')
# DST start - 31 March, 02:00
format = '%Y-%m-%d %H:%M:%S %Z%z'
expected = '2002-03-31 03:30:00 CEST+0200'
# iso8601
t = datefmt.parse_date('2002-03-31T02:30:00', tz)
self.assertEqual(expected, t.strftime(format))
# strptime
t = datetime.datetime(2002, 3, 31, 2, 30)
t = datefmt.parse_date(t.strftime('%x %X'), tz)
self.assertEqual(expected, t.strftime(format))
# i18n datetime
if Locale:
en_US = Locale.parse('en_US')
t = datefmt.parse_date('Mar 31, 2002 02:30', tz, en_US)
self.assertEqual(expected, t.strftime(format))
def test_parse_date_across_dst_boundary(self):
tz = datefmt.get_timezone('Europe/Zurich')
# DST start - 31 March, 02:00
format = '%Y-%m-%d %H:%M:%S %Z%z'
expected = '2002-03-31 03:30:00 CEST+0200'
# iso8601
t = datefmt.parse_date('2002-03-31T02:30:00', tz)
self.assertEqual(expected, t.strftime(format))
# strptime
t = datetime.datetime(2002, 3, 31, 2, 30)
t = datefmt.parse_date(t.strftime('%x %X'), tz)
self.assertEqual(expected, t.strftime(format))
# i18n datetime
if Locale:
en_US = Locale.parse('en_US')
t = datefmt.parse_date('Mar 31, 2002 02:30', tz, en_US)
self.assertEqual(expected, t.strftime(format))
def render_preference_panel(self, req, panel):
if req.method == 'POST':
if Locale and \
req.args.get('language') != req.session.get('language'):
# reactivate translations with new language setting
# when changed
del req.locale # for re-negotiating locale
deactivate()
make_activable(lambda: req.locale, self.env.path)
_do_save(req, panel, self._form_fields)
default_timezone_id = self.config.get('trac', 'default_timezone')
default_timezone = get_timezone(default_timezone_id) or localtz
default_time_format = \
self.config.get('trac', 'default_dateinfo_format') or 'relative'
default_date_format = \
self.config.get('trac', 'default_date_format') or 'locale'
data = {
'timezones': all_timezones,
'timezone': get_timezone,
'default_timezone': default_timezone,
'default_time_format': default_time_format,
'default_date_format': default_date_format,
'localtz': localtz,
'has_babel': False,
}
if Locale:
locale_ids = get_available_locales()
locales = [Locale.parse(locale) for locale in locale_ids]
# use locale identifiers from get_available_locales() instead
# of str(locale) to prevent storing expanded locale identifier
# to session, e.g. zh_Hans_CN and zh_Hant_TW, since Babel 1.0.
# see #11258.
languages = sorted((id_, locale.display_name)
for id_, locale in zip(locale_ids, locales))
default_language_id = self.config.get('trac', 'default_language')
default_language = get_locale_name(default_language_id) or \
_("Browser's language")
data['locales'] = locales
data['languages'] = languages
data['default_language'] = default_language
data['has_babel'] = True
return 'prefs_localization.html', data
def test_weekends_are_relative_to_the_users_timezone(self):
self.sprint.start = datetime(2009, 6, 23, 7, 0, tzinfo=utc)
self.sprint.end = datetime(2009, 7, 6, 19, 0, tzinfo=utc)
self.sprint.save()
bangkok_tz = get_timezone('GMT +7:00')
times = self.get_times_from_chart('weekend_data', tz=bangkok_tz)
self.assert_equals(4, len(times))
first_weekend = [
datetime(2009, 6, 27, 0, 0, tzinfo=bangkok_tz),
datetime(2009, 6, 28, 0, 0, tzinfo=bangkok_tz),
]
self.assert_equals(first_weekend, times[0:2])
second_weekend = [
datetime(2009, 7, 4, 0, 0, tzinfo=bangkok_tz),
datetime(2009, 7, 5, 0, 0, tzinfo=bangkok_tz),
]
self.assert_equals(second_weekend, times[2:])
def test_unicode_input(self):
tz = datefmt.get_timezone(u'Etc/GMT-4')
self.assertEqual(datetime.timedelta(hours=4), tz.utcoffset(None))
self.assertEqual('GMT +4:00', tz.zone)
def test_posix_conversion(self):
tz = datefmt.get_timezone('Etc/GMT-4')
self.assertEqual(datetime.timedelta(hours=4), tz.utcoffset(None))
self.assertEqual('GMT +4:00', tz.zone)
def test_pytz_conversion(self):
tz = datefmt.get_timezone('GMT +3:00')
self.assertEqual(datetime.timedelta(hours=3), tz.utcoffset(None))
def test_to_datetime_pytz_normalize(self):
tz = datefmt.get_timezone('Europe/Zurich')
date = datefmt.to_datetime(datetime.date(2002, 3, 31), tz)
format = '%Y-%m-%d %H:%M:%S %Z%z'
expected = '2002-03-31 00:00:00 CET+0100'
self.assertEqual(expected, date.strftime(format))
def test_midnight_keeps_timezone_if_already_specified(self):
los_angeles = get_timezone('GMT -8:00')
self.assert_equals(los_angeles,
midnight(datetime.now(tz=los_angeles)).tzinfo)
def format_time_field(self, value, format):
tzinfo = get_timezone(self.config.get('trac', 'default_timezone'))
return format_date_or_datetime(format, value, tzinfo=tzinfo) \
if value else ''
def test_parse_date_dst(self):
tz = datefmt.get_timezone("Europe/Zurich")
t = datefmt.parse_date("2009-08-01T12:00:00", tz)
t_utc = datetime.datetime(2009, 8, 1, 10, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc, t)
def test_unicode_input(self):
tz = datefmt.get_timezone(u'Etc/GMT-4')
self.assertEqual(datetime.timedelta(hours=4),
tz.utcoffset(None))
self.assertEqual('GMT +4:00', tz.zone)
def test_pytz_conversion(self):
tz = datefmt.get_timezone('GMT +3:00')
self.assertEqual(datetime.timedelta(hours=3),
tz.utcoffset(None))
def _get_tz(self, req):
tzname = self.config.get('trac', 'default_timezone')
return get_timezone(tzname) or localtz
def test_can_parse_subsecond_precision_datetimes(self):
self.assert_equals(datetime(2010, 9, 23, 13, 12, 24, 5482),
datetime_str_to_datetime('2010-09-23 13:12:24.005482'))
berlin = get_timezone('GMT +2:00')
self.assert_equals(datetime(2010, 9, 23, 13, 12, 24, 305482, tzinfo=berlin),
datetime_str_to_datetime('2010-09-23 13:12:24.305482+02:00'))
def test_parse_date(self):
tz = datefmt.get_timezone('Europe/Zurich')
t = datefmt.parse_date('2009-12-01T12:00:00', tz)
t_utc = datetime.datetime(2009, 12, 1, 11, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc, t)
def _format_time_field(self, value, format):
tzinfo = get_timezone(self.config.get('trac', 'default_timezone'))
return format_date_or_datetime(format, value, tzinfo=tzinfo) \
if value else ''
def test_midnight_keeps_timezone_if_already_specified(self):
los_angeles = get_timezone('GMT -8:00')
self.assert_equals(los_angeles, midnight(datetime.now(tz=los_angeles)).tzinfo)
def test_posix_conversion(self):
tz = datefmt.get_timezone('Etc/GMT-4')
self.assertEqual(datetime.timedelta(hours=4),
tz.utcoffset(None))
self.assertEqual('GMT +4:00', tz.zone)
def test_to_datetime_pytz_normalize(self):
tz = datefmt.get_timezone('Europe/Zurich')
date = datefmt.to_datetime(datetime.date(2002, 3, 31), tz)
format = '%Y-%m-%d %H:%M:%S %Z%z'
expected = '2002-03-31 00:00:00 CET+0100'
self.assertEqual(expected, date.strftime(format))
def test_parse_date(self):
tz = datefmt.get_timezone('Europe/Zurich')
t = datefmt.parse_date('2009-12-01T12:00:00', tz)
t_utc = datetime.datetime(2009, 12, 1, 11, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc, t)
def timezone(self):
"timezone object as set in user preferences, or server timezone"
if not hasattr(self, '_cached_timezone'):
timezone_name = get_user_attribute_from_session(self.env, 'tz', self.name)
self._cached_timezone = timezone_name and get_timezone(timezone_name) or localtz
return self._cached_timezone
