def test_shift_ast_ymd_with_diff_months_in_leap_and_common_years(self):
days_in_common_year_months = FAKE.random_choices(
elements=[x for x in range(200)], length=11)
days_in_leap_year_months = FAKE.random_choices(
elements=[x for x in range(200)], length=12)
days_in_common_year_months.append(30)
days_in_leap_year_months.append(31)
calendar = self.calendar_factory.build(
common_year_month_names=FAKE.words(nb=12),
days_in_common_year_months=days_in_common_year_months,
leap_year_month_names=FAKE.words(nb=13),
days_in_leap_year_months=days_in_leap_year_months,
leap_year_cycles=[4],
leap_year_cycle_start=1,
leap_year_cycle_ordinals=[4],
special_common_years=(),
special_leap_years=(),
leap_year_offset=0,
)
cd = ConvertibleDate(calendar=calendar)
plus_one_year = [[1, DateUnit.YEAR]]
sub_one_year = [[-1, DateUnit.YEAR]]
with self.session:
self.session.add(calendar)
self.session.flush()
assert cd.shift_ast_ymd((4, 13, 1), plus_one_year) == (5, 12, 1)
assert cd.shift_ast_ymd((8, 13, 1), sub_one_year) == (7, 12, 1)
assert cd.shift_ast_ymd((0, 13, 31), plus_one_year) == (1, 12, 30)
assert cd.shift_ast_ymd((-4, 13, 31), sub_one_year) == (-5, 12, 30)
def test__sanitize_weekday_names(self, patch_ss):
weekday_names, calendar, patch_ss = self.rand_cal_with_patched_ss(
patch_ss)
week_length = len(calendar.weekday_names)
new_weekday_names = FAKE.words(nb=week_length)
calendar.weekday_names = new_weekday_names
patch_ss.assert_any_call(new_weekday_names)
def test_are_valid_hour_labels(self):
hours_in_day = FAKE.random_int(min=1, max=100)
bad_hour_labels = FAKE.words(nb=hours_in_day + 1, unique=True)
ct = self.time_factory.build(
clock=self.clock_factory.build(hours_in_day=hours_in_day), )
assert ct.are_valid_hour_labels(bad_hour_labels) is False
assert ct.are_valid_hour_labels([]) is True
assert self.earth_ct.are_valid_hour_labels(["AM", "PM"]) is True
def test_common_months_constraint_with_months(self):
num_months, bad_days_in_months = self.random_bad_days_in_months()
bad_num_common_months_calendar = self.calendar_factory.build(
common_year_month_names=FAKE.words(nb=num_months),
days_in_common_year_months=bad_days_in_months,
)
with pytest.raises(IntegrityError), self.session:
self.session.add(bad_num_common_months_calendar)
self.session.commit()
def test_weekday_start_maximum_constraint(self):
week_len = FAKE.random_int(min=1)
too_big_weekday_start_calendar = self.calendar_factory.build(
weekday_names=FAKE.words(nb=week_len),
weekday_start=FAKE.random_int(min=week_len + 1, max=week_len + 99),
)
with pytest.raises(IntegrityError), self.session:
self.session.add(too_big_weekday_start_calendar)
self.session.commit()
def rand_cal_with_patched_ss(
self, patch_ss: patch
) -> tuple[tuple, "ConvertibleCalendar", patch]: # noqa: F821
"""random calendar with patched string sanitization"""
weekday_names = FAKE.words()
patch_ss.return_value = weekday_names
calendar = self.calendar_factory.build(
weekday_names=weekday_names,
epoch_weekday=0,
weekday_start=0,
weekends=(0, ),
)
return weekday_names, calendar, patch_ss
def test_labeled_hour_raises(self):
num_hour_labels = FAKE.random_int(min=1, max=20)
hours_in_day = FAKE.random_int(min=1, max=100) * num_hour_labels
clock = self.clock_factory.create(hours_in_day=hours_in_day)
no_hour_label_ct = self.time_factory.build(clock=clock,
hour_labels=list())
ct = self.time_factory.build(
clock=clock, hour_labels=FAKE.words(nb=num_hour_labels))
with pytest.raises(ValueError):
no_hour_label_ct.labeled_hour(
FAKE.random_int(min=1, max=hours_in_day - 1))
with pytest.raises(RuntimeError):
ct.labeled_hour(hours_in_day + 1)
def test_days_in_leap_year_raises(self):
num_common_months = FAKE.random_int(min=11, max=20)
num_leap_months = FAKE.random_int(min=1, max=10)
common_month_names = FAKE.words(nb=num_common_months)
days_in_common_year_months = FAKE.random_choices(
elements=list(range(11, 20)),
length=num_common_months,
)
leap_month_names = FAKE.words(nb=num_leap_months)
days_in_leap_year_months = FAKE.random_choices(
elements=list(range(1, 10)),
length=num_leap_months,
)
too_long_common_year_cal = self.calendar_factory.build(
common_year_month_names=common_month_names,
days_in_common_year_months=days_in_common_year_months,
leap_year_month_names=leap_month_names,
days_in_leap_year_months=days_in_leap_year_months,
)
with pytest.raises(AssertionError):
_ = too_long_common_year_cal.days_in_leap_year
def test_next_ast_ymd(self, *mocks):
mock_next_day = mocks[0]
mock_next_month = mocks[1]
mock_next_ast_year = mocks[2]
mock_next_era = mocks[3]
calendar = self.calendar_factory.build()
year = month = day = FAKE.random_int()
ymd = year, month, day
positive_frequency = FAKE.random_int()
negative_frequency = FAKE.random_int(min=-20, max=-1)
forward = FAKE.pybool()
cd = ConvertibleDate(calendar=calendar)
cd.next_ast_ymd(ymd, [positive_frequency, DateUnit.ERA], forward)
mock_next_era.assert_called_with(year, positive_frequency, forward)
cd.next_ast_ymd(ymd, [negative_frequency, DateUnit.ERA], forward)
mock_next_era.assert_called_with(year, negative_frequency, forward)
cd.next_ast_ymd(ymd, [positive_frequency, DateUnit.YEAR], forward)
mock_next_ast_year.assert_called_with(year, positive_frequency,
forward)
cd.next_ast_ymd(ymd, [negative_frequency, DateUnit.YEAR], forward)
mock_next_ast_year.assert_called_with(year, negative_frequency,
forward)
cd.next_ast_ymd(ymd, [positive_frequency, DateUnit.MONTH], forward)
mock_next_month.assert_called_with(year, month, positive_frequency,
forward)
cd.next_ast_ymd(ymd, [negative_frequency, DateUnit.MONTH], forward)
mock_next_month.assert_called_with(year, month, negative_frequency,
forward)
cd.next_ast_ymd(ymd, [positive_frequency, DateUnit.DAY], forward)
mock_next_day.assert_called_with(ymd, positive_frequency, forward)
cd.next_ast_ymd(ymd, [negative_frequency, DateUnit.DAY], forward)
mock_next_day.assert_called_with(ymd, negative_frequency, forward)
with pytest.raises(ValueError):
cd.next_ast_ymd(ymd, FAKE.words(nb=2))
def test__validate_weekends(self, patch_integer_sanitization):
week_length = FAKE.random_int(min=1, max=20)
good_weekends = (0, )
calendar = self.calendar_factory.build(
weekday_names=FAKE.words(week_length),
epoch_weekday=0,
weekday_start=0,
weekends=good_weekends,
)
bad_weekends = [day for day in range(week_length, week_length + 9)]
patch_integer_sanitization.assert_any_call(good_weekends)
with pytest.raises(AssertionError):
self.calendar_factory.build(
weekday_names=(),
epoch_weekday=None,
weekday_start=None,
weekends=bad_weekends,
)
with pytest.raises(AssertionError):
calendar.weekends = bad_weekends
def test_next_era(self):
num_eras = 5
era_ranges = [("-inf", FAKE.random_int())]
for _ in range(num_eras - 2):
era_ranges.append((FAKE.random_int(), FAKE.random_int()))
era_ranges.append((FAKE.random_int(), "inf"))
calendar = self.random_leapless_calendar()
calendar.eras = FAKE.words(nb=num_eras)
calendar.era_ranges = era_ranges
frequency = 2
past_era_idx = 1
past_era = calendar.eras[past_era_idx]
next_era_idx = 3
expected_hr_year = calendar.era_ranges[next_era_idx][0]
expected_ast_year = FAKE.random_int(min=-9999)
cd = ConvertibleDate(calendar=calendar)
cd.hr_to_ast = Mock()
cd.hr_to_ast.return_value = expected_ast_year
cd.era = Mock()
cd.era.return_value = past_era
# fmt: off
assert cd.next_era(FAKE.random_int(),
frequency) == (expected_ast_year, 1, 1)
# fmt: on
cd.hr_to_ast.assert_called_with(expected_hr_year, next_era_idx)
past_era_idx = num_eras - 1
past_era = calendar.eras[past_era_idx]
next_era_idx = 3
expected_hr_year = calendar.era_ranges[next_era_idx][0]
expected_ast_year = FAKE.random_int(min=-9999)
cd.hr_to_ast.return_value = expected_ast_year
cd.era.return_value = past_era
# fmt: off
assert cd.next_era(FAKE.random_int(), frequency,
forward=False) == (expected_ast_year, 1, 1)
# fmt: on
cd.hr_to_ast.assert_called_with(expected_hr_year, next_era_idx)
# next_era() when current era is the last era
past_era_idx = num_eras - 1
past_era = calendar.eras[past_era_idx]
next_era_idx = past_era_idx
expected_hr_year = calendar.era_ranges[next_era_idx][0]
expected_ast_year = FAKE.random_int(min=-9999)
cd.hr_to_ast.return_value = expected_ast_year
cd.era.return_value = past_era
# fmt: off
assert cd.next_era(FAKE.random_int(),
frequency) == (expected_ast_year, 1, 1)
# fmt: on
cd.hr_to_ast.assert_called_with(expected_hr_year, next_era_idx)
# next_era() when at proleptic era and moving backwards
with self.session:
self.session.add(calendar)
self.session.flush()
past_era_idx = 0
past_era = calendar.eras[past_era_idx]
next_era_idx = past_era_idx
expected_hr_year = calendar.era_ranges[next_era_idx][1]
expected_ast_year = FAKE.random_int(min=-9999)
expected_month = len(calendar.common_year_month_names)
expected_day = calendar.days_in_common_year_months[-1]
expected_ymd = expected_ast_year, expected_month, expected_day
cd.hr_to_ast.return_value = expected_ast_year
cd.era.return_value = past_era
assert (cd.next_era(FAKE.random_int(), frequency,
forward=False) == expected_ymd)
cd.hr_to_ast.assert_called_with(expected_hr_year, next_era_idx)
