def test_timezone_eq(self):
aware_local = just_now(tz='Europe/Kiev')
unaware_utc = datetime.datetime.utcnow()
aware_utc = just_now()
n_aware_local = normalize_datetime(aware_local)
n_unaware_utc = normalize_datetime(unaware_utc)
n_aware_utc = normalize_datetime(aware_utc)
assert n_aware_local == n_unaware_utc == n_aware_utc
def test_start_periodical_same_time(self):
now = just_now(tz='Europe/Kiev')
start_on = now + datetime.timedelta(days=1)
start_on = start_on.replace(hour=11, minute=45)
schedule = {
'timezone': 'Europe/Kiev',
'start': {
'on': start_on,
},
'periodical': {
'repeats': 'daily',
'every': 1,
'hour': 11,
'minute': 45,
},
'stop': {
'never': True,
}
}
schedule_gen = schedule_parser(schedule)
results = [next(schedule_gen) for _ in range(3)]
assert results == [
start_on,
start_on + datetime.timedelta(days=1),
start_on + datetime.timedelta(days=2),
]
async def wrapped(*args, **kwargs):
if schedule:
for dt in schedule_parser(schedule):
now = just_now()
delay_seconds = math.ceil((dt - now).total_seconds())
await asyncio.sleep(delay_seconds)
asyncio.create_task(func(*args, **kwargs))
else:
asyncio.create_task(func(*args, **kwargs))
def test_absolute_past_day_delay(self):
now = just_now()
start_on = now + datetime.timedelta(days=-1)
schedule = {
'start': {
'on': start_on,
},
}
schedule_gen = schedule_parser(schedule)
result = next(schedule_gen)
assert result == start_on
def test_absolute_day_delay(self):
now = just_now()
start_on = now + datetime.timedelta(days=1)
schedule = {
'start': {
'on': start_on,
},
}
schedule_gen = schedule_parser(schedule)
result = next(schedule_gen)
assert (result - now).total_seconds() == 86400
def test_kiev_timezone_apply(self):
now = just_now()
start_on = now + datetime.timedelta(days=1)
schedule = {
'start': {
'on': start_on,
},
'timezone': 'Europe/Kiev',
}
schedule_gen = schedule_parser(schedule)
result = next(schedule_gen)
assert (result - now).total_seconds() == 86400
def test_yearly_periodical(self):
now = just_now()
next_year = now + relativedelta(years=+1)
schedule = {
'periodical': {
'repeats': PeriodicalUnits.YEARLY,
'every': 1,
},
}
schedule_gen = schedule_parser(schedule)
result = next(schedule_gen)
assert next_year == result
def test_weekly_periodical(self):
now = just_now()
schedule = {
'periodical': {
'repeats': PeriodicalUnits.WEEKLY,
'every': 1,
},
}
schedule_gen = schedule_parser(schedule)
results = [next(schedule_gen) for _ in range(3)]
deltas = [(x - now).total_seconds() / 7 / 24 for x in results]
assert deltas == [3600, 7200, 10800]
def test_minutely_periodical(self):
now = just_now()
schedule = {
'periodical': {
'repeats': PeriodicalUnits.MINUTELY,
'every': 1,
},
}
schedule_gen = schedule_parser(schedule)
results = [next(schedule_gen) for _ in range(3)]
deltas = [(x - now).total_seconds() for x in results]
assert deltas == [60, 120, 180]
def test_weeks_delay(self):
now = just_now()
schedule = {
'start': {
'relative_timeshift': {
'delay': 1,
'time_units': TimeUnits.WEEKS,
}
},
}
schedule_gen = schedule_parser(schedule)
result = next(schedule_gen)
assert (result - now).total_seconds() == 604800
def test_delta_with_stop(self):
now = just_now()
schedule = {
'periodical': {
'repeats': PeriodicalUnits.YEARLY,
'every': 1,
},
'stop': {
'on': now + datetime.timedelta(days=1),
'never': False
}
}
delta, _ = schedule_delta(schedule)
assert delta == 0
def test_absolute_day_with_shift_delay(self):
now = just_now()
start_on = now + datetime.timedelta(days=1)
schedule = {
'start': {
'on': start_on,
'relative_timeshift': {
'delay': 1,
'time_units': TimeUnits.SECONDS,
}
},
}
schedule_gen = schedule_parser(schedule)
result = next(schedule_gen)
assert (result - now).total_seconds() == 86401
def test_seconds_delay(self):
now = just_now()
schedule = {
'start': {
'relative_timeshift': {
'delay': 1,
'time_units': TimeUnits.SECONDS,
}
},
'stop': {
'never': True,
}
}
schedule_gen = schedule_parser(schedule)
result = next(schedule_gen)
assert (result - now).total_seconds() == 1
def test_yearly_with_stop_periodical(self):
now = just_now()
next_year = now + relativedelta(years=+1)
schedule = {
'periodical': {
'repeats': PeriodicalUnits.YEARLY,
'every': 1,
},
'stop': {
'on': now + datetime.timedelta(days=400),
'never': False
}
}
schedule_gen = schedule_parser(schedule)
result = next(schedule_gen)
assert next_year == result
with pytest.raises(StopIteration):
next(schedule_gen)
def test_weekly_with_repeats_periodical(self):
now = just_now()
start_on = now + datetime.timedelta(days=1)
schedule = {
'start': {
'on': start_on,
},
'periodical': {
'repeats': PeriodicalUnits.WEEKLY,
'every': 1,
},
'stop': {
'never': False,
'after_num_repeats': 2
}
}
schedule_gen = schedule_parser(schedule)
one_dt, two_dt = list(schedule_gen)
assert one_dt == start_on
assert (two_dt - one_dt).days == 7
def test_different_timezones(self):
now = just_now(tz=None)
start_on = now + datetime.timedelta(days=1)
kyiv_schedule = {
'start': {
'on': start_on,
},
'timezone': 'Europe/Kiev',
}
kyiv_schedule_gen = schedule_parser(kyiv_schedule)
kyiv_result = next(kyiv_schedule_gen)
warsaw_schedule = {
'start': {
'on': start_on,
},
'timezone': 'Europe/Warsaw',
}
warsaw_schedule_gen = schedule_parser(warsaw_schedule)
warsaw_result = next(warsaw_schedule_gen)
assert (warsaw_result - kyiv_result).total_seconds() == 3600
