1
=== modified file 'autopilot/introspection/types.py'
2
--- autopilot/introspection/types.py	2014-05-29 19:44:44 +0000
3
+++ autopilot/introspection/types.py	2014-10-22 20:43:57 +0000
4
@@ -37,7 +37,9 @@
5
37
37
6
38
"""
38
"""
7
39
39
9
40
from datetime import datetime, time
40
from datetime import datetime, time, timedelta
10
41
from dateutil.tz import gettz, tzutc
11
42
12
41
import dbus
43
import dbus
13
42
import logging
44
import logging
14
43
from testtools.matchers import Equals
45
from testtools.matchers import Equals
15
@@ -547,6 +549,15 @@
16
547
    """The DateTime class represents a date and time in the UTC timezone.
549
    """The DateTime class represents a date and time in the UTC timezone.
17
548
550
18
549
    DateTime is constructed by passing a unix timestamp in to the constructor.
551
    DateTime is constructed by passing a unix timestamp in to the constructor.
19
552
    The incoming timestamp is assumed to be in UTC.
20
553
21
554
    .. note:: This class expects the passed in timestamp to be in UTC but will
22
555
      display the resulting date and time in local time (using the local
23
556
      timezone).
24
557
25
558
      This is done to mimic the behaviour of most applications which will
26
559
      display date and time in local time by default
27
560
28
550
    Timestamps are expressed as the number of seconds since 1970-01-01T00:00:00
561
    Timestamps are expressed as the number of seconds since 1970-01-01T00:00:00
29
551
    in the UTC timezone::
562
    in the UTC timezone::
30
552
563
31
@@ -588,10 +599,48 @@
32
588
    Finally, you can also compare a DateTime instance with a python datetime
599
    Finally, you can also compare a DateTime instance with a python datetime
33
589
    instance::
600
    instance::
34
590
601
39
591
        >>> my_datetime = datetime.datetime.fromutctimestamp(1377209927)
602
        >>> my_datetime = datetime.datetime.utcfromtimestamp(1377209927)
40
592
        True
603
        True
41
593
604
42
594
    DateTime instances can be converted to datetime instances:
605
43
606
    .. note:: Autopilot supports dates beyond 2038 on 32-bit platforms. To
44
607
     achieve this the underlying mechanisms require to work with timezone aware
45
608
     datetime objects.
46
609
47
610
      This means that the following won't always be true (due to the naive
48
611
      timestamp not having the correct daylight-savings time details)::
49
612
50
613
        >>> # This time stamp is within DST in the 'Europe/London' timezone
51
614
        >>> dst_ts = 1405382400
52
615
        >>> os.environ['TZ'] ='Europe/London'
53
616
        >>> time.tzset()
54
617
        >>> datetime.fromtimestamp(dst_ts).hour == DateTime(dst_ts).hour
55
618
        False
56
619
57
620
      But this will work::
58
621
59
622
        >>> from dateutil.tz import gettz
60
623
        >>> datetime.fromtimestamp(
61
624
                dst_ts, gettz()).hour == DateTime(dst_ts).hour
62
625
        True
63
626
64
627
      And this will always work to::
65
628
66
629
        >>> dt1 =  DateTime(nz_dst_timestamp)
67
630
        >>> dt2 = datetime(
68
631
                dt1.year, dt1.month, dt1.day, dt1.hour, dt1.minute, dt1.second
69
632
            )
70
633
        >>> dt1 == dt2
71
634
        True
72
635
73
636
    .. note:: DateTime.timestamp() will not always equal the passed in
74
637
      timestamp.
