def test26get_match_element_match_context_input_validation(self):
"""Check if an exception is raised, when other classes than MatchContext are used in get_match_element."""
model_element = DateTimeModelElement(self.id_, b"%d.%m.%Y %H:%M:%S")
data = b"07.02.2019 11:40:00: it still works"
model_element.get_match_element(self.path, DummyMatchContext(data))
model_element.get_match_element(self.path, MatchContext(data))
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, MatchElement(self.path, data, None, None))
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, data)
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, data.decode())
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, 123)
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, 123.22)
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, True)
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, None)
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, [])
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, {"key": MatchContext(data)})
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, set())
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, ())
self.assertRaises(AttributeError, model_element.get_match_element,
self.path, model_element)
def test16max_time_jump_seconds_exceeded(self):
"""
Test if the start_year is not updated, when the next date exceeds the max_time_jump_seconds.
A time inconsistency warning must occur.
"""
log_stream = StringIO()
logging.basicConfig(stream=log_stream, level=logging.INFO)
max_time_jump_seconds = 86400
start_year = 2020
match_context = DummyMatchContext(b"31.12 23:59:00: it still works")
date_time_model_element = DateTimeModelElement(
"path",
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=start_year,
max_time_jump_seconds=max_time_jump_seconds)
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1609459140)
self.assertEqual(match_context.match_string, b"31.12 23:59:00")
self.assertEqual(date_time_model_element.start_year, 2020)
match_context = DummyMatchContext(b"01.01 23:59:01: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1577923141)
self.assertEqual(match_context.match_string, b"01.01 23:59:01")
self.assertEqual(date_time_model_element.start_year, 2020)
self.assertIn(
"WARNING:DEBUG:DateTimeModelElement time inconsistencies parsing b'01.01 23:59:01', expecting value around "
"1609459140. Check your settings!", log_stream.getvalue())
for handler in logging.root.handlers[:]:
logging.root.removeHandler(handler)
initialize_loggers(self.aminer_config,
getpwnam("aminer").pw_uid,
getgrnam("aminer").gr_gid)
def test8modulo_time_match_rule(self):
"""This case unit the ModuloTimeMatchRule."""
description = "Test8Rules"
modulo_time_match_rule = ModuloTimeMatchRule(self.model_syslog_time, 86400, 43200, 86400, None)
self.analysis_context.register_component(modulo_time_match_rule, description)
date_time_model_element = DateTimeModelElement('time', b'%d.%m.%Y %H:%M:%S')
match_context = MatchContext(b'14.02.2019 13:00:00')
match_element = date_time_model_element.get_match_element(self.model_syslog, match_context)
log_atom = LogAtom(match_context.match_data, ParserMatch(match_element), time(), date_time_model_element)
self.assertTrue(modulo_time_match_rule.match(log_atom))
match_context = MatchContext(b'15.02.2019 00:00:00')
match_element = date_time_model_element.get_match_element(self.model_syslog, match_context)
log_atom = LogAtom(match_context.match_data, ParserMatch(match_element), time(), date_time_model_element)
self.assertTrue(not modulo_time_match_rule.match(log_atom))
match_context = MatchContext(b'14.02.2019 12:00:00')
match_element = date_time_model_element.get_match_element(self.model_syslog, match_context)
log_atom = LogAtom(match_context.match_data, ParserMatch(match_element), time(), date_time_model_element)
self.assertTrue(modulo_time_match_rule.match(log_atom))
match_context = MatchContext(b'15.02.2019 01:00:00')
match_element = date_time_model_element.get_match_element(self.model_syslog, match_context)
log_atom = LogAtom(match_context.match_data, ParserMatch(match_element), time(), date_time_model_element)
self.assertTrue(not modulo_time_match_rule.match(log_atom))
def test4_default_timezone(self):
"""This test case checks if the default Timezone is utc."""
match_context = MatchContext(b'07.02.2018 11:40:00')
date_time_model_element = DateTimeModelElement(
'path', b'%d.%m.%Y %H:%M:%S',
datetime.datetime.now(datetime.timezone.utc).astimezone().tzinfo)
date1 = date_time_model_element.get_match_element(
'match1', match_context).get_match_object()
match_context = MatchContext(b'07.02.2018 11:40:00')
date_time_model_element = DateTimeModelElement('path',
b'%d.%m.%Y %H:%M:%S')
date2 = date_time_model_element.get_match_element(
'match1', match_context).get_match_object()
self.assertEqual(date1 - date2, 0)
def test14learn_new_start_year_without_start_year_set(self):
"""Test if a new year is learned successfully with the start year being None."""
match_context = DummyMatchContext(b"31.12 23:59:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m %H:%M:%S",
timezone.utc)
self.assertIsNotNone(
date_time_model_element.get_match_element("match1", match_context))
self.assertEqual(match_context.match_string, b"31.12 23:59:00")
start_year = date_time_model_element.start_year
match_context = DummyMatchContext(b"01.01 11:20:00: it still works")
self.assertIsNotNone(
date_time_model_element.get_match_element("match1", match_context))
self.assertEqual(match_context.match_string, b"01.01 11:20:00")
self.assertEqual(date_time_model_element.start_year, start_year + 1)
def test3_new_year_with_start_year_value(self):
startYear = 2017
match_context = MatchContext(b'07.02.2018 11:40:00: it still works')
date_time_model_element = DateTimeModelElement('path',
b'%d.%m.%Y %H:%M:%S',
None, None, startYear)
self.assertEqual(
date_time_model_element.get_match_element(
'match1', match_context).get_match_object(), 1518003600)
match_context = MatchContext(b'07.02 11:40:00: it still works')
date_time_model_element = DateTimeModelElement('path',
b'%d.%m %H:%M:%S', None,
None, startYear)
self.assertEqual(
date_time_model_element.get_match_element(
'match1', match_context).get_match_object(), 1486467600)
def test6get_match_element_with_different_time_zones(self):
"""Test if different time_zones work with the DateTimeModelElement."""
date_time_model_element = DateTimeModelElement("path",
b"%d.%m.%Y %H:%M:%S%z",
timezone.utc)
match_context = DummyMatchContext(
b"07.02.2018 11:40:00 UTC-1200: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1518046800)
self.assertEqual(match_context.match_string,
b"07.02.2018 11:40:00 UTC-1200")
match_context = DummyMatchContext(
b"07.02.2018 11:40:00 UTC-12: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1518046800)
self.assertEqual(match_context.match_string,
b"07.02.2018 11:40:00 UTC-12")
match_context = DummyMatchContext(
b"07.02.2018 11:40:00 UTC-5: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1518021600)
self.assertEqual(match_context.match_string,
b"07.02.2018 11:40:00 UTC-5")
match_context = DummyMatchContext(
b"07.02.2018 11:40:00 UTC-0500: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1518021600)
self.assertEqual(match_context.match_string,
b"07.02.2018 11:40:00 UTC-0500")
match_context = DummyMatchContext(
b"07.02.2018 11:40:00 UTC+0000: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1518003600)
self.assertEqual(match_context.match_string,
b"07.02.2018 11:40:00 UTC+0000")
match_context = DummyMatchContext(
b"07.02.2018 11:40:00 UTC+0100: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1518000000)
self.assertEqual(match_context.match_string,
b"07.02.2018 11:40:00 UTC+0100")
match_context = DummyMatchContext(
b"07.02.2018 11:40:00 UTC+1400: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1517953200)
self.assertEqual(match_context.match_string,
b"07.02.2018 11:40:00 UTC+1400")
def test12get_match_element_without_leap_start_year(self):
"""Check if normal start_years can not parse the 29th February."""
match_context = DummyMatchContext(b"29.02 11:40:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=2019)
self.assertIsNone(
date_time_model_element.get_match_element("match1", match_context))
def test2start_year_value(self):
"""This test checks if they class is parsing dates without year values correctly."""
match_context = MatchContext(b'07.02 11:40:00: it still works')
date_time_model_element = DateTimeModelElement('path',
b'%d.%m %H:%M:%S', None,
None, 2017)
self.assertEqual(
date_time_model_element.get_match_element(
'match1', match_context).get_match_object(), 1486467600)
def test10get_match_element_without_start_year_defined(self):
"""Test if dates without year can still be parsed, even without defining the start_year."""
match_context = DummyMatchContext(b"07.02 11:40:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m %H:%M:%S",
timezone.utc)
self.assertIsNotNone(
date_time_model_element.get_match_element("match1", match_context))
self.assertEqual(match_context.match_string, b"07.02 11:40:00")
def test5_unclean_format_string(self):
"""This test case checks if unclean format_strings can be used."""
match_context = MatchContext(
b'Test 07.02.2018 11:40:00 UTC+0000: it still works')
date_time_model_element = DateTimeModelElement(
'path', b'Test %d.%m.%Y %H:%M:%S %z', datetime.timezone.utc, None,
2017)
self.assertEqual(
date_time_model_element.get_match_element(
'match1', match_context).get_match_object(), 1518003600)
self.assertEqual(match_context.match_data,
self.__expected_match_context)
match_context = MatchContext(
b'Test 07.02.2018 11:40:00 UTC-0001: it still works')
self.assertEqual(
date_time_model_element.get_match_element(
'match1', match_context).get_match_object(), 1518000000)
self.assertEqual(match_context.match_data,
self.__expected_match_context)
def test19date_before_unix_timestamps(self):
"""Check if timestamps before the unix timestamp are processed properly."""
match_context = DummyMatchContext(
b"01.01.1900 11:40:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m.%Y %H:%M:%S",
timezone.utc)
match_element = date_time_model_element.get_match_element(
"match1", match_context)
self.assertEqual(match_element.match_string, b"01.01.1900 11:40:00")
self.assertEqual(match_element.match_object, -2208946800)
def test5get_match_element_with_unclean_format_string(self):
"""This test case checks if unclean format_strings can be used."""
match_context = DummyMatchContext(
b"Date %d: 07.02.2018 11:40:00 UTC+0000: it still works")
date_time_model_element = DateTimeModelElement(
"path", b"Date %%d: %d.%m.%Y %H:%M:%S%z", timezone.utc)
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1518003600)
self.assertEqual(match_context.match_string,
b"Date %d: 07.02.2018 11:40:00 UTC+0000")
def test5get_match_element_with_unclean_format_string(self):
"""This test case checks if unclean format_strings can be used."""
data = b"Date %d: 07.02.2018 11:40:00 UTC+0000: it still works"
date = b"Date %d: 07.02.2018 11:40:00 UTC+0000"
match_context = DummyMatchContext(data)
date_time_model_element = DateTimeModelElement(
self.id_, b"Date %%d: %d.%m.%Y %H:%M:%S%z", timezone.utc)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1518003600, None)
def test18same_timestamp_multiple_times(self):
"""Test if the DateTimeModelElement can handle multiple same timestamps."""
data = b"07.02.2019 11:40:00: it still works"
date = b"07.02.2019 11:40:00"
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m.%Y %H:%M:%S",
timezone.utc)
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1549539600, None)
data = b"07.02.2019 11:40:00: it still works"
date = b"07.02.2019 11:40:00"
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1549539600, None)
def test11get_match_element_with_leap_start_year(self):
"""Check if leap start_years can parse the 29th February."""
match_context = DummyMatchContext(b"29.02 11:40:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=2020)
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1582976400)
self.assertEqual(match_context.match_string, b"29.02 11:40:00")
def test18same_timestamp_multiple_times(self):
"""Test if the DateTimeModelElement can handle multiple same timestamps."""
match_context = DummyMatchContext(
b"07.02.2019 11:40:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m.%Y %H:%M:%S",
timezone.utc)
match_element = date_time_model_element.get_match_element(
"match1", match_context)
self.assertEqual(match_element.match_string, b"07.02.2019 11:40:00")
self.assertEqual(match_element.match_object, 1549539600)
self.assertEqual(match_context.match_string, b"07.02.2019 11:40:00")
match_context = DummyMatchContext(
b"07.02.2019 11:40:00: it still works")
match_element = date_time_model_element.get_match_element(
"match1", match_context)
self.assertEqual(match_element.match_string, b"07.02.2019 11:40:00")
self.assertEqual(match_element.match_object, 1549539600)
self.assertEqual(match_context.match_string, b"07.02.2019 11:40:00")
def test13learn_new_start_year_with_start_year_set(self):
"""Test if a new year is learned successfully with the start year being set."""
start_year = 2020
match_context = DummyMatchContext(b"31.12 23:59:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=start_year)
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1609459140)
self.assertEqual(match_context.match_string, b"31.12 23:59:00")
self.assertEqual(date_time_model_element.start_year, start_year)
match_context = DummyMatchContext(b"01.01 11:20:00: it still works")
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1609500000)
self.assertEqual(match_context.match_string, b"01.01 11:20:00")
self.assertEqual(date_time_model_element.start_year, start_year + 1)
def test12get_match_element_without_leap_start_year(self):
"""Check if normal start_years can not parse the 29th February."""
data = b"29.02 11:40:00: it still works"
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=2019)
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
def test9get_match_element_with_start_year(self):
"""Test if dates without year can be parsed, when the start_year is defined."""
match_context = DummyMatchContext(b"07.02 11:40:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=2017)
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1486467600)
self.assertEqual(match_context.match_string, b"07.02 11:40:00")
match_context = DummyMatchContext(b"07.02 11:40:00: it still works")
date_time_model_element = DateTimeModelElement("path",
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=2019)
self.assertEqual(
date_time_model_element.get_match_element(
"match1", match_context).get_match_object(), 1549539600)
self.assertEqual(match_context.match_string, b"07.02 11:40:00")
def test9value_dependent_modulo_time_match_rule(self):
"""This case unit the ValueDependentModuloTimeMatchRule. Limit look up not working with tuples."""
description = "Test9Rules"
value_dependent_modulo_time_match_rule = ValueDependentModuloTimeMatchRule(self.model_syslog_time, 86400, [self.model_syslog_time],
{1550145600: [43200, 86400]})
self.analysis_context.register_component(value_dependent_modulo_time_match_rule, description)
date_time_model_element = DateTimeModelElement('time', b'%d.%m.%Y %H:%M:%S')
match_context = MatchContext(b'14.02.2019 12:00:00')
match_element = date_time_model_element.get_match_element(self.model_syslog, match_context)
log_atom = LogAtom(match_context.match_data, ParserMatch(match_element), 1550138400, date_time_model_element)
self.assertTrue(value_dependent_modulo_time_match_rule.match(log_atom))
def test14learn_new_start_year_without_start_year_set(self):
"""Test if a new year is learned successfully with the start year being None."""
data = b"31.12 23:59:00: it still works"
date = b"31.12 23:59:00"
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m %H:%M:%S",
timezone.utc)
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
dtm = datetime(datetime.now().year,
12,
31,
23,
59,
tzinfo=timezone.utc)
total_seconds = (
dtm - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, total_seconds,
None)
data = b"01.01 11:20:00: it still works"
date = b"01.01 11:20:00"
start_year = date_time_model_element.start_year
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
dtm = datetime(datetime.now().year + 1,
1,
1,
11,
20,
tzinfo=timezone.utc)
total_seconds = (
dtm - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, total_seconds,
None)
self.assertEqual(date_time_model_element.start_year, start_year + 1)
def test15max_time_jump_seconds_in_time(self):
"""
Test if the max_time_jump_seconds parameter works if the next date is in time.
Warnings with unqualified timestamp year wraparound.
"""
log_stream = StringIO()
logging.basicConfig(stream=log_stream, level=logging.INFO)
max_time_jump_seconds = 86400
start_year = 2020
date_time_model_element = DateTimeModelElement(
self.id_,
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=start_year,
max_time_jump_seconds=max_time_jump_seconds)
data = b"31.12 23:59:00: it still works"
date = b"31.12 23:59:00"
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1609459140, None)
self.assertEqual(date_time_model_element.start_year, start_year)
data = b"01.01 23:59:00: it still works"
date = b"01.01 23:59:00"
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1609545540, None)
self.assertEqual(date_time_model_element.start_year, start_year + 1)
self.assertIn(
"WARNING:DEBUG:DateTimeModelElement unqualified timestamp year wraparound detected from 2021-01-01T23:59:00+00:00 to "
"2021-01-01T23:59:00+00:00", log_stream.getvalue())
for handler in logging.root.handlers[:]:
logging.root.removeHandler(handler)
initialize_loggers(self.aminer_config,
getpwnam("aminer").pw_uid,
getgrnam("aminer").gr_gid)
def test19date_before_unix_timestamps(self):
"""Check if timestamps before the unix timestamp are processed properly."""
data = b"01.01.1900 11:40:00: it still works"
date = b"01.01.1900 11:40:00"
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m.%Y %H:%M:%S",
timezone.utc)
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, -2208946800,
None)
def test1date_formats_exceptions(self):
"""This test case verifies, if all date_format qualifiers are valid and exceptions are raised, if they are invalid."""
match_context = MatchContext(b'07.02.2019 11:40:00: it still works')
date_time_model_element = DateTimeModelElement('path',
b'%d.%m.%Y %H:%M:%S')
self.assertEqual(
date_time_model_element.get_match_element(
'match1', match_context).get_match_string(),
b'07.02.2019 11:40:00')
self.assertRaises(Exception, DateTimeModelElement, 'path', b'%h %b')
self.assertRaises(Exception, DateTimeModelElement, 'path', b'%H%H')
self.assertRaises(Exception, DateTimeModelElement, 'path', b'%H%s')
def test11get_match_element_with_leap_start_year(self):
"""Check if leap start_years can parse the 29th February."""
data = b"29.02 11:40:00: it still works"
date = b"29.02 11:40:00"
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=2020)
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1582976400, None)
def test9get_match_element_with_start_year(self):
"""Test if dates without year can be parsed, when the start_year is defined."""
data = b"07.02 11:40:00: it still works"
date = b"07.02 11:40:00"
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=2017)
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1486467600, None)
match_context = DummyMatchContext(data)
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=2019)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1549539600, None)
def test13learn_new_start_year_with_start_year_set(self):
"""Test if a new year is learned successfully with the start year being set."""
data = b"31.12 23:59:00: it still works"
date = b"31.12 23:59:00"
start_year = 2020
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m %H:%M:%S",
timezone.utc,
start_year=start_year)
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1609459140, None)
self.assertEqual(date_time_model_element.start_year, start_year)
data = b"01.01 11:20:00: it still works"
date = b"01.01 11:20:00"
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, 1609500000, None)
self.assertEqual(date_time_model_element.start_year, start_year + 1)
def test10get_match_element_without_start_year_defined(self):
"""Test if dates without year can still be parsed, even without defining the start_year."""
data = b"07.02 11:40:00: it still works"
date = b"07.02 11:40:00"
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m %H:%M:%S",
timezone.utc)
match_context = DummyMatchContext(data)
dtm = datetime(datetime.now().year, 2, 7, 11, 40, tzinfo=timezone.utc)
total_seconds = (
dtm - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_match_results(data, match_element, match_context,
self.id_, self.path, date, total_seconds,
None)
def test4wrong_date(self):
"""Test if wrong input data does not return a match."""
# wrong day
data = b"32.03.2019 11:40:00: it still works"
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m.%Y %H:%M:%S",
timezone.utc)
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
# wrong month
data = b"01.13.2019 11:40:00: it still works"
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
# wrong year
data = b"01.01.00 11:40:00: it still works"
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
# wrong date leap year
data = b"29.02.2019 11:40:00: it still works"
match_context = DummyMatchContext(data)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
# missing T
data = b"07.02.2019 11:40:00: it still works"
match_context = DummyMatchContext(data)
date_time_model_element = DateTimeModelElement(self.id_,
b"%d.%m.%YT%H:%M:%S",
timezone.utc)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)
# missing fractions
data = b"07.02.2019 11:40:00.: it still works"
match_context = DummyMatchContext(data)
date_time_model_element = DateTimeModelElement(
self.id_, b"%d.%m.%Y %H:%M:%S.%f", timezone.utc)
match_element = date_time_model_element.get_match_element(
self.path, match_context)
self.compare_no_match_results(data, match_element, match_context)