Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
import asyncio
import json
import os
import time
import boto3
import pytest
from botocore.exceptions import ClientError
import ministack.services.scheduler as scheduler_mod
from ministack.core.responses import (
get_account_id,
get_region,
set_request_account_id,
set_request_region,
)
ENDPOINT = os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566").rstrip("/")
REGION = "us-east-1"
def _scheduler_client(region):
return boto3.client(
"scheduler",
endpoint_url=ENDPOINT,
aws_access_key_id="test",
aws_secret_access_key="test",
region_name=region,
)
@pytest.fixture(scope="module")
def scheduler():
return _scheduler_client(REGION)
@pytest.fixture(scope="module")
def cfn():
return boto3.client("cloudformation", endpoint_url=ENDPOINT,
aws_access_key_id="test", aws_secret_access_key="test",
region_name=REGION)
def _uid():
import uuid
return uuid.uuid4().hex[:8]
# ---------------------------------------------------------------------------
# Schedule Groups
# ---------------------------------------------------------------------------
def test_scheduler_default_group_exists(scheduler):
"""The 'default' group should always exist."""
resp = scheduler.get_schedule_group(Name="default")
assert resp["Name"] == "default"
assert resp["State"] == "ACTIVE"
assert "Arn" in resp
assert "schedule-group/default" in resp["Arn"]
def test_scheduler_create_get_delete_group(scheduler):
name = f"test-group-{_uid()}"
resp = scheduler.create_schedule_group(Name=name)
arn = resp["ScheduleGroupArn"]
assert f"schedule-group/{name}" in arn
# Get
resp = scheduler.get_schedule_group(Name=name)
assert resp["Name"] == name
assert resp["State"] == "ACTIVE"
assert resp["Arn"] == arn
# Delete
scheduler.delete_schedule_group(Name=name)
with pytest.raises(ClientError) as exc:
scheduler.get_schedule_group(Name=name)
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
def test_scheduler_groups_schedules_and_tags_are_region_scoped(scheduler):
west = _scheduler_client("us-west-2")
group = f"region-group-{_uid()}"
name = f"region-schedule-{_uid()}"
east_group_arn = scheduler.create_schedule_group(Name=group)["ScheduleGroupArn"]
west_group_arn = west.create_schedule_group(Name=group)["ScheduleGroupArn"]
assert east_group_arn == f"arn:aws:scheduler:us-east-1:000000000000:schedule-group/{group}"
assert west_group_arn == f"arn:aws:scheduler:us-west-2:000000000000:schedule-group/{group}"
assert [item["Arn"] for item in scheduler.list_schedule_groups(NamePrefix=group)["ScheduleGroups"]] == [
east_group_arn
]
assert [item["Arn"] for item in west.list_schedule_groups(NamePrefix=group)["ScheduleGroups"]] == [
west_group_arn
]
east_schedule_arn = scheduler.create_schedule(
Name=name,
GroupName=group,
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={
"Arn": "arn:aws:lambda:us-east-1:000000000000:function:east-target",
"RoleArn": "arn:aws:iam::000000000000:role/test",
},
)["ScheduleArn"]
west_schedule_arn = west.create_schedule(
Name=name,
GroupName=group,
ScheduleExpression="rate(2 hours)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={
"Arn": "arn:aws:lambda:us-west-2:000000000000:function:west-target",
"RoleArn": "arn:aws:iam::000000000000:role/test",
},
)["ScheduleArn"]
assert east_schedule_arn == f"arn:aws:scheduler:us-east-1:000000000000:schedule/{group}/{name}"
assert west_schedule_arn == f"arn:aws:scheduler:us-west-2:000000000000:schedule/{group}/{name}"
assert scheduler.get_schedule(Name=name, GroupName=group)["ScheduleExpression"] == "rate(1 hour)"
assert west.get_schedule(Name=name, GroupName=group)["ScheduleExpression"] == "rate(2 hours)"
assert [item["Arn"] for item in scheduler.list_schedules(GroupName=group)["Schedules"]] == [
east_schedule_arn
]
assert [item["Arn"] for item in west.list_schedules(GroupName=group)["Schedules"]] == [
west_schedule_arn
]
scheduler.tag_resource(ResourceArn=east_schedule_arn, Tags=[{"Key": "region", "Value": "east"}])
west.tag_resource(ResourceArn=west_schedule_arn, Tags=[{"Key": "region", "Value": "west"}])
assert scheduler.list_tags_for_resource(ResourceArn=east_schedule_arn)["Tags"] == [
{"Key": "region", "Value": "east"}
]
assert west.list_tags_for_resource(ResourceArn=west_schedule_arn)["Tags"] == [
{"Key": "region", "Value": "west"}
]
scheduler.update_schedule(
Name=name,
GroupName=group,
ScheduleExpression="rate(3 hours)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={
"Arn": "arn:aws:lambda:us-east-1:000000000000:function:east-target-updated",
"RoleArn": "arn:aws:iam::000000000000:role/test",
},
)
assert scheduler.get_schedule(Name=name, GroupName=group)["ScheduleExpression"] == "rate(3 hours)"
assert west.get_schedule(Name=name, GroupName=group)["ScheduleExpression"] == "rate(2 hours)"
scheduler.delete_schedule(Name=name, GroupName=group)
with pytest.raises(ClientError) as exc:
scheduler.get_schedule(Name=name, GroupName=group)
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
with pytest.raises(ClientError) as exc:
scheduler.update_schedule(
Name=name,
GroupName=group,
ScheduleExpression="rate(4 hours)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={
"Arn": "arn:aws:lambda:us-east-1:000000000000:function:missing",
"RoleArn": "arn:aws:iam::000000000000:role/test",
},
)
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
with pytest.raises(ClientError) as exc:
scheduler.delete_schedule(Name=name, GroupName=group)
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
scheduler.delete_schedule_group(Name=group)
assert west.get_schedule_group(Name=group)["Arn"] == west_group_arn
assert west.get_schedule(Name=name, GroupName=group)["Arn"] == west_schedule_arn
assert west.list_tags_for_resource(ResourceArn=west_schedule_arn)["Tags"] == [
{"Key": "region", "Value": "west"}
]
west.delete_schedule_group(Name=group)
def test_scheduler_create_duplicate_group(scheduler):
name = f"dup-group-{_uid()}"
scheduler.create_schedule_group(Name=name)
with pytest.raises(ClientError) as exc:
scheduler.create_schedule_group(Name=name)
assert exc.value.response["Error"]["Code"] == "ConflictException"
scheduler.delete_schedule_group(Name=name)
def test_scheduler_cannot_delete_default_group(scheduler):
with pytest.raises(ClientError) as exc:
scheduler.delete_schedule_group(Name="default")
assert exc.value.response["Error"]["Code"] == "ValidationException"
def test_scheduler_list_groups(scheduler):
name = f"list-group-{_uid()}"
scheduler.create_schedule_group(Name=name)
resp = scheduler.list_schedule_groups()
names = [g["Name"] for g in resp["ScheduleGroups"]]
assert "default" in names
assert name in names
scheduler.delete_schedule_group(Name=name)
def test_scheduler_list_groups_name_prefix(scheduler):
prefix = f"pfx-{_uid()}"
scheduler.create_schedule_group(Name=f"{prefix}-a")
scheduler.create_schedule_group(Name=f"{prefix}-b")
resp = scheduler.list_schedule_groups(NamePrefix=prefix)
names = [g["Name"] for g in resp["ScheduleGroups"]]
assert len(names) == 2
assert all(n.startswith(prefix) for n in names)
scheduler.delete_schedule_group(Name=f"{prefix}-a")
scheduler.delete_schedule_group(Name=f"{prefix}-b")
# ---------------------------------------------------------------------------
# Schedules — CRUD
# ---------------------------------------------------------------------------
def test_scheduler_create_get_delete_schedule(scheduler):
name = f"test-sched-{_uid()}"
resp = scheduler.create_schedule(
Name=name,
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={
"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test",
},
)
arn = resp["ScheduleArn"]
assert f"schedule/default/{name}" in arn
# Get
resp = scheduler.get_schedule(Name=name)
assert resp["Name"] == name
assert resp["GroupName"] == "default"
assert resp["ScheduleExpression"] == "rate(1 hour)"
assert resp["State"] == "ENABLED"
assert resp["FlexibleTimeWindow"]["Mode"] == "OFF"
assert resp["Target"]["Arn"] == "arn:aws:lambda:us-east-1:000000000000:function:noop"
assert resp["Target"]["RoleArn"] == "arn:aws:iam::000000000000:role/test"
assert "CreationDate" in resp
assert "LastModificationDate" in resp
# Delete
scheduler.delete_schedule(Name=name)
with pytest.raises(ClientError) as exc:
scheduler.get_schedule(Name=name)
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
def test_scheduler_create_schedule_in_custom_group(scheduler):
group = f"custom-group-{_uid()}"
name = f"sched-{_uid()}"
scheduler.create_schedule_group(Name=group)
resp = scheduler.create_schedule(
Name=name,
GroupName=group,
ScheduleExpression="cron(0 12 * * ? *)",
FlexibleTimeWindow={"Mode": "FLEXIBLE", "MaximumWindowInMinutes": 15},
Target={
"Arn": "arn:aws:sqs:us-east-1:000000000000:my-queue",
"RoleArn": "arn:aws:iam::000000000000:role/test",
"Input": '{"key":"value"}',
},
)
assert f"schedule/{group}/{name}" in resp["ScheduleArn"]
resp = scheduler.get_schedule(Name=name, GroupName=group)
assert resp["GroupName"] == group
assert resp["ScheduleExpression"] == "cron(0 12 * * ? *)"
assert resp["FlexibleTimeWindow"]["Mode"] == "FLEXIBLE"
assert resp["FlexibleTimeWindow"]["MaximumWindowInMinutes"] == 15
assert resp["Target"]["Input"] == '{"key":"value"}'
scheduler.delete_schedule(Name=name, GroupName=group)
scheduler.delete_schedule_group(Name=group)
def test_scheduler_create_duplicate_schedule(scheduler):
name = f"dup-sched-{_uid()}"
scheduler.create_schedule(
Name=name,
ScheduleExpression="rate(5 minutes)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
with pytest.raises(ClientError) as exc:
scheduler.create_schedule(
Name=name,
ScheduleExpression="rate(10 minutes)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
assert exc.value.response["Error"]["Code"] == "ConflictException"
scheduler.delete_schedule(Name=name)
def test_scheduler_delete_nonexistent_schedule(scheduler):
with pytest.raises(ClientError) as exc:
scheduler.delete_schedule(Name="nonexistent-schedule-xyz")
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
def test_scheduler_get_nonexistent_schedule(scheduler):
with pytest.raises(ClientError) as exc:
scheduler.get_schedule(Name="nonexistent-schedule-xyz")
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
# ---------------------------------------------------------------------------
# UpdateSchedule
# ---------------------------------------------------------------------------
def test_scheduler_update_schedule(scheduler):
name = f"upd-sched-{_uid()}"
scheduler.create_schedule(
Name=name,
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:old",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
State="ENABLED",
)
resp = scheduler.update_schedule(
Name=name,
ScheduleExpression="rate(30 minutes)",
FlexibleTimeWindow={"Mode": "FLEXIBLE", "MaximumWindowInMinutes": 5},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:new",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
State="DISABLED",
Description="Updated schedule",
)
assert "ScheduleArn" in resp
resp = scheduler.get_schedule(Name=name)
assert resp["ScheduleExpression"] == "rate(30 minutes)"
assert resp["State"] == "DISABLED"
assert resp["Description"] == "Updated schedule"
assert resp["Target"]["Arn"] == "arn:aws:lambda:us-east-1:000000000000:function:new"
scheduler.delete_schedule(Name=name)
def test_scheduler_update_nonexistent_schedule(scheduler):
with pytest.raises(ClientError) as exc:
scheduler.update_schedule(
Name="nonexistent-xyz",
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
# ---------------------------------------------------------------------------
# ListSchedules
# ---------------------------------------------------------------------------
def test_scheduler_list_schedules(scheduler):
prefix = f"ls-{_uid()}"
for i in range(3):
scheduler.create_schedule(
Name=f"{prefix}-{i}",
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
resp = scheduler.list_schedules(NamePrefix=prefix)
names = [s["Name"] for s in resp["Schedules"]]
assert len(names) == 3
# Each item should have abbreviated Target with just Arn
for s in resp["Schedules"]:
assert "Arn" in s["Target"]
assert "CreationDate" in s
for i in range(3):
scheduler.delete_schedule(Name=f"{prefix}-{i}")
def test_scheduler_list_schedules_filter_by_group(scheduler):
group = f"filter-group-{_uid()}"
scheduler.create_schedule_group(Name=group)
scheduler.create_schedule(
Name=f"in-group-{_uid()}", GroupName=group,
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
scheduler.create_schedule(
Name=f"in-default-{_uid()}",
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
resp = scheduler.list_schedules(GroupName=group)
assert all(s["GroupName"] == group for s in resp["Schedules"])
assert len(resp["Schedules"]) == 1
# Cleanup
scheduler.delete_schedule_group(Name=group)
def test_scheduler_list_schedules_filter_by_state(scheduler):
name_e = f"enabled-{_uid()}"
name_d = f"disabled-{_uid()}"
for n, s in [(name_e, "ENABLED"), (name_d, "DISABLED")]:
scheduler.create_schedule(
Name=n, State=s,
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
resp = scheduler.list_schedules(State="DISABLED", NamePrefix="disabled-")
assert all(s["State"] == "DISABLED" for s in resp["Schedules"])
scheduler.delete_schedule(Name=name_e)
scheduler.delete_schedule(Name=name_d)
# ---------------------------------------------------------------------------
# Schedule with at() expression
# ---------------------------------------------------------------------------
def test_scheduler_at_expression(scheduler):
name = f"at-sched-{_uid()}"
scheduler.create_schedule(
Name=name,
ScheduleExpression="at(2030-01-01T00:00:00)",
ScheduleExpressionTimezone="America/New_York",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
ActionAfterCompletion="DELETE",
)
resp = scheduler.get_schedule(Name=name)
assert resp["ScheduleExpression"] == "at(2030-01-01T00:00:00)"
assert resp["ScheduleExpressionTimezone"] == "America/New_York"
assert resp["ActionAfterCompletion"] == "DELETE"
scheduler.delete_schedule(Name=name)
# ---------------------------------------------------------------------------
# Tags
# ---------------------------------------------------------------------------
def test_scheduler_tag_schedule(scheduler):
name = f"tag-sched-{_uid()}"
resp = scheduler.create_schedule(
Name=name,
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
arn = resp["ScheduleArn"]
scheduler.tag_resource(ResourceArn=arn, Tags=[
{"Key": "env", "Value": "test"},
{"Key": "team", "Value": "platform"},
])
resp = scheduler.list_tags_for_resource(ResourceArn=arn)
tags = {t["Key"]: t["Value"] for t in resp["Tags"]}
assert tags == {"env": "test", "team": "platform"}
scheduler.untag_resource(ResourceArn=arn, TagKeys=["team"])
resp = scheduler.list_tags_for_resource(ResourceArn=arn)
tags = {t["Key"]: t["Value"] for t in resp["Tags"]}
assert tags == {"env": "test"}
scheduler.delete_schedule(Name=name)
def test_scheduler_tag_group(scheduler):
name = f"tag-group-{_uid()}"
scheduler.create_schedule_group(Name=name, Tags=[
{"Key": "env", "Value": "prod"},
])
arn = scheduler.get_schedule_group(Name=name)["Arn"]
resp = scheduler.list_tags_for_resource(ResourceArn=arn)
tags = {t["Key"]: t["Value"] for t in resp["Tags"]}
assert tags == {"env": "prod"}
scheduler.delete_schedule_group(Name=name)
# ---------------------------------------------------------------------------
# Delete group cascades to schedules
# ---------------------------------------------------------------------------
def test_scheduler_delete_group_deletes_schedules(scheduler):
group = f"cascade-group-{_uid()}"
scheduler.create_schedule_group(Name=group)
for i in range(3):
scheduler.create_schedule(
Name=f"cascade-{i}", GroupName=group,
ScheduleExpression="rate(1 hour)",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test"},
)
resp = scheduler.list_schedules(GroupName=group)
assert len(resp["Schedules"]) == 3
scheduler.delete_schedule_group(Name=group)
# Group gone
with pytest.raises(ClientError) as exc:
scheduler.get_schedule_group(Name=group)
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
# ---------------------------------------------------------------------------
# CloudFormation integration
# ---------------------------------------------------------------------------
def test_scheduler_cfn_creates_schedule(cfn, scheduler):
"""AWS::Scheduler::Schedule via CFN should be queryable via Scheduler API."""
uid = _uid()
sched_name = f"cfn-sched-{uid}"
group_name = f"cfn-group-{uid}"
template = json.dumps({
"AWSTemplateFormatVersion": "2010-09-09",
"Resources": {
"Group": {
"Type": "AWS::Scheduler::ScheduleGroup",
"Properties": {"Name": group_name},
},
"Schedule": {
"Type": "AWS::Scheduler::Schedule",
"Properties": {
"Name": sched_name,
"GroupName": group_name,
"ScheduleExpression": "rate(10 minutes)",
"FlexibleTimeWindow": {"Mode": "OFF"},
"Target": {
"Arn": "arn:aws:lambda:us-east-1:000000000000:function:cfn-target",
"RoleArn": "arn:aws:iam::000000000000:role/test",
},
},
},
},
})
stack_name = f"sched-stack-{uid}"
cfn.create_stack(StackName=stack_name, TemplateBody=template)
time.sleep(2)
stack = cfn.describe_stacks(StackName=stack_name)["Stacks"][0]
assert stack["StackStatus"] == "CREATE_COMPLETE"
# Verify via Scheduler API
resp = scheduler.get_schedule(Name=sched_name, GroupName=group_name)
assert resp["Name"] == sched_name
assert resp["GroupName"] == group_name
assert resp["ScheduleExpression"] == "rate(10 minutes)"
resp = scheduler.get_schedule_group(Name=group_name)
assert resp["Name"] == group_name
# Delete stack
cfn.delete_stack(StackName=stack_name)
time.sleep(1)
def test_scheduler_fires_at_expression_to_sqs(scheduler):
"""A standalone schedule must actually fire: an at() schedule in the near past
delivers to its SQS target within one tick of the daemon — #958."""
import datetime as _dt
sqs = boto3.client("sqs", endpoint_url=ENDPOINT, aws_access_key_id="test",
aws_secret_access_key="test", region_name=REGION)
name = f"fire-{_uid()}"
q_url = sqs.create_queue(QueueName=f"sched-target-{_uid()}")["QueueUrl"]
q_arn = sqs.get_queue_attributes(
QueueUrl=q_url, AttributeNames=["QueueArn"])["Attributes"]["QueueArn"]
past = (_dt.datetime.now(_dt.timezone.utc) - _dt.timedelta(seconds=2)).strftime("%Y-%m-%dT%H:%M:%S")
scheduler.create_schedule(
Name=name,
ScheduleExpression=f"at({past})",
FlexibleTimeWindow={"Mode": "OFF"},
Target={"Arn": q_arn, "RoleArn": "arn:aws:iam::000000000000:role/r",
"Input": "hello-from-schedule"},
)
try:
deadline = time.time() + 20
body = None
while time.time() < deadline:
msgs = sqs.receive_message(
QueueUrl=q_url, WaitTimeSeconds=1, MaxNumberOfMessages=1
).get("Messages", [])
if msgs:
body = msgs[0]["Body"]
break
assert body == "hello-from-schedule", f"schedule did not fire (body={body!r})"
finally:
try:
scheduler.delete_schedule(Name=name)
except ClientError:
pass
sqs.delete_queue(QueueUrl=q_url)
# ---------------------------------------------------------------------------
# ARN adoption, region scoping, and the firing ticker. Folded from
# test_scheduler_arn_adoption.py: these drive the scheduler module
# in-process (scheduler_mod.*) rather than through boto3.
# ---------------------------------------------------------------------------
@pytest.fixture(autouse=True)
def _reset_scheduler():
set_request_account_id("000000000000")
set_request_region("us-east-1")
scheduler_mod.reset()
scheduler_mod._schedule_last_fired.clear()
scheduler_mod._ticker_thread = None
yield
scheduler_mod.reset()
scheduler_mod._schedule_last_fired.clear()
scheduler_mod._ticker_thread = None
def _request(method, path, body=None, query=None):
payload = json.dumps(body or {}).encode()
return asyncio.run(
scheduler_mod.handle_request(method, path, {}, payload, query or {})
)
def _body(resp):
return json.loads(resp[2].decode())
def _create_schedule(group="default"):
name = f"sched-{_uid()}"
body = {
"ScheduleExpression": "rate(1 hour)",
"FlexibleTimeWindow": {"Mode": "OFF"},
"Target": {
"Arn": "arn:aws:lambda:us-east-1:000000000000:function:noop",
"RoleArn": "arn:aws:iam::000000000000:role/test",
},
}
if group != "default":
body["GroupName"] = group
resp = _request("POST", f"/schedules/{name}", body)
assert resp[0] == 200
return name, _body(resp)["ScheduleArn"]
def _create_group():
name = f"group-{_uid()}"
resp = _request("POST", f"/schedule-groups/{name}")
assert resp[0] == 200
return name, _body(resp)["ScheduleGroupArn"]
def _assert_error(resp, status, code):
assert resp[0] == status
assert _body(resp)["__type"] == code
def test_scheduler_tag_apis_accept_local_schedule_arn():
name, arn = _create_schedule()
resp = _request("POST", f"/tags/{arn}", {"Tags": [{"Key": "env", "Value": "test"}]})
assert resp[0] == 200
resp = _request("GET", f"/tags/{arn}")
assert _body(resp)["Tags"] == [{"Key": "env", "Value": "test"}]
resp = _request("DELETE", f"/tags/{arn}", query={"TagKeys": ["env"]})
assert resp[0] == 200
assert _body(_request("GET", f"/tags/{arn}"))["Tags"] == []
assert f"default/{name}" in scheduler_mod._schedules
def test_scheduler_tag_apis_accept_local_schedule_group_arn():
_name, arn = _create_group()
resp = _request("POST", f"/tags/{arn}", {"Tags": [{"Key": "team", "Value": "platform"}]})
assert resp[0] == 200
resp = _request("GET", f"/tags/{arn}")
assert _body(resp)["Tags"] == [{"Key": "team", "Value": "platform"}]
def test_scheduler_tag_apis_accept_default_schedule_group_arn():
arn = "arn:aws:scheduler:us-east-1:000000000000:schedule-group/default"
resp = _request("POST", f"/tags/{arn}", {"Tags": [{"Key": "default", "Value": "yes"}]})
assert resp[0] == 200
resp = _request("GET", f"/tags/{arn}")
assert _body(resp)["Tags"] == [{"Key": "default", "Value": "yes"}]
def test_scheduler_tag_apis_do_not_resolve_same_named_resources_from_other_region():
set_request_region("us-west-2")
_schedule_name, west_schedule_arn = _create_schedule()
_group_name, west_group_arn = _create_group()
set_request_region("us-east-1")
east_schedule_arn = west_schedule_arn.replace(":us-west-2:", ":us-east-1:")
east_group_arn = west_group_arn.replace(":us-west-2:", ":us-east-1:")
for arn in (east_schedule_arn, east_group_arn):
resp = _request("POST", f"/tags/{arn}", {"Tags": [{"Key": "env", "Value": "bad"}]})
_assert_error(resp, 404, "ResourceNotFoundException")
assert scheduler_mod._tags.get(arn) is None
assert scheduler_mod._tags.get(west_schedule_arn) is None
assert scheduler_mod._tags.get(west_group_arn) is None
def test_scheduler_ticker_dispatches_in_schedule_region_and_restores_context(monkeypatch):
from ministack.services import eventbridge
account_id = "000000000000"
name = f"ticker-{_uid()}"
key = f"default/{name}"
expected = {}
for region in ("us-east-1", "us-west-2"):
schedule_arn = f"arn:aws:scheduler:{region}:{account_id}:schedule/{key}"
target_arn = f"arn:aws:lambda:{region}:{account_id}:function:ticker-target"
expected[region] = (schedule_arn, target_arn)
scheduler_mod._schedules.set_scoped(
account_id,
region,
key,
{
"Arn": schedule_arn,
"Name": name,
"GroupName": "default",
"ScheduleExpression": "at(1970-01-01T00:00:01)",
"Target": {"Arn": target_arn},
"State": "ENABLED",
"ActionAfterCompletion": "NONE",
"CreationDate": 1,
},
)
set_request_account_id("111111111111")
set_request_region("eu-west-1")
calls = []
def _capture_target(target, event, schedule):
calls.append((get_account_id(), get_region(), target, event, schedule))
monkeypatch.setattr(eventbridge, "_invoke_target", _capture_target)
monkeypatch.setattr(scheduler_mod.time, "time", lambda: 2.0)
scheduler_mod._tick_schedules()
assert len(calls) == 2
calls_by_region = {call[1]: call for call in calls}
assert set(calls_by_region) == set(expected)
for region, (schedule_arn, target_arn) in expected.items():
dispatch_account, dispatch_region, target, event, schedule = calls_by_region[region]
assert (dispatch_account, dispatch_region) == (account_id, region)
assert target["Arn"] == target_arn
assert event["Account"] == account_id
assert event["Region"] == region
assert event["Resources"] == [schedule_arn]
assert schedule["Arn"] == schedule_arn
assert (get_account_id(), get_region()) == ("111111111111", "eu-west-1")
def test_scheduler_start_scheduler_starts_daemon_once(monkeypatch):
created_threads = []
class _FakeThread:
def __init__(self, *, target, daemon, name):
self.target = target
self.daemon = daemon
self.name = name
self.started = False
created_threads.append(self)
def start(self):
self.started = True
def is_alive(self):
return self.started
monkeypatch.setattr(scheduler_mod.threading, "Thread", _FakeThread)
scheduler_mod.start_scheduler()
scheduler_mod.start_scheduler()
assert len(created_threads) == 1
thread = created_threads[0]
assert thread.target is scheduler_mod._ticker_loop
assert thread.daemon is True
assert thread.name == "evb-scheduler-ticker"
assert thread.started is True
def test_scheduler_unknown_route_returns_validation_error():
response = _request("GET", "/unknown")
_assert_error(response, 400, "ValidationException")
@pytest.mark.parametrize(
"bad_arn, expected_status, expected_code",
[
("not-an-arn", 400, "ValidationException"),
(
"arn:aws-us-gov:scheduler:us-east-1:000000000000:schedule/default/{name}",
404,
"ResourceNotFoundException",
),
(
"arn:aws:events:us-east-1:000000000000:schedule/default/{name}",
404,
"ResourceNotFoundException",
),
(
"arn:aws:scheduler:us-east-1:111111111111:schedule/default/{name}",
404,
"ResourceNotFoundException",
),
(
"arn:aws:scheduler:us-west-2:000000000000:schedule/default/{name}",
404,
"ResourceNotFoundException",
),
(
"arn:aws:scheduler:us-east-1:000000000000:schedule/default",
404,
"ResourceNotFoundException",
),
(
"arn:aws:scheduler:us-east-1:000000000000:schedule/default/{name}/extra",
404,
"ResourceNotFoundException",
),
(
"arn:aws:scheduler:us-east-1:000000000000:rule/default/{name}",
404,
"ResourceNotFoundException",
),
(
"arn:aws:scheduler:us-east-1:000000000000:schedule/default/missing-{name}",
404,
"ResourceNotFoundException",
),
(
"arn:aws:scheduler:us-east-1:000000000000:schedule-group/missing-{name}",
404,
"ResourceNotFoundException",
),
],
)
@pytest.mark.parametrize("method", ["GET", "POST", "DELETE"])
def test_scheduler_tag_apis_reject_invalid_resource_arns_before_touching_tags(
method, bad_arn, expected_status, expected_code
):
name, good_arn = _create_schedule()
_request("POST", f"/tags/{good_arn}", {"Tags": [{"Key": "env", "Value": "good"}]})
baseline = dict(scheduler_mod._tags.get(good_arn, {}))
arn = bad_arn.format(name=name)
body = {"Tags": [{"Key": "env", "Value": "bad"}]} if method == "POST" else None
query = {"TagKeys": ["env"]} if method == "DELETE" else None
resp = _request(method, f"/tags/{arn}", body=body, query=query)
_assert_error(resp, expected_status, expected_code)
assert scheduler_mod._tags.get(good_arn, {}) == baseline
assert scheduler_mod._tags.get(arn) is None
def test_scheduler_schedule_error_messages(scheduler):
"""Real AWS (us-east-1, #2467 r2 q12/q13/q15/q16/q17): schedule messages do not name the group."""
import uuid as _uuid
group = f"msg-grp-{_uuid.uuid4().hex[:8]}"
name, missing = f"msg-{_uuid.uuid4().hex[:8]}", f"msg-missing-{_uuid.uuid4().hex[:8]}"
scheduler.create_schedule_group(Name=group)
common = {
"GroupName": group,
"ScheduleExpression": "at(2030-01-01T00:00:00)",
"FlexibleTimeWindow": {"Mode": "OFF"},
"Target": {"Arn": "arn:aws:sqs:us-east-1:000000000000:q", "RoleArn": "arn:aws:iam::000000000000:role/r"},
}
try:
scheduler.create_schedule(Name=name, **common)
calls = [
(lambda: scheduler.get_schedule(Name=missing, GroupName=group), "ResourceNotFoundException",
f"Schedule {missing} does not exist."),
(lambda: scheduler.create_schedule(Name=name, **common), "ConflictException",
f"Schedule {name} already exists."),
(lambda: scheduler.update_schedule(Name=missing, **common), "ResourceNotFoundException",
f"Schedule {missing} does not exist."),
(lambda: scheduler.delete_schedule(Name=missing, GroupName=group), "ResourceNotFoundException",
f"Schedule {missing} does not exist."),
(lambda: scheduler.get_schedule(Name=name), "ResourceNotFoundException",
f"Schedule {name} does not exist."),
]
for call, code, message in calls:
with pytest.raises(ClientError) as exc:
call()
assert exc.value.response["Error"]["Code"] == code
assert exc.value.response["Error"]["Message"] == message
finally:
scheduler.delete_schedule_group(Name=group)