75
638
      To paraphrase a message from [http://bugs.python.org/msg229393]
76
639
      "datetime.timestamp is supposed to be inverse of
77
640
      datetime.fromtimestamp(), but since the later is not monotonic, no such
78
641
      inverse exists in the strict mathematical sense."
79
642
80
643
    DateTime instances can be converted to datetime instances::
81
595
644
82
596
        >>> isinstance(my_dt.datetime, datetime.datetime)
645
        >>> isinstance(my_dt.datetime, datetime.datetime)
83
597
        True
646
        True
84
@@ -599,7 +648,41 @@
85
599
    """
648
    """
86
600
    def __init__(self, *args, **kwargs):
649
    def __init__(self, *args, **kwargs):
87
601
        super(DateTime, self).__init__(*args, **kwargs)
650
        super(DateTime, self).__init__(*args, **kwargs)
89
602
        self._cached_dt = datetime.fromtimestamp(self[0])
651
        # Using timedelta in this manner is a workaround so that we can support
90
652
        # timestamps larger than the 32bit time_t limit on 32bit hardware.
91
653
        # We then apply another workaround where timedelta doesn't apply
92
654
        # daylight savings, so we need to work out the offsets for the
93
655
        # localtime manually and apply them to give us the correct local time.
94
656
        #
95
657
        # Note. self[0] is a UTC timestamp
96
658
        EPOCH = datetime(1970, 1, 1, tzinfo=tzutc())
97
659
        utc_dt = EPOCH + timedelta(seconds=self[0])
98
660
99
661
        local_tzinfo = gettz()
100
662
101
663
        # Get the localtimes timezone offset (known as standard offset) by
102
664
        # subtracting its dst offset (if any) from its utc offset.
103
665
        # We apply this to the utc datetime object to get datetime object in
104
666
        # localtime.
105
667
        # (We will check (once we have a local datetime) if the time is in dst
106
668
        # and make that adjustment then.)
107
669
        utc_offset = local_tzinfo.utcoffset(utc_dt)
108
670
        dst_offset = local_tzinfo.dst(utc_dt)
109
671
        standard_offset = utc_offset - dst_offset
110
672
111
673
        # Create a local timezone aware datetime object from the utc_dt
112
674
        # (i.e. attaching a timezone to it) and apply the standard offset to
113
675
        # give us the local time.
114
676
        local_dt = utc_dt.replace(tzinfo=local_tzinfo) + standard_offset
115
677
116
678
        # If the new local time is firmly in std time then the standard offset
117
679
        # will be 0 (i.e. timedelta(0)).
118
680
        # If the delta isn't 0 then we need to use the timezone information to
119
681
        # apply the dst delta to the local time.
120
682
        if standard_offset != timedelta(0):
121
683
            local_dt = local_dt + local_tzinfo.dst(local_dt)
122
684
123
685
        self._cached_dt = local_dt
124
603
686
125
604
    @property
687
    @property
126
605
    def year(self):
688
    def year(self):
127
@@ -627,14 +710,21 @@
128
627
710
129
628
    @property
711
    @property
130
629
    def timestamp(self):
712
    def timestamp(self):
132
630
        return self[0]
713
        return self._cached_dt.timestamp()
133
631
714
134
632
    @property
715
    @property
135
633
    def datetime(self):
716
    def datetime(self):
136
634
        return self._cached_dt
717
        return self._cached_dt
137
635
718
138
636
    def __eq__(self, other):
719
    def __eq__(self, other):
139
720
        # A little 'magic' here, if the datetime object to test against is
140
721
        # naive, use the tzinfo from the cached datetime (just for the
141
722
        # comparison)
142
637
        if isinstance(other, datetime):
723
        if isinstance(other, datetime):
143
724
            if other.tzinfo is None:
144
725
                return other.replace(
145
726
                    tzinfo=self._cached_dt.tzinfo
146
727
                ) == self._cached_dt
147
638
            return other == self._cached_dt
728
            return other == self._cached_dt
148
639
        return super(DateTime, self).__eq__(other)
729
        return super(DateTime, self).__eq__(other)
149
640
730
150
641
731
151
=== modified file 'autopilot/tests/functional/fixtures.py'
152
--- autopilot/tests/functional/fixtures.py	2014-05-23 13:44:36 +0000
153
+++ autopilot/tests/functional/fixtures.py	2014-10-22 20:43:57 +0000
154
@@ -25,8 +25,9 @@
155
25
from shutil import rmtree
25
from shutil import rmtree
156
26
import tempfile
26
import tempfile
157
27
from textwrap import dedent
27
from textwrap import dedent
158
28
import time
159
28
29
161
29
from fixtures import Fixture
30
from fixtures import EnvironmentVariable, Fixture
162
30
31
163
31
32
164
32
logger = logging.getLogger(__name__)
33
logger = logging.getLogger(__name__)
165
@@ -166,3 +167,16 @@
166
166
        with open(tmp_file_path, 'w') as desktop_file:
167
        with open(tmp_file_path, 'w') as desktop_file:
167
167
            desktop_file.write(file_contents)
168
            desktop_file.write(file_contents)
168
168
        return tmp_file_path
169
        return tmp_file_path
169
170
170
171
171
172
class SetTimezone(Fixture):
172
173
    def __init__(self, timezone):
173
174
        self._timezone = timezone
174
175
175
176
    def setUp(self):
176
177
        super().setUp()
177
178
        # These steps need to happen in the right order otherwise they won't
178
179
        # get cleaned up properly and we'll be left in an incorrect timezone.
179
180
        self.addCleanup(time.tzset)
180
181
        self.useFixture(EnvironmentVariable('TZ', self._timezone))
181
182
        time.tzset()
182
169
183
183
=== modified file 'autopilot/tests/functional/test_types.py'
184
--- autopilot/tests/functional/test_types.py	2014-05-22 06:41:16 +0000
185
+++ autopilot/tests/functional/test_types.py	2014-10-22 20:43:57 +0000
186
@@ -1,29 +1,99 @@
187
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
188
2
#
189
3
# Autopilot Functional Test Tool
190
4
# Copyright (C) 2013-2014 Canonical
191
5
#
192
6
# This program is free software: you can redistribute it and/or modify
193
7
# it under the terms of the GNU General Public License as published by
194
8
# the Free Software Foundation, either version 3 of the License, or
195
9
# (at your option) any later version.
196
10
#
197
11
# This program is distributed in the hope that it will be useful,
198
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
199
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
200
14
# GNU General Public License for more details.
201
15
#
202
16
# You should have received a copy of the GNU General Public License
203
17
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
204
18
#
205
1
19
206
2
from datetime import datetime
20
from datetime import datetime
207
3
21
208
4
from autopilot.testcase import AutopilotTestCase
22
from autopilot.testcase import AutopilotTestCase
209
5
from autopilot.tests.functional import QmlScriptRunnerMixin
23
from autopilot.tests.functional import QmlScriptRunnerMixin
210
24
from autopilot.tests.functional.fixtures import SetTimezone
211
6
25
212
7
from textwrap import dedent
26
from textwrap import dedent
213
8
27
214
9
28
226
10
class TypeTests(AutopilotTestCase, QmlScriptRunnerMixin):
29
class DateTimeTests(AutopilotTestCase, QmlScriptRunnerMixin):
227
11
30
    scenarios = [
228
12
    def test_date(self):
31
        ('UTC', dict(
229
13
        proxy = self.start_qml_script(
32
            TZ='UTC',
230
14
            dedent(
33
            expected_string='2014-09-29T12:00:00',
231
15
                """\
34
        )),
232
16
                import QtQuick 2.0
35
        ('NZ', dict(
233
17
36
            TZ='Pacific/Auckland',
234
18
                Item {
37
            expected_string='2014-09-30T01:00:00',
235
19
                    objectName: "TestMePlease"
38
        )),
236
20
                    property date foo: "2014-01-01"
39
        ('US Central', dict(
237
40
            TZ='US/Central',
238
41
            expected_string='2014-09-29T07:00:00',
239
42
        )),
240
43
        ('US Eastern', dict(
241
44
            TZ='US/Eastern',
242
45
            expected_string='2014-09-29T08:00:00',
243
46
        )),
244
47
        ('MSK', dict(
245
48
            TZ='Europe/Moscow',
246
49
            expected_string='2014-09-29T16:00:00',
247
50
        )),
248
51
    ]
249
52
250
53
    def get_test_qml_string(self, date_string):
251
54
        return dedent("""
252
55
            import QtQuick 2.0
253
56
            import QtQml 2.2
254
57
            Rectangle {
255
58
                property date testingTime: new Date(%s);
256
59
                Text {
257
60
                    text: testingTime;
258
21
                }
61
                }
263
22
                """
62
            }""" % date_string)
264
23
            )
63
265
24
        )
64
    def test_qml_applies_timezone_to_timestamp(self):
266
25
        item = proxy.select_single('*', objectName="TestMePlease")
65
        """Test that when given a timestamp the datetime displayed has the
267
66
        timezone applied to it.
268
67
269
68
        QML will apply a timezone calculation to a timestamp (but not a
270
69
        timestring).
271
70
272
71
        """
273
72
        self.useFixture(SetTimezone(self.TZ))
274
73
275
74
        qml_script = self.get_test_qml_string('1411992000000')
276
75
277
76
        proxy = self.start_qml_script(qml_script)
278
26
        self.assertEqual(
77
        self.assertEqual(
281
27
            item.foo,
78
            proxy.select_single('QQuickText').text,
282
28
            datetime(2014, 1, 1, 0, 0, 0)
79
            self.expected_string
283
29
        )
80
        )
284
81
285
82
    def test_timezone_not_applied_to_timestring(self):
286
83
        """Test that, in all timezones, the literal representation we get in
287
84
        the proxy object matches the one in the Qml script.
288
85
289
86
        """
290
87
        self.useFixture(SetTimezone(self.TZ))
291
88
292
89
        qml_script = self.get_test_qml_string("'2014-01-15 12:34:52'")
293
90
        proxy = self.start_qml_script(qml_script)
294
91
        date_object = proxy.select_single("QQuickRectangle").testingTime
295
92
296
93
        self.assertEqual(date_object.year, 2014)
297
94
        self.assertEqual(date_object.month, 1)
298
95
        self.assertEqual(date_object.day, 15)
299
96
        self.assertEqual(date_object.hour, 12)
300
97
        self.assertEqual(date_object.minute, 34)
301
98
        self.assertEqual(date_object.second, 52)
302
99
        self.assertEqual(datetime(2014, 1, 15, 12, 34, 52), date_object)
303
30
100
304
=== modified file 'autopilot/tests/unit/test_test_fixtures.py'
305
--- autopilot/tests/unit/test_test_fixtures.py	2014-05-20 08:53:21 +0000
306
+++ autopilot/tests/unit/test_test_fixtures.py	2014-10-22 20:43:57 +0000
307
@@ -19,6 +19,7 @@
308
19
19
309
20
from autopilot.tests.functional.fixtures import (
20
from autopilot.tests.functional.fixtures import (
310
21
    ExecutableScript,
21
    ExecutableScript,
311
22
    SetTimezone,
312
22
    TempDesktopFile,
23
    TempDesktopFile,
313
23
)
24
)
314
24
25
315
@@ -213,3 +214,22 @@
316
213
    def test_creates_file_with_execute_bit_set(self):
214
    def test_creates_file_with_execute_bit_set(self):
317
214
        fixture = self.useFixture(ExecutableScript(script=""))
215
        fixture = self.useFixture(ExecutableScript(script=""))
318
215
        self.assertTrue(os.stat(fixture.path).st_mode & stat.S_IXUSR)
216
        self.assertTrue(os.stat(fixture.path).st_mode & stat.S_IXUSR)
319
217
320
218
321
219
class SetTimezoneTests(TestCase):
322
220
323
221
    def test_sets_environment_variable_to_timezone(self):
324
222
        token = self.getUniqueString()
325
223
326
224
        self.useFixture(SetTimezone(token))
327
225
328
226
        self.assertEqual(os.environ.get('TZ'), token)
329
227
330
228
    def test_resets_timezone_back_to_original(self):
331
229
        original_tz = os.environ.get('TZ', None)
332
230
        token = self.getUniqueString()
333
231
334
232
        fixture = self.useFixture(SetTimezone(token))
335
233
        fixture.cleanUp()
336
234
337
235
        self.assertEqual(os.environ.get('TZ', None), original_tz)
338
216
236
339
=== modified file 'autopilot/tests/unit/test_types.py'
340
--- autopilot/tests/unit/test_types.py	2014-07-22 02:39:26 +0000
341
+++ autopilot/tests/unit/test_types.py	2014-10-22 20:43:57 +0000
342
@@ -18,13 +18,14 @@
343
18
#
18
#
344
19
19
345
20
from datetime import datetime, time
20
from datetime import datetime, time
347
21
from testscenarios import TestWithScenarios
21
from testscenarios import TestWithScenarios, multiply_scenarios
348
22
from testtools import TestCase
22
from testtools import TestCase
349
23
from testtools.matchers import Equals, IsInstance, NotEquals, raises
23
from testtools.matchers import Equals, IsInstance, NotEquals, raises
350
24
24
351
25
import dbus
25
import dbus
352
26
from unittest.mock import patch, Mock
26
from unittest.mock import patch, Mock
353
27
27
354
28
from autopilot.tests.functional.fixtures import SetTimezone
355
28
from autopilot.introspection.types import (
29
from autopilot.introspection.types import (
356
29
    Color,
30
    Color,
357
30
    create_value_instance,
31
    create_value_instance,
358
@@ -51,6 +52,8 @@
359
51
from autopilot.introspection.dbus import DBusIntrospectionObject
52
from autopilot.introspection.dbus import DBusIntrospectionObject
360
52
from autopilot.utilities import compatible_repr
53
from autopilot.utilities import compatible_repr
361
53
54
362
55
from dateutil import tz
363
56
364
54
57
365
55
class PlainTypeTests(TestWithScenarios, TestCase):
58
class PlainTypeTests(TestWithScenarios, TestCase):
366
56
59
367
@@ -281,19 +284,32 @@
368
281
        self.assertEqual(repr(c), str(c))
284
        self.assertEqual(repr(c), str(c))
369
282
285
370
283
286
372
284
class DateTimeTests(TestCase):
287
def unable_to_handle_timestamp(timestamp):
373
288
    """Return false if the platform can handle timestamps larger than 32bit
374
289
    limit.
375
290
376
291
    """
377
292
    try:
378
293
        datetime.fromtimestamp(timestamp)
379
294
        return False
380
295
    except:
381
296
        return True
382
297
383
298
384
299
class DateTimeCreationTests(TestCase):
385
300
386
301
    timestamp = 1405382400  # No significance, just a timestamp
387
285
302
388
286
    def test_can_construct_datetime(self):
303
    def test_can_construct_datetime(self):
390
287
        dt = DateTime(1377209927)
304
        dt = DateTime(self.timestamp)
391
288
        self.assertThat(dt, IsInstance(dbus.Array))
305
        self.assertThat(dt, IsInstance(dbus.Array))
392
289
306
393
290
    def test_datetime_has_slice_access(self):
307
    def test_datetime_has_slice_access(self):
397
291
        dt = DateTime(1377209927)
308
        dt = DateTime(self.timestamp)
398
292
309
        self.assertThat(dt[0], Equals(self.timestamp))
396
293
        self.assertThat(dt[0], Equals(1377209927))
399
294
310
400
295
    def test_datetime_has_properties(self):
311
    def test_datetime_has_properties(self):
402
296
        dt = DateTime(1377209927)
312
        dt = DateTime(self.timestamp)
403
297
313
404
298
        self.assertTrue(hasattr(dt, 'timestamp'))
314
        self.assertTrue(hasattr(dt, 'timestamp'))
405
299
        self.assertTrue(hasattr(dt, 'year'))
315
        self.assertTrue(hasattr(dt, 'year'))
406
@@ -303,58 +319,154 @@
407
303
        self.assertTrue(hasattr(dt, 'minute'))
319
        self.assertTrue(hasattr(dt, 'minute'))
408
304
        self.assertTrue(hasattr(dt, 'second'))
320
        self.assertTrue(hasattr(dt, 'second'))
409
305
321
410
322
    def test_repr(self):
411
323
        # Use a well known timezone for comparison
412
324
        self.useFixture(SetTimezone('UTC'))
413
325
        dt = DateTime(self.timestamp)
414
326
        observed = repr(dt)
415
327
416
328
        expected = "DateTime({:%Y-%m-%d %H:%M:%S})".format(
417
329
            datetime.fromtimestamp(self.timestamp)
418
330
        )
419
331
        self.assertEqual(expected, observed)
420
332
421
333
    def test_repr_equals_str(self):
422
334
        dt = DateTime(self.timestamp)
423
335
        self.assertEqual(repr(dt), str(dt))
424
336
425
337
    def test_can_create_DateTime_using_large_timestamp(self):
426
338
        """Must be able to create a DateTime object using a timestamp larger
427
339
        than the 32bit time_t limit.
428
340
429
341
        """
430
342
        # Use a well known timezone for comparison
431
343
        self.useFixture(SetTimezone('UTC'))
432
344
        large_timestamp = 2**32+1
433
345
        dt = DateTime(large_timestamp)
434
346
435
347
        self.assertEqual(dt.year, 2106)
436
348
        self.assertEqual(dt.month, 2)
437
349
        self.assertEqual(dt.day, 7)
438
350
        self.assertEqual(dt.hour, 6)
439
351
        self.assertEqual(dt.minute, 28)
440
352
        self.assertEqual(dt.second, 17)
441
353
        self.assertEqual(dt.timestamp, large_timestamp)
442
354
443
355
444
356
class DateTimeTests(TestWithScenarios, TestCase):
445
357
446
358
    timestamps = [
447
359
        # This timestamp uncovered an issue during development.
448
360
        ('Explicit US/Pacific test', dict(
449
361
            timestamp=1090123200
450
362
        )),
451
363
452
364
        ('NZ DST example', dict(
453
365
            timestamp=2047570047
454
366
        )),
455
367
456
368
        ('Winter', dict(
457
369
            timestamp=1389744000
458
370
        )),
459
371
460
372
        ('Summer', dict(
461
373
            timestamp=1405382400
462
374
        )),
463
375
464
376
        ('32bit max', dict(
465
377
            timestamp=2**32+1
466
378
        )),
467
379
468
380
        ('32bit limit', dict(
469
381
            timestamp=2983579200
470
382
        )),
471
383
472
384
    ]
473
385
474
386
    timezones = [
475
387
        ('UTC', dict(
476
388
            timezone='UTC'
477
389
        )),
478
390
479
391
        ('London', dict(
480
392
            timezone='Europe/London'
481
393
        )),
482
394
483
395
        ('New Zealand', dict(
484
396
            timezone='NZ',
485
397
        )),
486
398
487
399
        ('Pacific', dict(
488
400
            timezone='US/Pacific'
489
401
        )),
490
402
491
403
        ('Hongkong', dict(
492
404
            timezone='Hongkong'
493
405
        )),
494
406
495
407
        ('Moscow', dict(
496
408
            timezone='Europe/Moscow'
497
409
        ))
498
410
    ]
499
411
500
412
    scenarios = multiply_scenarios(timestamps, timezones)
501
413
502
414
    def skip_if_timestamp_too_large(self, timestamp):
503
415
        if unable_to_handle_timestamp(self.timestamp):
504
416
            self.skip("Timestamp to large for platform time_t")
505
417
506
306
    def test_datetime_properties_have_correct_values(self):
418
    def test_datetime_properties_have_correct_values(self):
517
307
        dt = DateTime(1377209927)
419
        self.skip_if_timestamp_too_large(self.timestamp)
518
308
        dt_with_tz = datetime.fromtimestamp(1377209927)
420
        self.useFixture(SetTimezone(self.timezone))
519
309
421
520
310
        self.assertThat(dt.timestamp, Equals(dt_with_tz.timestamp()))
422
        dt1 = DateTime(self.timestamp)
521
311
        self.assertThat(dt.year, Equals(dt_with_tz.year))
423
        dt2 = datetime.fromtimestamp(self.timestamp, tz.gettz())
522
312
        self.assertThat(dt.month, Equals(dt_with_tz.month))
424
523
313
        self.assertThat(dt.day, Equals(dt_with_tz.day))
425
        self.assertThat(dt1.year, Equals(dt2.year))
524
314
        self.assertThat(dt.hour, Equals(dt_with_tz.hour))
426
        self.assertThat(dt1.month, Equals(dt2.month))
525
315
        self.assertThat(dt.minute, Equals(dt_with_tz.minute))
427
        self.assertThat(dt1.day, Equals(dt2.day))
526
316
        self.assertThat(dt.second, Equals(dt_with_tz.second))
428
        self.assertThat(dt1.hour, Equals(dt2.hour))
527
429
        self.assertThat(dt1.minute, Equals(dt2.minute))
528
430
        self.assertThat(dt1.second, Equals(dt2.second))
529
431
        self.assertThat(dt1.timestamp, Equals(dt2.timestamp()))
530
317
432
531
318
    def test_equality_with_datetime(self):
433
    def test_equality_with_datetime(self):
534
319
        dt1 = DateTime(1377209927)
434
        self.skip_if_timestamp_too_large(self.timestamp)
535
320
        dt2 = DateTime(1377209927)
435
        self.useFixture(SetTimezone(self.timezone))
536
436
537
437
        dt1 = DateTime(self.timestamp)
538
438
        dt2 = datetime(
539
439
            dt1.year, dt1.month, dt1.day, dt1.hour, dt1.minute, dt1.second
540
440
        )
541
321
441
542
322
        self.assertThat(dt1, Equals(dt2))
442
        self.assertThat(dt1, Equals(dt2))
543
323
443
544
324
    def test_equality_with_list(self):
444
    def test_equality_with_list(self):
547
325
        dt1 = DateTime(1377209927)
445
        self.skip_if_timestamp_too_large(self.timestamp)
548
326
        dt2 = [1377209927]
446
        self.useFixture(SetTimezone(self.timezone))
549
447
550
448
        dt1 = DateTime(self.timestamp)
551
449
        dt2 = [self.timestamp]
552
327
450
553
328
        self.assertThat(dt1, Equals(dt2))
451
        self.assertThat(dt1, Equals(dt2))
554
329
452
560
330
    def test_equality_with_datetime_timestamp(self):
453
    def test_equality_with_datetime_object(self):
561
331
        # DateTime no longer assumes UTC and uses local TZ.
454
        self.skip_if_timestamp_too_large(self.timestamp)
562
332
        dt1 = DateTime(1377209927)
455
        self.useFixture(SetTimezone(self.timezone))
563
333
        dt2 = datetime.fromtimestamp(1377209927)
456
564
334
        dt3 = datetime.fromtimestamp(1377209928)
457
        dt1 = DateTime(self.timestamp)
565
458
        dt2 = datetime.fromtimestamp(self.timestamp, tz.gettz())
566
459
        dt3 = datetime.fromtimestamp(self.timestamp + 1, tz.gettz())
567
335
460
568
336
        self.assertThat(dt1, Equals(dt2))
461
        self.assertThat(dt1, Equals(dt2))
569
337
        self.assertThat(dt1, NotEquals(dt3))
462
        self.assertThat(dt1, NotEquals(dt3))
570
338
463
571
339
    def test_can_convert_to_datetime(self):
464
    def test_can_convert_to_datetime(self):
573
340
        dt1 = DateTime(1377209927)
465
        self.skip_if_timestamp_too_large(self.timestamp)
574
341
466
575
467
        dt1 = DateTime(self.timestamp)
576
342
        self.assertThat(dt1.datetime, IsInstance(datetime))
468
        self.assertThat(dt1.datetime, IsInstance(datetime))
577
343
469
578
344
    def test_repr(self):
579
345
        expected = repr_type(
580
346
            u"DateTime({:%Y-%m-%d %H:%M:%S})".format(
581
347
                datetime.fromtimestamp(1377209927)
582
348
            )
583
349
        )
584
350
        dt = DateTime(1377209927)
585
351
        observed = repr(dt)
586
352
        self.assertEqual(expected, observed)
587
353
588
354
    def test_repr_equals_str(self):
589
355
        dt = DateTime(1377209927)
590
356
        self.assertEqual(repr(dt), str(dt))
591
357
592
358
470
593
359
class TimeTests(TestCase):
471
class TimeTests(TestCase):
594
360
472
595
361
473
596
=== modified file 'debian/control'
597
--- debian/control	2014-08-05 21:58:41 +0000
598
+++ debian/control	2014-10-22 20:43:57 +0000
599
@@ -15,6 +15,7 @@
600
15
               libjs-underscore,
15
               libjs-underscore,
601
16
               liblttng-ust-dev,
16
               liblttng-ust-dev,
602
17
               python3-all-dev (>= 3.4),
17
               python3-all-dev (>= 3.4),
603
18
               python3-dateutil,
604
18
               python3-dbus,
19
               python3-dbus,
605
19
               python3-decorator,
20
               python3-decorator,
606
20
               python3-evdev,
21
               python3-evdev,
607
@@ -44,6 +45,7 @@
608
44
         ${python3:Depends},
45
         ${python3:Depends},
609
45
         gir1.2-ubuntu-app-launch-2 | gir1.2-upstart-app-launch-2,
46
         gir1.2-ubuntu-app-launch-2 | gir1.2-upstart-app-launch-2,
610
46
         libjs-underscore, libjs-jquery,
47
         libjs-underscore, libjs-jquery,
611
48
         python3-dateutil,
612
47
         python3-dbus,
49
         python3-dbus,
613
48
         python3-decorator,
50
         python3-decorator,
614
49
         python3-fixtures,
51
         python3-fixtures,
615
@@ -135,6 +137,7 @@
616
135
         libautopilot-gtk (>= 1.4),
137
         libautopilot-gtk (>= 1.4),
617
136
         libautopilot-qt (>= 1.4),
138
         libautopilot-qt (>= 1.4),
618
137
         python3-autopilot,
139
         python3-autopilot,
619
140
         python3-dateutil,
620
138
         python3-dbus.mainloop.qt,
141
         python3-dbus.mainloop.qt,
621
139
         python3-evdev,
142
         python3-evdev,
622
140
         python3-pyqt4,
143
         python3-pyqt4,
Reviewer	Review Type	Date Requested	Status
Nicholas Skaggs (community)			Approve on 2014-10-22
PS Jenkins bot	continuous-integration	2014-10-02	Needs Fixing on 2014-10-17
Thomi Richards (community)		2014-10-02	Needs Fixing on 2014-10-16
Robert Bruce Park		2014-10-02	Pending
Barry Warsaw		2014-10-02	Pending
Christopher Lee			Pending
Review via email: mp+236815@code.launchpad.net