You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
540 lines
19 KiB
540 lines
19 KiB
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (c) 2021, Brandon Nielsen
|
|
# All rights reserved.
|
|
#
|
|
# This software may be modified and distributed under the terms
|
|
# of the BSD license. See the LICENSE file for details.
|
|
|
|
import unittest
|
|
|
|
import aniso8601
|
|
from aniso8601.builders import DatetimeTuple, DateTuple, TimeTuple, TimezoneTuple
|
|
from aniso8601.exceptions import ISOFormatError
|
|
from aniso8601.resolution import TimeResolution
|
|
from aniso8601.tests.compat import mock
|
|
from aniso8601.time import (
|
|
_get_time_resolution,
|
|
get_datetime_resolution,
|
|
get_time_resolution,
|
|
parse_datetime,
|
|
parse_time,
|
|
)
|
|
|
|
|
|
class TestTimeResolutionFunctions(unittest.TestCase):
|
|
def test_get_time_resolution(self):
|
|
self.assertEqual(get_time_resolution("01:23:45"), TimeResolution.Seconds)
|
|
self.assertEqual(get_time_resolution("24:00:00"), TimeResolution.Seconds)
|
|
self.assertEqual(get_time_resolution("23:21:28,512400"), TimeResolution.Seconds)
|
|
self.assertEqual(get_time_resolution("23:21:28.512400"), TimeResolution.Seconds)
|
|
self.assertEqual(get_time_resolution("01:23"), TimeResolution.Minutes)
|
|
self.assertEqual(get_time_resolution("24:00"), TimeResolution.Minutes)
|
|
self.assertEqual(get_time_resolution("01:23,4567"), TimeResolution.Minutes)
|
|
self.assertEqual(get_time_resolution("01:23.4567"), TimeResolution.Minutes)
|
|
self.assertEqual(get_time_resolution("012345"), TimeResolution.Seconds)
|
|
self.assertEqual(get_time_resolution("240000"), TimeResolution.Seconds)
|
|
self.assertEqual(get_time_resolution("0123"), TimeResolution.Minutes)
|
|
self.assertEqual(get_time_resolution("2400"), TimeResolution.Minutes)
|
|
self.assertEqual(get_time_resolution("01"), TimeResolution.Hours)
|
|
self.assertEqual(get_time_resolution("24"), TimeResolution.Hours)
|
|
self.assertEqual(get_time_resolution("12,5"), TimeResolution.Hours)
|
|
self.assertEqual(get_time_resolution("12.5"), TimeResolution.Hours)
|
|
self.assertEqual(
|
|
get_time_resolution("232128.512400+00:00"), TimeResolution.Seconds
|
|
)
|
|
self.assertEqual(get_time_resolution("0123.4567+00:00"), TimeResolution.Minutes)
|
|
self.assertEqual(get_time_resolution("01.4567+00:00"), TimeResolution.Hours)
|
|
self.assertEqual(get_time_resolution("01:23:45+00:00"), TimeResolution.Seconds)
|
|
self.assertEqual(get_time_resolution("24:00:00+00:00"), TimeResolution.Seconds)
|
|
self.assertEqual(
|
|
get_time_resolution("23:21:28.512400+00:00"), TimeResolution.Seconds
|
|
)
|
|
self.assertEqual(get_time_resolution("01:23+00:00"), TimeResolution.Minutes)
|
|
self.assertEqual(get_time_resolution("24:00+00:00"), TimeResolution.Minutes)
|
|
self.assertEqual(
|
|
get_time_resolution("01:23.4567+00:00"), TimeResolution.Minutes
|
|
)
|
|
self.assertEqual(
|
|
get_time_resolution("23:21:28.512400+11:15"), TimeResolution.Seconds
|
|
)
|
|
self.assertEqual(
|
|
get_time_resolution("23:21:28.512400-12:34"), TimeResolution.Seconds
|
|
)
|
|
self.assertEqual(
|
|
get_time_resolution("23:21:28.512400Z"), TimeResolution.Seconds
|
|
)
|
|
self.assertEqual(
|
|
get_time_resolution("06:14:00.000123Z"), TimeResolution.Seconds
|
|
)
|
|
|
|
def test_get_datetime_resolution(self):
|
|
self.assertEqual(
|
|
get_datetime_resolution("2019-06-05T01:03:11.858714"),
|
|
TimeResolution.Seconds,
|
|
)
|
|
self.assertEqual(
|
|
get_datetime_resolution("2019-06-05T01:03:11"), TimeResolution.Seconds
|
|
)
|
|
self.assertEqual(
|
|
get_datetime_resolution("2019-06-05T01:03"), TimeResolution.Minutes
|
|
)
|
|
self.assertEqual(get_datetime_resolution("2019-06-05T01"), TimeResolution.Hours)
|
|
|
|
def test_get_time_resolution_badtype(self):
|
|
testtuples = (None, 1, False, 1.234)
|
|
|
|
for testtuple in testtuples:
|
|
with self.assertRaises(ValueError):
|
|
get_time_resolution(testtuple)
|
|
|
|
def test_get_time_resolution_badstr(self):
|
|
testtuples = ("A6:14:00.000123Z", "06:14:0B", "bad", "")
|
|
|
|
for testtuple in testtuples:
|
|
with self.assertRaises(ISOFormatError):
|
|
get_time_resolution(testtuple)
|
|
|
|
def test_get_time_resolution_internal(self):
|
|
self.assertEqual(
|
|
_get_time_resolution(TimeTuple(hh="01", mm="02", ss="03", tz=None)),
|
|
TimeResolution.Seconds,
|
|
)
|
|
self.assertEqual(
|
|
_get_time_resolution(TimeTuple(hh="01", mm="02", ss=None, tz=None)),
|
|
TimeResolution.Minutes,
|
|
)
|
|
self.assertEqual(
|
|
_get_time_resolution(TimeTuple(hh="01", mm=None, ss=None, tz=None)),
|
|
TimeResolution.Hours,
|
|
)
|
|
|
|
|
|
class TestTimeParserFunctions(unittest.TestCase):
|
|
def test_parse_time(self):
|
|
testtuples = (
|
|
("01:23:45", {"hh": "01", "mm": "23", "ss": "45", "tz": None}),
|
|
("24:00:00", {"hh": "24", "mm": "00", "ss": "00", "tz": None}),
|
|
(
|
|
"23:21:28,512400",
|
|
{"hh": "23", "mm": "21", "ss": "28.512400", "tz": None},
|
|
),
|
|
(
|
|
"23:21:28.512400",
|
|
{"hh": "23", "mm": "21", "ss": "28.512400", "tz": None},
|
|
),
|
|
(
|
|
"01:03:11.858714",
|
|
{"hh": "01", "mm": "03", "ss": "11.858714", "tz": None},
|
|
),
|
|
(
|
|
"14:43:59.9999997",
|
|
{"hh": "14", "mm": "43", "ss": "59.9999997", "tz": None},
|
|
),
|
|
("01:23", {"hh": "01", "mm": "23", "ss": None, "tz": None}),
|
|
("24:00", {"hh": "24", "mm": "00", "ss": None, "tz": None}),
|
|
("01:23,4567", {"hh": "01", "mm": "23.4567", "ss": None, "tz": None}),
|
|
("01:23.4567", {"hh": "01", "mm": "23.4567", "ss": None, "tz": None}),
|
|
("012345", {"hh": "01", "mm": "23", "ss": "45", "tz": None}),
|
|
("240000", {"hh": "24", "mm": "00", "ss": "00", "tz": None}),
|
|
("232128,512400", {"hh": "23", "mm": "21", "ss": "28.512400", "tz": None}),
|
|
("232128.512400", {"hh": "23", "mm": "21", "ss": "28.512400", "tz": None}),
|
|
("010311.858714", {"hh": "01", "mm": "03", "ss": "11.858714", "tz": None}),
|
|
(
|
|
"144359.9999997",
|
|
{"hh": "14", "mm": "43", "ss": "59.9999997", "tz": None},
|
|
),
|
|
("0123", {"hh": "01", "mm": "23", "ss": None, "tz": None}),
|
|
("2400", {"hh": "24", "mm": "00", "ss": None, "tz": None}),
|
|
("01", {"hh": "01", "mm": None, "ss": None, "tz": None}),
|
|
("24", {"hh": "24", "mm": None, "ss": None, "tz": None}),
|
|
("12,5", {"hh": "12.5", "mm": None, "ss": None, "tz": None}),
|
|
("12.5", {"hh": "12.5", "mm": None, "ss": None, "tz": None}),
|
|
(
|
|
"232128,512400+00:00",
|
|
{
|
|
"hh": "23",
|
|
"mm": "21",
|
|
"ss": "28.512400",
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"232128.512400+00:00",
|
|
{
|
|
"hh": "23",
|
|
"mm": "21",
|
|
"ss": "28.512400",
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"0123,4567+00:00",
|
|
{
|
|
"hh": "01",
|
|
"mm": "23.4567",
|
|
"ss": None,
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"0123.4567+00:00",
|
|
{
|
|
"hh": "01",
|
|
"mm": "23.4567",
|
|
"ss": None,
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"01,4567+00:00",
|
|
{
|
|
"hh": "01.4567",
|
|
"mm": None,
|
|
"ss": None,
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"01.4567+00:00",
|
|
{
|
|
"hh": "01.4567",
|
|
"mm": None,
|
|
"ss": None,
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"01:23:45+00:00",
|
|
{
|
|
"hh": "01",
|
|
"mm": "23",
|
|
"ss": "45",
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"24:00:00+00:00",
|
|
{
|
|
"hh": "24",
|
|
"mm": "00",
|
|
"ss": "00",
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"23:21:28.512400+00:00",
|
|
{
|
|
"hh": "23",
|
|
"mm": "21",
|
|
"ss": "28.512400",
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"01:23+00:00",
|
|
{
|
|
"hh": "01",
|
|
"mm": "23",
|
|
"ss": None,
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"24:00+00:00",
|
|
{
|
|
"hh": "24",
|
|
"mm": "00",
|
|
"ss": None,
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"01:23.4567+00:00",
|
|
{
|
|
"hh": "01",
|
|
"mm": "23.4567",
|
|
"ss": None,
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
},
|
|
),
|
|
(
|
|
"23:21:28.512400+11:15",
|
|
{
|
|
"hh": "23",
|
|
"mm": "21",
|
|
"ss": "28.512400",
|
|
"tz": TimezoneTuple(False, None, "11", "15", "+11:15"),
|
|
},
|
|
),
|
|
(
|
|
"23:21:28.512400-12:34",
|
|
{
|
|
"hh": "23",
|
|
"mm": "21",
|
|
"ss": "28.512400",
|
|
"tz": TimezoneTuple(True, None, "12", "34", "-12:34"),
|
|
},
|
|
),
|
|
(
|
|
"23:21:28.512400Z",
|
|
{
|
|
"hh": "23",
|
|
"mm": "21",
|
|
"ss": "28.512400",
|
|
"tz": TimezoneTuple(False, True, None, None, "Z"),
|
|
},
|
|
),
|
|
(
|
|
"06:14:00.000123Z",
|
|
{
|
|
"hh": "06",
|
|
"mm": "14",
|
|
"ss": "00.000123",
|
|
"tz": TimezoneTuple(False, True, None, None, "Z"),
|
|
},
|
|
),
|
|
)
|
|
|
|
for testtuple in testtuples:
|
|
with mock.patch.object(
|
|
aniso8601.time.PythonTimeBuilder, "build_time"
|
|
) as mockBuildTime:
|
|
|
|
mockBuildTime.return_value = testtuple[1]
|
|
|
|
result = parse_time(testtuple[0])
|
|
|
|
self.assertEqual(result, testtuple[1])
|
|
mockBuildTime.assert_called_once_with(**testtuple[1])
|
|
|
|
def test_parse_time_badtype(self):
|
|
testtuples = (None, 1, False, 1.234)
|
|
|
|
for testtuple in testtuples:
|
|
with self.assertRaises(ValueError):
|
|
parse_time(testtuple, builder=None)
|
|
|
|
def test_parse_time_badstr(self):
|
|
testtuples = (
|
|
"A6:14:00.000123Z",
|
|
"06:14:0B",
|
|
"06:1 :02",
|
|
"0000,70:24,9",
|
|
"00.27:5332",
|
|
"bad",
|
|
"",
|
|
)
|
|
|
|
for testtuple in testtuples:
|
|
with self.assertRaises(ISOFormatError):
|
|
parse_time(testtuple, builder=None)
|
|
|
|
def test_parse_time_mockbuilder(self):
|
|
mockBuilder = mock.Mock()
|
|
|
|
expectedargs = {"hh": "01", "mm": "23", "ss": "45", "tz": None}
|
|
|
|
mockBuilder.build_time.return_value = expectedargs
|
|
|
|
result = parse_time("01:23:45", builder=mockBuilder)
|
|
|
|
self.assertEqual(result, expectedargs)
|
|
mockBuilder.build_time.assert_called_once_with(**expectedargs)
|
|
|
|
mockBuilder = mock.Mock()
|
|
|
|
expectedargs = {
|
|
"hh": "23",
|
|
"mm": "21",
|
|
"ss": "28.512400",
|
|
"tz": TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
}
|
|
|
|
mockBuilder.build_time.return_value = expectedargs
|
|
|
|
result = parse_time("232128.512400+00:00", builder=mockBuilder)
|
|
|
|
self.assertEqual(result, expectedargs)
|
|
mockBuilder.build_time.assert_called_once_with(**expectedargs)
|
|
|
|
mockBuilder = mock.Mock()
|
|
|
|
expectedargs = {
|
|
"hh": "23",
|
|
"mm": "21",
|
|
"ss": "28.512400",
|
|
"tz": TimezoneTuple(False, None, "11", "15", "+11:15"),
|
|
}
|
|
|
|
mockBuilder.build_time.return_value = expectedargs
|
|
|
|
result = parse_time("23:21:28.512400+11:15", builder=mockBuilder)
|
|
|
|
self.assertEqual(result, expectedargs)
|
|
mockBuilder.build_time.assert_called_once_with(**expectedargs)
|
|
|
|
def test_parse_datetime(self):
|
|
testtuples = (
|
|
(
|
|
"2019-06-05T01:03:11,858714",
|
|
(
|
|
DateTuple("2019", "06", "05", None, None, None),
|
|
TimeTuple("01", "03", "11.858714", None),
|
|
),
|
|
),
|
|
(
|
|
"2019-06-05T01:03:11.858714",
|
|
(
|
|
DateTuple("2019", "06", "05", None, None, None),
|
|
TimeTuple("01", "03", "11.858714", None),
|
|
),
|
|
),
|
|
(
|
|
"1981-04-05T23:21:28.512400Z",
|
|
(
|
|
DateTuple("1981", "04", "05", None, None, None),
|
|
TimeTuple(
|
|
"23",
|
|
"21",
|
|
"28.512400",
|
|
TimezoneTuple(False, True, None, None, "Z"),
|
|
),
|
|
),
|
|
),
|
|
(
|
|
"1981095T23:21:28.512400-12:34",
|
|
(
|
|
DateTuple("1981", None, None, None, None, "095"),
|
|
TimeTuple(
|
|
"23",
|
|
"21",
|
|
"28.512400",
|
|
TimezoneTuple(True, None, "12", "34", "-12:34"),
|
|
),
|
|
),
|
|
),
|
|
(
|
|
"19810405T23:21:28+00",
|
|
(
|
|
DateTuple("1981", "04", "05", None, None, None),
|
|
TimeTuple(
|
|
"23", "21", "28", TimezoneTuple(False, None, "00", None, "+00")
|
|
),
|
|
),
|
|
),
|
|
(
|
|
"19810405T23:21:28+00:00",
|
|
(
|
|
DateTuple("1981", "04", "05", None, None, None),
|
|
TimeTuple(
|
|
"23",
|
|
"21",
|
|
"28",
|
|
TimezoneTuple(False, None, "00", "00", "+00:00"),
|
|
),
|
|
),
|
|
),
|
|
)
|
|
|
|
for testtuple in testtuples:
|
|
with mock.patch.object(
|
|
aniso8601.time.PythonTimeBuilder, "build_datetime"
|
|
) as mockBuildDateTime:
|
|
|
|
mockBuildDateTime.return_value = testtuple[1]
|
|
|
|
result = parse_datetime(testtuple[0])
|
|
|
|
self.assertEqual(result, testtuple[1])
|
|
mockBuildDateTime.assert_called_once_with(*testtuple[1])
|
|
|
|
def test_parse_datetime_spacedelimited(self):
|
|
expectedargs = (
|
|
DateTuple("2004", None, None, "53", "6", None),
|
|
TimeTuple(
|
|
"23", "21", "28.512400", TimezoneTuple(True, None, "12", "34", "-12:34")
|
|
),
|
|
)
|
|
|
|
with mock.patch.object(
|
|
aniso8601.time.PythonTimeBuilder, "build_datetime"
|
|
) as mockBuildDateTime:
|
|
|
|
mockBuildDateTime.return_value = expectedargs
|
|
|
|
result = parse_datetime("2004-W53-6 23:21:28.512400-12:34", delimiter=" ")
|
|
|
|
self.assertEqual(result, expectedargs)
|
|
mockBuildDateTime.assert_called_once_with(*expectedargs)
|
|
|
|
def test_parse_datetime_commadelimited(self):
|
|
expectedargs = (
|
|
DateTuple("1981", "04", "05", None, None, None),
|
|
TimeTuple(
|
|
"23", "21", "28.512400", TimezoneTuple(False, True, None, None, "Z")
|
|
),
|
|
)
|
|
|
|
with mock.patch.object(
|
|
aniso8601.time.PythonTimeBuilder, "build_datetime"
|
|
) as mockBuildDateTime:
|
|
|
|
mockBuildDateTime.return_value = expectedargs
|
|
|
|
result = parse_datetime("1981-04-05,23:21:28,512400Z", delimiter=",")
|
|
|
|
self.assertEqual(result, expectedargs)
|
|
mockBuildDateTime.assert_called_once_with(*expectedargs)
|
|
|
|
def test_parse_datetime_baddelimiter(self):
|
|
testtuples = (
|
|
"1981-04-05,23:21:28,512400Z",
|
|
"2004-W53-6 23:21:28.512400-12:3",
|
|
"1981040523:21:28",
|
|
)
|
|
|
|
for testtuple in testtuples:
|
|
with self.assertRaises(ISOFormatError):
|
|
parse_datetime(testtuple, builder=None)
|
|
|
|
def test_parse_datetime_badtype(self):
|
|
testtuples = (None, 1, False, 1.234)
|
|
|
|
for testtuple in testtuples:
|
|
with self.assertRaises(ValueError):
|
|
parse_datetime(testtuple, builder=None)
|
|
|
|
def test_parse_datetime_badstr(self):
|
|
testtuples = (
|
|
"1981-04-05TA6:14:00.000123Z",
|
|
"2004-W53-6T06:14:0B",
|
|
"2014-01-230T23:21:28+00",
|
|
"201401230T01:03:11.858714",
|
|
"9999 W53T49",
|
|
"9T0000,70:24,9",
|
|
"bad",
|
|
"",
|
|
)
|
|
|
|
for testtuple in testtuples:
|
|
with self.assertRaises(ISOFormatError):
|
|
parse_datetime(testtuple, builder=None)
|
|
|
|
def test_parse_datetime_mockbuilder(self):
|
|
mockBuilder = mock.Mock()
|
|
|
|
expectedargs = (
|
|
DateTuple("1981", None, None, None, None, "095"),
|
|
TimeTuple(
|
|
"23", "21", "28.512400", TimezoneTuple(True, None, "12", "34", "-12:34")
|
|
),
|
|
)
|
|
|
|
mockBuilder.build_datetime.return_value = expectedargs
|
|
|
|
result = parse_datetime("1981095T23:21:28.512400-12:34", builder=mockBuilder)
|
|
|
|
self.assertEqual(result, expectedargs)
|
|
mockBuilder.build_datetime.assert_called_once_with(*expectedargs)
|