Пример #1
0
    def test_test_format(self):
        datetime_type = DateTime(datetime_format='%m-%d-%Y %I:%M %p')

        self.assertEqual(datetime_type.test('3/1/1994 12:30 PM'), False)
        self.assertEqual(datetime_type.test('03-01-1994 12:30 PM'), True)
        self.assertEqual(
            datetime_type.test(datetime.datetime(1994, 3, 1, 12, 30)), True)
Пример #2
0
    def test_cast_format_locale(self):
        date_type = DateTime(datetime_format='%Y-%m-%d %I:%M %p',
                             locale='ko_KR.UTF-8')

        # Date formats depend on the platform's strftime/strptime implementation;
        # some platforms like macOS always return AM/PM for day periods (%p),
        # so we will catch any CastError that may arise from the conversion
        possible_values = (
            ('1994-03-01 12:30 오후', '2011-02-17 06:30 오전', None,
             '1984-01-05 06:30 오후', 'n/a'),
            ('1994-03-01 12:30 PM', '2011-02-17 06:30 AM', None,
             '1984-01-05 06:30 PM', 'n/a'),
        )
        valid = False
        exceptions = []
        for values in possible_values:
            try:
                casted = tuple(date_type.cast(v) for v in values)
            except CastError as e:
                exceptions.append(repr(e))
                continue
            self.assertSequenceEqual(
                casted, (datetime.datetime(1994, 3, 1, 12, 30, 0),
                         datetime.datetime(2011, 2, 17, 6, 30, 0), None,
                         datetime.datetime(1984, 1, 5, 18, 30, 0), None))
            valid = True
        if not valid:
            raise AssertionError('\n\n'.join(exceptions))
Пример #3
0
    def test_cast_locale(self):
        date_type = DateTime(locale='fr_FR')

        values = ('01/03/1994 12:30', '17/2/11 6:30', None, '5/01/84 18:30',
                  'n/a')
        casted = tuple(date_type.cast(v) for v in values)
        self.assertSequenceEqual(
            casted, (datetime.datetime(1994, 3, 1, 12, 30, 0),
                     datetime.datetime(2011, 2, 17, 6, 30, 0), None,
                     datetime.datetime(1984, 1, 5, 18, 30, 0), None))
Пример #4
0
    def test_cast_format(self):
        datetime_type = DateTime(datetime_format='%m-%d-%Y %I:%M %p')

        values = ('03-01-1994 12:30 PM', '02-17-2011 06:30 AM', None,
                  '01-05-1984 06:30 PM', 'n/a')
        casted = tuple(datetime_type.cast(v) for v in values)
        self.assertSequenceEqual(
            casted, (datetime.datetime(1994, 3, 1, 12, 30, 0),
                     datetime.datetime(2011, 2, 17, 6, 30, 0), None,
                     datetime.datetime(1984, 1, 5, 18, 30, 0), None))
Пример #5
0
    def test_cast_parser_timezone(self):
        tzinfo = pytz.timezone('US/Pacific')
        datetime_type = DateTime(timezone=tzinfo)

        values = ('3/1/1994 12:30 PM', '2/17/2011 06:30', None,
                  'January 5th, 1984 22:37', 'n/a')
        casted = tuple(datetime_type.cast(v) for v in values)
        self.assertSequenceEqual(
            casted,
            (tzinfo.localize(datetime.datetime(1994, 3, 1, 12, 30, 0, 0)),
             tzinfo.localize(datetime.datetime(2011, 2, 17, 6, 30, 0, 0)),
             None, tzinfo.localize(datetime.datetime(1984, 1, 5, 22, 37, 0,
                                                     0)), None))
Пример #6
0
    def test_change_datetimes(self):
        rows = (('10/4/2015 4:43', '10/7/2015 4:50'),
                ('10/2/2015 12 PM', '9/28/2015 12 PM'), ('9/28/2015 12:00:00',
                                                         '9/1/2015 6 PM'))

        datetime_type = DateTime()

        column_names = ['one', 'two']
        column_types = [datetime_type, datetime_type]

        table = Table(rows, column_names, column_types)

        new_table = table.compute([('test', Change('one', 'two'))])

        self.assertIsNot(new_table, table)
        self.assertEqual(len(new_table.rows), 3)
        self.assertEqual(len(new_table.columns), 3)

        self.assertSequenceEqual(new_table.rows[0], (datetime.datetime(
            2015, 10, 4, 4, 43), datetime.datetime(
                2015, 10, 7, 4, 50), datetime.timedelta(days=3, minutes=7)))

        self.assertEqual(new_table.columns['test'][0],
                         datetime.timedelta(days=3, minutes=7))
        self.assertEqual(new_table.columns['test'][1],
                         datetime.timedelta(days=-4))
        self.assertEqual(new_table.columns['test'][2],
                         datetime.timedelta(days=-26, hours=-18))
