def test_recurring_thread():
def job(modifiable_arg: Dict):
# Modify the variable, which should be shared with the main thread.
modifiable_arg["count"] += 1
# Since this should run in a separate thread, this shouldn't block anything.
time.sleep(5)
# Schedule the above to run every second in a separate thread, but not a separate
# process.
test_dict = {"count": 0}
schedule.every(1).seconds.do(job, test_dict)
start = time.time()
end = start + 3.5 # We want to wait just over 3 seconds
while time.time() < end:
# Launch job and wait one second
schedule.run_pending()
time.sleep(1)
# Stop all scheduled jobs
schedule.clear()
# Nothing should happen from this point, even if we sleep another while
time.sleep(2)
# The job should have run a total of 3 times and the variable should be updated.
assert test_dict == {"count": 3}
def test_once_single_call():
mock = Mock()
mock.side_effect = lambda: time.sleep(0.2)
schedule.once().do(mock)
for _ in range(10):
schedule.run_pending()
time.sleep(0.05)
mock.assert_called_once()
def test_once_single_call():
mock = Mock()
mock.side_effect = lambda: time.sleep(0.2)
schedule.once().do(mock)
assert repr(schedule.jobs[0]).startswith("Once at")
for _ in range(10):
schedule.run_pending()
time.sleep(0.05)
mock.assert_called_once()
def test_recurring_single_call():
mock = Mock()
mock.side_effect = lambda: time.sleep(0.2)
schedule.every(2).seconds.do(mock)
# Wait 2 seconds so we can run the task once
time.sleep(2)
# This loop corresponds to 0.1 seconds of total time and while there will
# be 10 calls to run_pending() the mock function should only run once
for _ in range(10):
schedule.run_pending()
time.sleep(0.01)
mock.assert_called_once()
def test_once():
def job(path: str):
print("job executed!")
path = Path(path).write_text(str(time.time()))
with tempfile.NamedTemporaryFile("r") as file:
# Schedule the above to run once, two seconds from now
start = time.time()
schedule.once(datetime.fromtimestamp(start + 2)).do(job, file.name)
assert file.readline() == ""
# We trigger this every now and then, but the job should only execute at the
# specified time.
while time.time() < start + 3:
schedule.run_pending()
time.sleep(0.05)
file.seek(0)
# Verify that the written time was within 0.1 seconds of the expected time
assert float(file.readline()) - 2 == pytest.approx(start, abs=0.1)
def test_recurring_subprocess():
def job(path: str, modifiable_arg: Dict):
path = Path(path)
# Increment number by one.
current = path.read_text() or "0"
new_number = int(current) + 1
path.write_text(str(new_number))
# Modify the variable, which should be local to this process only.
modifiable_arg["changed"] = True
# Since this should run in a separate process, this shouldn't block anything.
time.sleep(5)
with tempfile.NamedTemporaryFile("r") as file:
# Schedule the above to run every second in a subprocess.
test_dict = {}
schedule.every(1).seconds.do(job, file.name,
test_dict).tag("subprocess")
# Assert nothing has changed yet
file.readline() == "0"
start = time.time()
end = start + 3.5 # We want to wait just over 3 seconds
while time.time() < end:
# Launch job and wait one second
schedule.run_pending()
time.sleep(1)
# Stop all scheduled jobs
schedule.clear()
# Nothing should happen from this point, even if we sleep another while
time.sleep(2)
# We expect the job to have been launched 3 times, and since the sleep time
# in the job should not be blocking, the number must have increased 3 times.
file.seek(0)
assert file.readline() == "3"
assert test_dict == {} # We expect the dict to not have been changed.