def test_fuzzydate_invalid_day_is_none(self):
d1 = fuzzydate(day=0)
self.assertIsNone(d1.day)
d2 = fuzzydate(day=32)
self.assertIsNone(d2.day)
d3 = fuzzydate(month=1, day=32)
self.assertIsNone(d3.day)
d4 = fuzzydate(month=1, day=32, year=2000)
self.assertIsNone(d4.day)
def test_fuzzydate_can_raise_error_when_date_would_be_invalid(self):
"""fuzzydate can raise an error on fuzzydate(2015, 2, 29, raise_errors=True)
2015 was not a leap year."""
with self.assertRaises(ValueError):
fuzzydate(2015, 2, 29, raise_errors=True)
fd = fuzzydate(2015, 2, 29, raise_errors=False)
self.assertIsNone(fd.day)
# 2016 was a leap year and shouldn't generate an error
fuzzydate(2016, 2, 29, raise_errors=True)
def test_fuzzydate_fillin_raises_error_when_date_would_be_invalid(self):
"""fuzzydate.fillin should raise an error when the fillin would create an invalid date."""
fd = fuzzydate(month=2, day=29)
fillin_date = date(2015, 7, 4)
with self.assertRaises(ValueError):
fd.fillin(fillin_date)
def test_fuzzydate_fillin_works_with_actual_date(self):
fd = fuzzydate(1776)
fillin_date = date(2016, 7, 4)
id4_date = fd.fillin(fillin_date)
self.assertEqual(id4_date.year, 1776)
self.assertEqual(id4_date.month, 7)
self.assertEqual(id4_date.day, 4)
def test_fuzzydate_fillin_error_on_invalid_arg(self):
"""Value given to fillin must be a date."""
fd = fuzzydate(month=2, day=29)
for invalid in (1, 'XXX', None, 1.1):
with self.subTest('Invalid fillin: {}'.format(invalid)):
with self.assertRaises(TypeError):
fd.fillin(invalid)
def test_fuzzydate_filter_non_fuzzydate(self):
for invalid in (
1,
'XXX',
None,
1.1,
date(2001, 1, 31),
fuzzydate(month=2, day=31),
):
self.assertIsNone(fuzzydate_filter(invalid, 'N d Y'))
def test_event_end_date(self):
"""Events can track their end date."""
with self.subTest('Only a end year'):
event = Event.objects.create(name='End Event', end_year=1989)
self.assertEqual(event.fuzzy_end_date, fuzzydate(year=1989))
with self.subTest('End month and year'):
event = Event.objects.create(name='Another End Event',
end_year=1989,
end_month=12)
self.assertEqual(event.fuzzy_end_date,
fuzzydate(year=1989, month=12))
with self.subTest('Full end date'):
event = Event.objects.create(name='Final End Event',
end_year=1989,
end_month=12,
end_day=13)
self.assertEqual(event.fuzzy_end_date,
fuzzydate(year=1989, month=12, day=13))
def test_event_start_date(self):
"""Events can track their start date."""
with self.subTest('Only a start year'):
event = Event.objects.create(name='Start Event', start_year=1989)
self.assertEqual(event.fuzzy_start_date, fuzzydate(year=1989))
with self.subTest('Start month and year'):
event = Event.objects.create(name='Another Start Event',
start_year=1989,
start_month=12)
self.assertEqual(event.fuzzy_start_date,
fuzzydate(year=1989, month=12))
with self.subTest('Full start date'):
event = Event.objects.create(name='Final Start Event',
start_year=1989,
start_month=12,
start_day=13)
self.assertEqual(event.fuzzy_start_date,
fuzzydate(year=1989, month=12, day=13))
def test_fuzzydate_filter_and_fuzzydate_handle_invalid_dates(self):
date_str = fuzzydate_filter(fuzzydate(month=2, day=42), 'N d Y')
self.assertEqual('Feb.', date_str)
def test_fuzzydate_filter_handles_month_day(self):
date_str = fuzzydate_filter(fuzzydate(month=12, day=31), 'N d Y')
self.assertIn('31', date_str.split())
self.assertIn('Dec.', date_str.split())
def test_fuzzydate_filter_handles_day_year(self):
date_str = fuzzydate_filter(fuzzydate(year=1997), 'N d Y')
self.assertEqual('1997', date_str)
def fuzzy_dissolution_date(self):
return fuzzydate(self.dissolution_year, self.dissolution_month, self.dissolution_day)
def fuzzy_commencement_date(self):
return fuzzydate(self.commencement_year, self.commencement_month, self.commencement_day)
def test_fuzzydate_filter_handles_month_only(self):
date_str = fuzzydate_filter(fuzzydate(month=12), 'N d Y')
self.assertEqual('Dec.', date_str)
def test_fuzzydate_can_raise_error_on_invalid_month(self):
with self.assertRaises(ValueError):
fuzzydate(month=0, raise_errors=True)
with self.assertRaises(ValueError):
fuzzydate(month=13, raise_errors=True)
def test_fuzzydate_creates_year_only_instance(self):
fd = fuzzydate(1776)
self.assertEqual(fd.year, 1776)
self.assertIsNone(fd.month)
self.assertIsNone(fd.day)
def fuzzy_end_date(self):
return fuzzydate(self.end_year, self.end_month, self.end_day)
def test_fuzzydate_can_raise_error_on_invalid_day(self):
with self.assertRaises(ValueError):
fuzzydate(day=0, raise_errors=True)
with self.assertRaises(ValueError):
fuzzydate(day=32, raise_errors=True)
def fuzzy_planned_completion_date(self):
return fuzzydate(self.planned_completion_year, self.planned_completion_month, self.planned_completion_day)
def test_repr(self):
"""fuzzydate should have a readable repr."""
self.assertEqual(repr(fuzzydate(month=1, day=31, year=2000)),
'fuzzydate(2000, 1, 31)')
def test_fuzzydate_equality(self):
"""Fuzzy dates are equal if all set values are equal."""
with self.subTest('Day'):
self.assertEqual(fuzzydate(day=10), fuzzydate(day=10))
self.assertNotEqual(fuzzydate(day=10), fuzzydate(day=1))
self.assertNotEqual(fuzzydate(month=1, day=10), fuzzydate(day=10))
with self.subTest('Month'):
self.assertEqual(fuzzydate(month=10), fuzzydate(month=10))
self.assertNotEqual(fuzzydate(month=10), fuzzydate(month=1))
self.assertNotEqual(fuzzydate(month=1, day=10), fuzzydate(month=1))
self.assertEqual(fuzzydate(month=1, day=10),
fuzzydate(month=1, day=10))
with self.subTest('Year'):
self.assertEqual(fuzzydate(year=2000), fuzzydate(year=2000))
self.assertNotEqual(fuzzydate(year=2000), fuzzydate(year=2001))
self.assertNotEqual(fuzzydate(month=1, year=2000),
fuzzydate(year=2000))
self.assertEqual(fuzzydate(month=1, year=2000),
fuzzydate(month=1, year=2000))
self.assertNotEqual(fuzzydate(month=1, year=2000),
fuzzydate(month=10, year=2000))
with self.subTest('All'):
self.assertEqual(fuzzydate(month=1, day=1, year=2000),
fuzzydate(month=1, day=1, year=2000))
self.assertNotEqual(fuzzydate(month=2, day=1, year=2000),
fuzzydate(month=1, day=1, year=2000))
self.assertNotEqual(fuzzydate(month=1, day=2, year=2000),
fuzzydate(month=1, day=1, year=2000))
self.assertNotEqual(fuzzydate(month=1, day=1, year=2000),
fuzzydate(month=1, day=1, year=2001))
self.assertNotEqual(fuzzydate(month=1, day=1, year=2000),
fuzzydate(month=1, year=2000))
def fuzzy_appeared_date(self):
return fuzzydate(self.appeared_year, self.appeared_month, self.appeared_day)
def fuzzy_founding_date(self):
return fuzzydate(self.founding_year, self.founding_month, self.founding_day)
def test_fuzzydate_invalid_day_is_none(self):
d1 = fuzzydate(day=0)
self.assertIsNone(d1.day)
d2 = fuzzydate(day=32)
self.assertIsNone(d2.day)
def test_fuzzydate_can_raise_error_when_date_would_be_invalid(self):
'''fuzzydate can raise an error on fuzzydate(2015, 2, 29, raise_errors=True) because Feb 29, 2015 was not a leap year.'''
with self.assertRaises(ValueError):
fuzzydate(2015, 2, 29, raise_errors=True)
def test_fuzzydate_invalid_month_is_none(self):
d1 = fuzzydate(month=0)
self.assertIsNone(d1.month)
d2 = fuzzydate(month=13)
self.assertIsNone(d2.month)
def test_fuzzydate_raises_error_on_invalid_day_when_raise_errors_is_true(
self):
with self.assertRaises(ValueError):
fuzzydate(2001, 1, 98, raise_errors=True)
def test_fuzzydate_sets_invalid_day_to_none(self):
fd = fuzzydate(2001, 1, 98)
self.assertIsNone(fd.day)
def fuzzy_start_date(self):
return fuzzydate(self.start_year, self.start_month, self.start_day)
def test_fuzzydate_accepts_positional_args(self):
fd = fuzzydate(1776, 7, 4)
self.assertEqual(fd.year, 1776)
self.assertEqual(fd.month, 7)
self.assertEqual(fd.day, 4)
def fuzzy_start_date(self):
return fuzzydate(self.start_year, self.start_month, self.start_day)
def test_fuzzydate_sets_invalid_month_to_none(self):
fd = fuzzydate(2001, 13, 1)
self.assertIsNone(fd.month)
def fuzzy_end_date(self):
return fuzzydate(self.end_year, self.end_month, self.end_day)
def test_fuzzydate_sets_invalid_month_and_day_to_none(self):
fd = fuzzydate(2001, 32, 86)
self.assertIsNone(fd.month)
self.assertIsNone(fd.day)
def fuzzy_founding_date(self):
return fuzzydate(self.founding_year, self.founding_month, self.founding_day)
def test_fuzzydate_filter_handles_day_only(self):
date_str = fuzzydate_filter(fuzzydate(day=31), 'N d Y')
self.assertEqual('31', date_str)
def fuzzy_dissolution_date(self):
return fuzzydate(self.dissolution_year, self.dissolution_month, self.dissolution_day)