Пример #7
0
    def setUp(self):
        self.rows = [
            [datetime.datetime(1994, 3, 3, 6, 31)],
            [datetime.datetime(1994, 3, 3, 6, 30, 30)],
            [datetime.datetime(1994, 3, 3, 6, 30)],
        ]

        self.table = Table(self.rows, ['test', 'null'],
                           [DateTime(), DateTime()])

        self.time_delta_rows = [
            [datetime.timedelta(seconds=10), None],
            [datetime.timedelta(seconds=20), None],
        ]

        self.time_delta_table = Table(self.time_delta_rows, ['test', 'null'],
                                      [TimeDelta(), TimeDelta()])
Пример #8
0
    def setUp(self):
        self.rows = (
            (1, 'a', True, '11/4/2015', '11/4/2015 12:22 PM', '4:15'),
            (2, u'👍', False, '11/5/2015', '11/4/2015 12:45 PM', '6:18'),
            (None, 'b', None, None, None, None)
        )

        self.column_names = [
            'number', 'text', 'boolean', 'date', 'datetime', 'timedelta'
        ]

        self.column_types = [
            Number(), Text(), Boolean(), Date(), DateTime(), TimeDelta()
        ]
Пример #9
0
 def setUp(self):
     self.type = DateTime()
Пример #10
0
class TestDateTime(unittest.TestCase):
    def setUp(self):
        self.type = DateTime()

    def test_test(self):
        self.assertEqual(self.type.test(None), True)
        self.assertEqual(self.type.test('N/A'), True)
        self.assertEqual(self.type.test(True), False)
        self.assertEqual(self.type.test('True'), False)
        self.assertEqual(self.type.test(1), False)
        self.assertEqual(self.type.test(Decimal('1')), False)
        self.assertEqual(self.type.test('2.7'), True)
        self.assertEqual(self.type.test(2.7), False)
        self.assertEqual(self.type.test('3/1/1994'), True)
        self.assertEqual(self.type.test(datetime.date(1994, 3, 1)), True)
        self.assertEqual(self.type.test('3/1/1994 12:30 PM'), True)
        self.assertEqual(self.type.test('2015-01-01 02:34'), True)
        self.assertEqual(self.type.test(datetime.datetime(1994, 3, 1, 12, 30)),
                         True)
        self.assertEqual(self.type.test('4:10'), False)
        self.assertEqual(
            self.type.test(datetime.timedelta(hours=4, minutes=10)), False)
        self.assertEqual(self.type.test('a'), False)
        self.assertEqual(self.type.test('A\nB'), False)
        self.assertEqual(self.type.test(u'👍'), False)
        self.assertEqual(self.type.test('05_leslie3d_base'), False)
        self.assertEqual(self.type.test('2016-12-29'), True)
        self.assertEqual(self.type.test('2016-12-29T11:43:30Z'), True)
        self.assertEqual(self.type.test('2016-12-29T11:43:30+06:00'), True)
        self.assertEqual(self.type.test('2016-12-29T11:43:30-06:00'), True)
        self.assertEqual(self.type.test('720(38-4)31A-1.1(A)'), False)

    def test_test_format(self):
        datetime_type = DateTime(datetime_format='%m-%d-%Y %I:%M %p')

        self.assertEqual(datetime_type.test('3/1/1994 12:30 PM'), False)
        self.assertEqual(datetime_type.test('03-01-1994 12:30 PM'), True)
        self.assertEqual(
            datetime_type.test(datetime.datetime(1994, 3, 1, 12, 30)), True)

    def test_iso_format(self):
        values = ('1994-03-01T12:30:00', '2011-02-17T06:30')
        casted = tuple(self.type.cast(v) for v in values)
        self.assertSequenceEqual(casted, (datetime.datetime(
            1994, 3, 1, 12, 30, 0), datetime.datetime(2011, 2, 17, 6, 30, 0)))

    def test_cast_parser(self):
        values = ('3/1/1994 12:30 PM', '2/17/2011 06:30', None,
                  'January 5th, 1984 22:37', 'n/a', '2015-01-01 02:34')
        casted = tuple(self.type.cast(v) for v in values)
        self.assertSequenceEqual(
            casted, (datetime.datetime(1994, 3, 1, 12, 30, 0),
                     datetime.datetime(2011, 2, 17, 6, 30, 0), None,
                     datetime.datetime(1984, 1, 5, 22, 37, 0), None,
                     datetime.datetime(2015, 1, 1, 2, 34, 0)))

    def test_cast_parser_timezone(self):
        tzinfo = pytz.timezone('US/Pacific')
        datetime_type = DateTime(timezone=tzinfo)

        values = ('3/1/1994 12:30 PM', '2/17/2011 06:30', None,
                  'January 5th, 1984 22:37', 'n/a')
        casted = tuple(datetime_type.cast(v) for v in values)
        self.assertSequenceEqual(
            casted,
            (tzinfo.localize(datetime.datetime(1994, 3, 1, 12, 30, 0, 0)),
             tzinfo.localize(datetime.datetime(2011, 2, 17, 6, 30, 0, 0)),
             None, tzinfo.localize(datetime.datetime(1984, 1, 5, 22, 37, 0,
                                                     0)), None))

    def test_cast_format(self):
        datetime_type = DateTime(datetime_format='%m-%d-%Y %I:%M %p')

        values = ('03-01-1994 12:30 PM', '02-17-2011 06:30 AM', None,
                  '01-05-1984 06:30 PM', 'n/a')
        casted = tuple(datetime_type.cast(v) for v in values)
        self.assertSequenceEqual(
            casted, (datetime.datetime(1994, 3, 1, 12, 30, 0),
                     datetime.datetime(2011, 2, 17, 6, 30, 0), None,
                     datetime.datetime(1984, 1, 5, 18, 30, 0), None))

    def test_cast_format_locale(self):
        date_type = DateTime(datetime_format='%Y-%m-%d %I:%M %p',
                             locale='ko_KR.UTF-8')

        # Date formats depend on the platform's strftime/strptime implementation;
        # some platforms like macOS always return AM/PM for day periods (%p),
        # so we will catch any CastError that may arise from the conversion
        possible_values = (
            ('1994-03-01 12:30 오후', '2011-02-17 06:30 오전', None,
             '1984-01-05 06:30 오후', 'n/a'),
            ('1994-03-01 12:30 PM', '2011-02-17 06:30 AM', None,
             '1984-01-05 06:30 PM', 'n/a'),
        )
        valid = False
        exceptions = []
        for values in possible_values:
            try:
                casted = tuple(date_type.cast(v) for v in values)
            except CastError as e:
                exceptions.append(repr(e))
                continue
            self.assertSequenceEqual(
                casted, (datetime.datetime(1994, 3, 1, 12, 30, 0),
                         datetime.datetime(2011, 2, 17, 6, 30, 0), None,
                         datetime.datetime(1984, 1, 5, 18, 30, 0), None))
            valid = True
        if not valid:
            raise AssertionError('\n\n'.join(exceptions))

    def test_cast_locale(self):
        date_type = DateTime(locale='fr_FR')

        values = ('01/03/1994 12:30', '17/2/11 6:30', None, '5/01/84 18:30',
                  'n/a')
        casted = tuple(date_type.cast(v) for v in values)
        self.assertSequenceEqual(
            casted, (datetime.datetime(1994, 3, 1, 12, 30, 0),
                     datetime.datetime(2011, 2, 17, 6, 30, 0), None,
                     datetime.datetime(1984, 1, 5, 18, 30, 0), None))

    def test_cast_error(self):
        with self.assertRaises(CastError):
            self.type.cast('quack')

    def test_pickle_parser(self):
        from_pickle = pickle.loads(pickle.dumps(self.type))
        self.assertEqual(from_pickle.datetime_format,
                         self.type.datetime_format)
        self.assertEqual(from_pickle.timezone, self.type.timezone)
        self.assertEqual(from_pickle.locale, self.type.locale)
        self.assertEqual(from_pickle._source_time, self.type._source_time)
        self.assertIsInstance(from_pickle._constants, parsedatetime.Constants)
        self.assertIsInstance(from_pickle._parser, parsedatetime.Calendar)