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
"""
Tests for RDS Data API service emulator.
Since no real DB containers are available in CI, these tests focus on:
- API routing (requests reach the handler, not 404)
- Parameter validation (missing resourceArn, missing sql, etc.)
- Transaction lifecycle error paths
- Invalid resource ARN handling
"""
import json
import os
import urllib.request
import uuid
from types import SimpleNamespace
from unittest.mock import Mock
import boto3
import pytest
from botocore.config import Config
from botocore.exceptions import ClientError
ENDPOINT = os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566")
REGION = "us-east-1"
ACCOUNT_ID = "000000000000"
FAKE_CLUSTER_ARN = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:nonexistent-cluster"
FAKE_SECRET_ARN = f"arn:aws:secretsmanager:{REGION}:{ACCOUNT_ID}:secret:nonexistent-secret"
def _raw_post(path, body):
"""Send a raw POST to the MiniStack endpoint (bypassing boto3 since
rds-data uses REST paths like /Execute)."""
data = json.dumps(body).encode()
req = urllib.request.Request(
f"{ENDPOINT}{path}",
data=data,
headers={"Content-Type": "application/json"},
method="POST",
)
# 30s instead of 10s: under CI xdist contention the server's first
# call into _resolve_cluster triggers a lazy `from ministack.services
# import rds` whose import-time block can exceed 10s on the shared
# 2-core Linux runner. Handler itself is sub-ms once rds is loaded,
# so 30s leaves a wide margin without making real failures slow.
try:
resp = urllib.request.urlopen(req, timeout=30)
return resp.status, json.loads(resp.read())
except urllib.error.HTTPError as e:
return e.code, json.loads(e.read())
def _regional_client(service, region, access_key_id="test"):
return boto3.client(
service,
endpoint_url=ENDPOINT,
aws_access_key_id=access_key_id,
aws_secret_access_key="test",
region_name=region,
config=Config(region_name=region, retries={"mode": "standard"}),
)
# ── Routing tests ──────────────────────────────────────────
def test_execute_route_exists():
"""POST /Execute reaches the rds-data handler (not a 404)."""
status, body = _raw_post("/Execute", {})
# Should get a 400 (missing params), not 404
assert status == 400
assert "BadRequestException" in str(body) or "resourceArn" in str(body)
def test_begin_transaction_route_exists():
"""POST /BeginTransaction reaches the rds-data handler."""
status, body = _raw_post("/BeginTransaction", {})
assert status == 400
def test_commit_transaction_route_exists():
"""POST /CommitTransaction reaches the rds-data handler."""
status, body = _raw_post("/CommitTransaction", {})
assert status == 400
def test_rollback_transaction_route_exists():
"""POST /RollbackTransaction reaches the rds-data handler."""
status, body = _raw_post("/RollbackTransaction", {})
assert status == 400
def test_batch_execute_route_exists():
"""POST /BatchExecute reaches the rds-data handler."""
status, body = _raw_post("/BatchExecute", {})
assert status == 400
# ── Parameter validation ───────────────────────────────────
def test_execute_missing_resource_arn():
status, body = _raw_post("/Execute", {
"secretArn": FAKE_SECRET_ARN,
"sql": "SELECT 1",
})
assert status == 400
assert "resourceArn" in body.get("message", body.get("Message", ""))
def test_execute_missing_secret_arn():
status, body = _raw_post("/Execute", {
"resourceArn": FAKE_CLUSTER_ARN,
"sql": "SELECT 1",
})
assert status == 400
assert "secretArn" in body.get("message", body.get("Message", ""))
def test_execute_missing_sql():
status, body = _raw_post("/Execute", {
"resourceArn": FAKE_CLUSTER_ARN,
"secretArn": FAKE_SECRET_ARN,
})
assert status == 400
assert "sql" in body.get("message", body.get("Message", ""))
def test_batch_execute_missing_sql():
status, body = _raw_post("/BatchExecute", {
"resourceArn": FAKE_CLUSTER_ARN,
"secretArn": FAKE_SECRET_ARN,
})
assert status == 400
assert "sql" in body.get("message", body.get("Message", ""))
# ── Invalid ARN ────────────────────────────────────────────
def test_execute_nonexistent_cluster():
"""ExecuteStatement with a non-existent cluster ARN returns an error."""
status, body = _raw_post("/Execute", {
"resourceArn": FAKE_CLUSTER_ARN,
"secretArn": FAKE_SECRET_ARN,
"sql": "SELECT 1",
})
assert status == 400
assert "not found" in body.get("message", body.get("Message", "")).lower()
@pytest.mark.auth_contract
@pytest.mark.parametrize("operation,action,params,cluster,reason", [
("execute_statement", "ExecuteStatement", {"sql": "select 1"}, "other", None),
("batch_execute_statement", "BatchExecuteStatement", {"sql": "select 1"}, "other", None),
("begin_transaction", "BeginTransaction", {}, "other", None),
("commit_transaction", "CommitTransaction", {"transactionId": "t"}, "other", None),
("rollback_transaction", "RollbackTransaction", {"transactionId": "t"}, "other", None),
("execute_statement", "ExecuteStatement", {"sql": "select 1"}, "denied",
"with an explicit deny in an identity-based policy"),
], ids=["execute", "batch-execute", "begin", "commit", "rollback", "explicit-deny"])
def test_rds_data_authorization_contract(auth_enabled, iam_user, operation, action, params, cluster, reason):
"""An RDS Data call is authorized as rds-data:<operation> on the cluster its resourceArn names."""
name = f"rdsdata-{uuid.uuid4().hex[:8]}"
clusters = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:{name}"
user = iam_user(policy={"Version": "2012-10-17", "Statement": [
{"Effect": "Allow", "Action": ["rds-data:ExecuteStatement", "rds-data:BeginTransaction"],
"Resource": f"{clusters}-allowed"},
{"Effect": "Deny", "Action": "rds-data:ExecuteStatement", "Resource": f"{clusters}-denied"},
]})
rds = user.client("rds-data")
allowed = {"resourceArn": f"{clusters}-allowed", "secretArn": FAKE_SECRET_ARN}
for call in (lambda: rds.execute_statement(**allowed, sql="select 1"), lambda: rds.begin_transaction(**allowed)):
with pytest.raises(ClientError) as served:
call()
assert served.value.response["Error"]["Code"] == "BadRequestException"
with pytest.raises(ClientError) as exc:
getattr(rds, operation)(resourceArn=f"{clusters}-{cluster}", secretArn=FAKE_SECRET_ARN, **params)
response = exc.value.response
if not auth_enabled:
assert response["Error"]["Code"] == "BadRequestException"
return
reason = reason or f"because no identity-based policy allows the rds-data:{action} action"
assert (response["ResponseMetadata"]["HTTPStatusCode"], response["Error"]["Code"]) == (
403, "AccessDeniedException")
assert response["Error"]["Message"] == (
f"User: {user.arn} is not authorized to perform: rds-data:{action} on resource: {clusters}-{cluster} {reason}")
assert response["ResponseMetadata"]["HTTPHeaders"]["content-type"] == "application/json"
def test_rds_data_resolves_cluster_arn_by_arn_region(rds, sm):
east_rds = _regional_client("rds", "us-east-1")
west_rds = _regional_client("rds", "us-west-2")
east_data = _regional_client("rds-data", "us-east-1")
cluster_id = f"rds-data-region-{uuid.uuid4().hex[:8]}"
secret_arn = sm.create_secret(
Name=f"rds-data-region-secret-{uuid.uuid4().hex[:8]}",
SecretString='{"username":"admin","password":"testpass123"}',
)["ARN"]
try:
east_rds.create_db_cluster(
DBClusterIdentifier=cluster_id,
Engine="aurora-mysql",
EngineMode="serverless",
EnableHttpEndpoint=True,
MasterUsername="admin",
MasterUserPassword="testpass123",
)
west_rds.create_db_cluster(
DBClusterIdentifier=cluster_id,
Engine="aurora-mysql",
EngineMode="serverless",
EnableHttpEndpoint=True,
MasterUsername="admin",
MasterUserPassword="testpass123",
)
east_arn = east_rds.describe_db_clusters(DBClusterIdentifier=cluster_id)["DBClusters"][0]["DBClusterArn"]
west_arn = west_rds.describe_db_clusters(DBClusterIdentifier=cluster_id)["DBClusters"][0]["DBClusterArn"]
east_data.execute_statement(
resourceArn=west_arn,
secretArn=secret_arn,
sql="CREATE DATABASE west_only_db",
)
east_resp = east_data.execute_statement(
resourceArn=east_arn,
secretArn=secret_arn,
sql="SHOW DATABASES",
)
west_resp = east_data.execute_statement(
resourceArn=west_arn,
secretArn=secret_arn,
sql="SHOW DATABASES",
)
east_names = [r[0]["stringValue"] for r in east_resp.get("records", [])]
west_names = [r[0]["stringValue"] for r in west_resp.get("records", [])]
assert "west_only_db" not in east_names
assert "west_only_db" in west_names
finally:
for client in (east_rds, west_rds):
try:
client.delete_db_cluster(DBClusterIdentifier=cluster_id, SkipFinalSnapshot=True)
except ClientError:
pass
def test_execute_rejects_foreign_account_cluster_arn():
"""ExecuteStatement should not resolve a cluster ARN from another account."""
owner_account = "111111111111"
owner = _regional_client("rds", REGION, access_key_id=owner_account)
cluster_id = f"rds-data-foreign-account-{uuid.uuid4().hex[:8]}"
try:
cluster = owner.create_db_cluster(
DBClusterIdentifier=cluster_id,
Engine="aurora-mysql",
MasterUsername="admin",
MasterUserPassword="password123",
)["DBCluster"]
assert f":{owner_account}:" in cluster["DBClusterArn"]
status, body = _raw_post("/Execute", {
"resourceArn": cluster["DBClusterArn"],
"secretArn": FAKE_SECRET_ARN,
"sql": "SELECT 1",
})
assert status == 400
assert "not found" in body.get("message", body.get("Message", "")).lower()
finally:
try:
owner.delete_db_cluster(DBClusterIdentifier=cluster_id, SkipFinalSnapshot=True)
except ClientError:
pass
def test_cluster_id_from_arn_includes_account_region_and_resource_tail():
from ministack.services import rds_data
assert (
rds_data._cluster_id_from_arn(
"arn:aws:rds:us-east-1:000000000000:cluster:cluster-id:tail",
)
== "000000000000:us-east-1:cluster:cluster-id:tail"
)
def test_rds_data_member_lookup_uses_resource_arn_region():
from ministack.core.responses import (
get_account_id,
get_region,
set_request_account_id,
set_request_region,
)
from ministack.services import rds, rds_data
original_account = get_account_id()
original_region = get_region()
cluster_id = f"rds-data-member-{uuid.uuid4().hex[:8]}"
east_arn = f"arn:aws:rds:us-east-1:{ACCOUNT_ID}:cluster:{cluster_id}"
west_arn = f"arn:aws:rds:us-west-2:{ACCOUNT_ID}:cluster:{cluster_id}"
east_instance = {
"DBInstanceIdentifier": f"{cluster_id}-east",
"DBClusterIdentifier": cluster_id,
"DBInstanceStatus": "available",
"Engine": "aurora-mysql",
"Endpoint": {"Address": "east.example", "Port": 3306},
}
west_instance = {
"DBInstanceIdentifier": f"{cluster_id}-west",
"DBClusterIdentifier": cluster_id,
"DBInstanceStatus": "available",
"Engine": "aurora-mysql",
}
try:
set_request_account_id(ACCOUNT_ID)
rds.reset()
rds._clusters.set_scoped(
ACCOUNT_ID,
"us-east-1",
cluster_id,
{"DBClusterIdentifier": cluster_id, "DBClusterArn": east_arn, "Engine": "aurora-mysql"},
)
rds._clusters.set_scoped(
ACCOUNT_ID,
"us-west-2",
cluster_id,
{
"DBClusterIdentifier": cluster_id,
"DBClusterArn": west_arn,
"Engine": "aurora-mysql",
"EngineMode": "provisioned",
"DBClusterMembers": [{
"DBInstanceIdentifier": west_instance["DBInstanceIdentifier"],
"IsClusterWriter": True,
}],
"_shared_container_ready": True,
"_shared_endpoint": {"Address": "west.example", "Port": 3306},
"_shared_container_id": "west-shared-container",
"_shared_internal_address": "172.20.0.8",
"_shared_internal_port": 3306,
},
)
rds._instances.set_scoped(ACCOUNT_ID, "us-east-1", east_instance["DBInstanceIdentifier"], east_instance)
rds._instances.set_scoped(ACCOUNT_ID, "us-west-2", west_instance["DBInstanceIdentifier"], west_instance)
set_request_region("us-east-1")
instance, engine = rds_data._resolve_cluster(west_arn)
assert instance is west_instance
assert engine == "aurora-mysql"
assert instance["Endpoint"] == {"Address": "west.example", "Port": 3306}
assert instance["_docker_container_id"] == "west-shared-container"
assert instance["_internal_address"] == "172.20.0.8"
assert instance["_internal_port"] == 3306
finally:
rds.reset()
set_request_account_id(original_account)
set_request_region(original_region)
def test_rds_data_db_arn_lookup_rejects_foreign_account():
from ministack.core.responses import (
get_account_id,
set_request_account_id,
)
from ministack.services import rds, rds_data
original_account = get_account_id()
db_id = f"rds-data-db-{uuid.uuid4().hex[:8]}"
db_arn = f"arn:aws:rds:us-east-1:111111111111:db:{db_id}"
instance = {
"DBInstanceIdentifier": db_id,
"Engine": "aurora-mysql",
"Endpoint": {"Address": "foreign.example", "Port": 3306},
}
try:
rds.reset()
rds._instances.set_scoped("111111111111", "us-east-1", db_id, instance)
set_request_account_id(ACCOUNT_ID)
assert rds_data._resolve_cluster(db_arn) == (None, None)
finally:
rds.reset()
set_request_account_id(original_account)
def test_begin_transaction_nonexistent_cluster():
"""BeginTransaction with a non-existent cluster ARN returns an error."""
status, body = _raw_post("/BeginTransaction", {
"resourceArn": FAKE_CLUSTER_ARN,
"secretArn": FAKE_SECRET_ARN,
})
assert status == 400
assert "not found" in body.get("message", body.get("Message", "")).lower()
def test_batch_execute_nonexistent_cluster():
status, body = _raw_post("/BatchExecute", {
"resourceArn": FAKE_CLUSTER_ARN,
"secretArn": FAKE_SECRET_ARN,
"sql": "INSERT INTO t VALUES (1)",
})
assert status == 400
assert "not found" in body.get("message", body.get("Message", "")).lower()
# ── Transaction lifecycle (error paths) ────────────────────
def test_commit_missing_transaction_id():
status, body = _raw_post("/CommitTransaction", {})
assert status == 400
assert "transactionId" in body.get("message", body.get("Message", ""))
def test_rollback_missing_transaction_id():
status, body = _raw_post("/RollbackTransaction", {})
assert status == 400
assert "transactionId" in body.get("message", body.get("Message", ""))
def test_commit_nonexistent_transaction(rds, sm):
resource_arn, secret_arn = _setup_stub_cluster(rds, sm)
status, body = _raw_post("/CommitTransaction", {
"resourceArn": resource_arn,
"secretArn": secret_arn,
"transactionId": "nonexistent-txn-id",
})
assert status == 404
assert "not found" in body.get("message", body.get("Message", "")).lower()
def test_rollback_nonexistent_transaction(rds, sm):
resource_arn, secret_arn = _setup_stub_cluster(rds, sm)
status, body = _raw_post("/RollbackTransaction", {
"resourceArn": resource_arn,
"secretArn": secret_arn,
"transactionId": "nonexistent-txn-id",
})
assert status == 404
assert "not found" in body.get("message", body.get("Message", "")).lower()
# ── Invalid JSON ───────────────────────────────────────────
def test_execute_invalid_json():
"""Malformed JSON body returns BadRequestException."""
req = urllib.request.Request(
f"{ENDPOINT}/Execute",
data=b"not-json{{{",
headers={"Content-Type": "application/json"},
method="POST",
)
try:
resp = urllib.request.urlopen(req, timeout=10)
status = resp.status
body = json.loads(resp.read())
except urllib.error.HTTPError as e:
status = e.code
body = json.loads(e.read())
assert status == 400
assert "Invalid JSON" in body.get("message", body.get("Message", ""))
# ── Parameter conversion (unit tests) ─────────────────────
def test_convert_parameters_all_types():
"""_convert_parameters handles all RDS Data API value types."""
from ministack.services.rds_data import _convert_parameters
params = [
{"name": "s", "value": {"stringValue": "hello"}},
{"name": "n", "value": {"longValue": 42}},
{"name": "d", "value": {"doubleValue": 3.14}},
{"name": "b", "value": {"booleanValue": True}},
{"name": "null_val", "value": {"isNull": True}},
{"name": "blob", "value": {"blobValue": "AQID"}}, # base64 of b'\x01\x02\x03'
]
result = _convert_parameters(params)
assert result["s"] == "hello"
assert result["n"] == 42
assert result["d"] == 3.14
assert result["b"] is True
assert result["null_val"] is None
assert result["blob"] == b"\x01\x02\x03"
def test_convert_parameters_empty():
"""_convert_parameters returns empty dict for empty/None input."""
from ministack.services.rds_data import _convert_parameters
assert _convert_parameters([]) == {}
assert _convert_parameters(None) == {}
def test_convert_parameters_missing_name_skipped():
"""Parameters without a name are skipped."""
from ministack.services.rds_data import _convert_parameters
params = [
{"value": {"stringValue": "no-name"}},
{"name": "valid", "value": {"stringValue": "ok"}},
]
result = _convert_parameters(params)
assert len(result) == 1
assert result["valid"] == "ok"
def test_convert_parameters_empty_value():
"""Parameter with empty value object returns None."""
from ministack.services.rds_data import _convert_parameters
result = _convert_parameters([{"name": "x", "value": {}}])
assert result["x"] is None
def test_substitute_named_params_distinct_numeric_tokens():
""":1 and :10 are distinct placeholders, not substring shadows (#957 bug 2).
A naive substring replace of ":1" first corrupts ":10" into "<val>0". Token
matching keeps them distinct regardless of supply order."""
from ministack.services.rds_data import _substitute_named_params
params = {"1": "ONE", "10": "TEN"}
assert _substitute_named_params("SELECT :1 AS one, :10 AS ten", params) == \
"SELECT %(1)s AS one, %(10)s AS ten"
# Order of the names in the dict must not change the result.
assert _substitute_named_params("SELECT :10 AS ten, :1 AS one", {"10": "TEN", "1": "ONE"}) == \
"SELECT %(10)s AS ten, %(1)s AS one"
def test_substitute_named_params_preserves_cast_and_unknowns():
"""A ::type cast is left intact and a :word that is not a supplied parameter
passes through unchanged instead of becoming a bad placeholder."""
from ministack.services.rds_data import _substitute_named_params
assert _substitute_named_params("SELECT :val::jsonb", {"val": "{}"}) == "SELECT %(val)s::jsonb"
assert _substitute_named_params("SELECT :foo", {"bar": 1}) == "SELECT :foo"
assert _substitute_named_params("SELECT 1", {}) == "SELECT 1"
# A longer unrelated :token must not be partially eaten by a shorter param
# name. Substring replace of ":id" would corrupt ":identity"; token matching
# leaves it whole because it is not a supplied parameter.
assert _substitute_named_params("SELECT :id, :identity", {"id": 1}) == "SELECT %(id)s, :identity"
# ── Stub mode tests ────────────────────────────────────────
def _setup_stub_cluster(rds, sm):
"""Create an Aurora Serverless cluster and secret for stub testing."""
import uuid as _uuid
cluster_id = f"stub-test-{_uuid.uuid4().hex[:8]}"
rds.create_db_cluster(
DBClusterIdentifier=cluster_id,
Engine="aurora-mysql",
EngineMode="serverless",
EnableHttpEndpoint=True,
MasterUsername="admin",
MasterUserPassword="testpass123",
)
secret_arn = sm.create_secret(
Name=f"stub-secret-{_uuid.uuid4().hex[:8]}",
SecretString='{"username":"admin","password":"testpass123"}',
)["ARN"]
cluster_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:{cluster_id}"
return cluster_arn, secret_arn
def _exec(cluster_arn, secret_arn, sql):
"""Execute a SQL statement via the stub and return (status, body)."""
return _raw_post("/Execute", {
"resourceArn": cluster_arn,
"secretArn": secret_arn,
"sql": sql,
})
def _setup_stub_cluster_state():
from ministack.services import rds, rds_data, secretsmanager
cluster_id = f"stub-state-{uuid.uuid4().hex[:8]}"
secret_name = f"stub-state-secret-{uuid.uuid4().hex[:8]}"
cluster_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:{cluster_id}"
secret_arn = f"arn:aws:secretsmanager:{REGION}:{ACCOUNT_ID}:secret:{secret_name}"
rds_data.reset()
rds._clusters[cluster_id] = {
"DBClusterIdentifier": cluster_id,
"DBClusterArn": cluster_arn,
"Engine": "aurora-mysql",
"EngineMode": "serverless",
"HttpEndpointEnabled": True,
}
secretsmanager._secrets[secret_name] = {
"ARN": secret_arn,
"Name": secret_name,
"Versions": {
"v1": {
"Stages": ["AWSCURRENT"],
"SecretString": '{"username":"admin","password":"testpass123"}',
},
},
}
return cluster_id, cluster_arn, secret_name, secret_arn
@pytest.mark.parametrize(
"stored_resource_arn",
(None, "other-resource"),
ids=("bogus", "cross-resource"),
)
def test_rds_data_stub_rejects_invalid_transaction_id(stored_resource_arn):
from ministack.services import rds, rds_data, secretsmanager
cluster_id, cluster_arn, secret_name, secret_arn = _setup_stub_cluster_state()
txn_id = f"stub-invalid-txn-{uuid.uuid4().hex}"
if stored_resource_arn is not None:
rds_data._transactions[txn_id] = {
"resourceArn": f"{cluster_arn}-{stored_resource_arn}",
"conn": object(),
}
try:
status, headers, body = rds_data._execute_statement({
"resourceArn": cluster_arn,
"secretArn": secret_arn,
"transactionId": txn_id,
"sql": "CREATE DATABASE should_not_write",
})
payload = json.loads(body)
assert status == 404
assert headers["x-amzn-errortype"] == "TransactionNotFoundException"
assert payload["__type"] == "TransactionNotFoundException"
assert payload["message"] == f"Transaction {txn_id} not found"
assert "should_not_write" not in rds_data._stub_databases.get(
rds_data._cluster_id_from_arn(cluster_arn), set()
)
if stored_resource_arn is not None:
assert txn_id in rds_data._transactions
finally:
rds_data.reset()
rds._clusters.pop(cluster_id, None)
secretsmanager._secrets.pop(secret_name, None)
def test_rds_data_stub_create_and_query_databases(rds, sm):
"""CREATE DATABASE via stub, then query information_schema.schemata."""
cluster_arn, secret_arn = _setup_stub_cluster(rds, sm)
status, _ = _exec(cluster_arn, secret_arn, "CREATE DATABASE myappdb")
assert status == 200
status, body = _exec(
cluster_arn, secret_arn,
"SELECT schema_name FROM information_schema.schemata WHERE schema_name IN ('myappdb')",
)
assert status == 200
names = [r[0]["stringValue"] for r in body.get("records", [])]
assert "myappdb" in names
def test_rds_data_stub_create_and_query_users(rds, sm):
"""CREATE USER via stub, then query mysql.user."""
cluster_arn, secret_arn = _setup_stub_cluster(rds, sm)
status, _ = _exec(cluster_arn, secret_arn, "CREATE USER 'appuser'@'%' IDENTIFIED BY 'pass'")
assert status == 200
status, body = _exec(
cluster_arn, secret_arn,
"SELECT User FROM mysql.user WHERE User='appuser'",
)
assert status == 200
names = [r[0]["stringValue"] for r in body.get("records", [])]
assert "appuser" in names
def test_rds_data_stub_grant_and_show_grants(rds, sm):
"""GRANT privileges, then SHOW GRANTS FOR."""
cluster_arn, secret_arn = _setup_stub_cluster(rds, sm)
_exec(cluster_arn, secret_arn, "CREATE USER 'grantee'@'%' IDENTIFIED BY 'pass'")
status, _ = _exec(
cluster_arn, secret_arn,
"GRANT ALL PRIVILEGES ON mydb.* TO 'grantee'@'%'",
)
assert status == 200
status, body = _exec(cluster_arn, secret_arn, "SHOW GRANTS FOR 'grantee'")
assert status == 200
grants = [r[0]["stringValue"] for r in body.get("records", [])]
assert any("GRANT" in g and "grantee" in g for g in grants)
def test_rds_data_stub_show_grants_accepts_host_qualified_user():
"""The provider asks for SHOW GRANTS using the MySQL 'user'@'host' shape."""
from ministack.services import rds, rds_data, secretsmanager
cluster_id, cluster_arn, secret_name, secret_arn = _setup_stub_cluster_state()
try:
rds_data._execute_statement({
"resourceArn": cluster_arn,
"secretArn": secret_arn,
"sql": "CREATE USER 'grantee'@'%' IDENTIFIED BY 'pass'",
})
rds_data._execute_statement({
"resourceArn": cluster_arn,
"secretArn": secret_arn,
"sql": "GRANT SELECT ON appdb.* TO 'grantee'@'%'",
})
status, _headers, body = rds_data._execute_statement({
"resourceArn": cluster_arn,
"secretArn": secret_arn,
"sql": "SHOW GRANTS FOR 'grantee'@'%'",
})
payload = json.loads(body)
assert status == 200
grants = [r[0]["stringValue"] for r in payload.get("records", [])]
assert grants
assert any("GRANT" in g and "grantee" in g for g in grants)
finally:
rds._clusters.pop(cluster_id, None)
secretsmanager._secrets.pop(secret_name, None)
def test_rds_data_rejects_disabled_http_endpoint_before_stub():
from ministack.services import rds, rds_data
cluster_id = f"disabled-endpoint-{uuid.uuid4().hex[:8]}"
resource_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:{cluster_id}"
rds._clusters[cluster_id] = {
"DBClusterIdentifier": cluster_id,
"DBClusterArn": resource_arn,
"Engine": "aurora-mysql",
"EngineMode": "serverless",
"HttpEndpointEnabled": False,
}
try:
common = {
"resourceArn": resource_arn,
"secretArn": FAKE_SECRET_ARN,
}
cases = (
(rds_data._execute_statement, {"sql": "SELECT 1"}),
(rds_data._begin_transaction, {}),
(rds_data._batch_execute_statement, {"sql": "SELECT 1"}),
)
for handler, extra in cases:
status, headers, body = handler({**common, **extra})
payload = json.loads(body)
assert status == 400
assert headers["x-amzn-errortype"] == "HttpEndpointNotEnabledException"
assert payload["__type"] == "HttpEndpointNotEnabledException"
finally:
rds._clusters.pop(cluster_id, None)
def test_rds_data_member_instance_arn_honors_parent_http_endpoint_gate():
from ministack.services import rds, rds_data, secretsmanager
cluster_id, _cluster_arn, secret_name, secret_arn = _setup_stub_cluster_state()
instance_id = f"disabled-member-{uuid.uuid4().hex[:8]}"
instance_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:db:{instance_id}"
rds._clusters[cluster_id]["HttpEndpointEnabled"] = False
rds._instances[instance_id] = {
"DBInstanceIdentifier": instance_id,
"DBInstanceArn": instance_arn,
"DBClusterIdentifier": cluster_id,
"DBInstanceStatus": "available",
"Engine": "aurora-mysql",
}
try:
status, headers, body = rds_data._execute_statement({
"resourceArn": instance_arn,
"secretArn": secret_arn,
"sql": "SHOW DATABASES",
})
payload = json.loads(body)
assert status == 400
assert headers["x-amzn-errortype"] == "HttpEndpointNotEnabledException"
assert payload["__type"] == "HttpEndpointNotEnabledException"
finally:
rds._instances.pop(instance_id, None)
rds._clusters.pop(cluster_id, None)
secretsmanager._secrets.pop(secret_name, None)
@pytest.mark.parametrize(
"handler_name",
("_commit_transaction", "_rollback_transaction"),
)
def test_transaction_completion_requires_resource_and_secret_arns(handler_name):
from ministack.services import rds_data
class _Connection:
def commit(self):
pass
def rollback(self):
pass
def close(self):
pass
rds_data.reset()
txn_id = f"txn-required-arns-{uuid.uuid4().hex}"
rds_data._transactions[txn_id] = {"conn": _Connection()}
handler = getattr(rds_data, handler_name)
try:
status, _headers, body = handler({"transactionId": txn_id})
payload = json.loads(body)
assert status == 400
assert payload["__type"] == "BadRequestException"
assert "resourceArn" in payload["message"]
assert txn_id in rds_data._transactions
status, _headers, body = handler({
"transactionId": txn_id,
"resourceArn": FAKE_CLUSTER_ARN,
})
payload = json.loads(body)
assert status == 400
assert payload["__type"] == "BadRequestException"
assert "secretArn" in payload["message"]
assert txn_id in rds_data._transactions
finally:
rds_data._transactions.pop(txn_id, None)
@pytest.mark.parametrize(
"handler_name",
("_commit_transaction", "_rollback_transaction"),
)
def test_transaction_completion_honors_http_endpoint_gate(handler_name):
from ministack.services import rds, rds_data, secretsmanager
class _Connection:
def commit(self):
pass
def rollback(self):
pass
def close(self):
pass
cluster_id, cluster_arn, secret_name, secret_arn = _setup_stub_cluster_state()
rds._clusters[cluster_id]["HttpEndpointEnabled"] = False
txn_id = f"txn-disabled-endpoint-{uuid.uuid4().hex}"
rds_data._transactions[txn_id] = {"conn": _Connection()}
handler = getattr(rds_data, handler_name)
try:
status, headers, body = handler({
"transactionId": txn_id,
"resourceArn": cluster_arn,
"secretArn": secret_arn,
})
payload = json.loads(body)
assert status == 400
assert headers["x-amzn-errortype"] == "HttpEndpointNotEnabledException"
assert payload["__type"] == "HttpEndpointNotEnabledException"
assert txn_id in rds_data._transactions
finally:
rds_data._transactions.pop(txn_id, None)
rds._clusters.pop(cluster_id, None)
secretsmanager._secrets.pop(secret_name, None)
@pytest.mark.parametrize(
("handler_name", "extra", "expected_error"),
(
("_commit_transaction", {}, "NotFoundException"),
("_rollback_transaction", {}, "NotFoundException"),
(
"_execute_statement",
{"sql": "SHOW DATABASES"},
"TransactionNotFoundException",
),
(
"_batch_execute_statement",
{"sql": "SHOW DATABASES"},
"TransactionNotFoundException",
),
),
ids=("commit", "rollback", "execute", "batch"),
)
def test_transaction_is_bound_to_resource_arn(
monkeypatch,
handler_name,
extra,
expected_error,
):
from ministack.services import rds_data
class _Cursor:
rowcount = 0
description = None
def execute(self, *_args, **_kwargs):
pass
def close(self):
pass
class _Connection:
def __init__(self):
self.commits = 0
self.rollbacks = 0
def autocommit(self, _enabled):
pass
def cursor(self):
return _Cursor()
def commit(self):
self.commits += 1
def rollback(self):
self.rollbacks += 1
def close(self):
pass
cluster_a_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:txn-cluster-a"
cluster_b_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:txn-cluster-b"
instance = {
"Endpoint": {"Address": "127.0.0.1", "Port": 3306},
"_docker_container_id": "txn-test-container",
"Engine": "aurora-mysql",
}
clusters = {
cluster_a_arn: {"DBClusterIdentifier": "txn-cluster-a", "HttpEndpointEnabled": True},
cluster_b_arn: {"DBClusterIdentifier": "txn-cluster-b", "HttpEndpointEnabled": True},
}
connection = _Connection()
monkeypatch.setattr(
rds_data,
"_resolve_target",
lambda resource_arn: (instance, "aurora-mysql", clusters[resource_arn]),
)
monkeypatch.setattr(
rds_data,
"_require_secret_credentials",
lambda _secret_arn: ("admin", "password", None),
)
monkeypatch.setattr(rds_data, "_connect", lambda *_args, **_kwargs: connection)
rds_data.reset()
try:
status, _headers, body = rds_data._begin_transaction({
"resourceArn": cluster_a_arn,
"secretArn": FAKE_SECRET_ARN,
})
assert status == 200
txn_id = json.loads(body)["transactionId"]
handler = getattr(rds_data, handler_name)
status, headers, body = handler({
"resourceArn": cluster_b_arn,
"secretArn": FAKE_SECRET_ARN,
"transactionId": txn_id,
**extra,
})
payload = json.loads(body)
assert status == 404
assert headers["x-amzn-errortype"] == expected_error
assert payload["__type"] == expected_error
assert payload["message"] == f"Transaction {txn_id} not found"
assert txn_id in rds_data._transactions
assert connection.commits == 0
assert connection.rollbacks == 0
if expected_error == "TransactionNotFoundException":
rds_data._transactions.pop(txn_id)
status, headers, body = handler({
"resourceArn": cluster_a_arn,
"secretArn": FAKE_SECRET_ARN,
"transactionId": txn_id,
**extra,
})
payload = json.loads(body)
assert status == 404
assert headers["x-amzn-errortype"] == "TransactionNotFoundException"
assert payload["__type"] == "TransactionNotFoundException"
assert payload["message"] == f"Transaction {txn_id} not found"
finally:
rds_data.reset()
def test_rds_data_rejects_missing_secret_before_password_fallback():
from ministack.services import rds, rds_data
cluster_id, cluster_arn, secret_name, _secret_arn = _setup_stub_cluster_state()
try:
status, headers, body = rds_data._execute_statement({
"resourceArn": cluster_arn,
"secretArn": FAKE_SECRET_ARN,
"sql": "CREATE DATABASE should_not_write",
})
payload = json.loads(body)
assert status == 400
assert headers["x-amzn-errortype"] == "SecretsErrorException"
assert payload["__type"] == "SecretsErrorException"
assert "secret" in payload["message"].lower()
finally:
rds._clusters.pop(cluster_id, None)
from ministack.services import secretsmanager
secretsmanager._secrets.pop(secret_name, None)
def test_rds_data_rejects_secret_without_password_before_password_fallback():
from ministack.services import rds, rds_data, secretsmanager
cluster_id, cluster_arn, secret_name, secret_arn = _setup_stub_cluster_state()
secretsmanager._secrets[secret_name]["Versions"]["v1"]["SecretString"] = '{"username":"admin"}'
try:
status, headers, body = rds_data._execute_statement({
"resourceArn": cluster_arn,
"secretArn": secret_arn,
"sql": "CREATE DATABASE should_not_write",
})
payload = json.loads(body)
assert status == 400
assert headers["x-amzn-errortype"] == "InvalidSecretException"
assert payload["__type"] == "InvalidSecretException"
assert "password" in payload["message"].lower()
finally:
rds._clusters.pop(cluster_id, None)
secretsmanager._secrets.pop(secret_name, None)
def test_rds_data_rejects_secret_scheduled_for_deletion():
from ministack.services import rds, rds_data, secretsmanager
cluster_id, cluster_arn, secret_name, secret_arn = _setup_stub_cluster_state()
secretsmanager._secrets[secret_name]["DeletedDate"] = "2026-08-10T00:00:00Z"
try:
status, headers, body = rds_data._execute_statement({
"resourceArn": cluster_arn,
"secretArn": secret_arn,
"sql": "SHOW DATABASES",
})
payload = json.loads(body)
assert status == 400
assert headers["x-amzn-errortype"] == "SecretsErrorException"
assert payload["__type"] == "SecretsErrorException"
assert "scheduled for deletion" in payload["message"]
finally:
rds._clusters.pop(cluster_id, None)
secretsmanager._secrets.pop(secret_name, None)
def test_rds_data_stub_rejects_unrecognized_sql():
from ministack.services import rds, rds_data, secretsmanager
cluster_id, cluster_arn, secret_name, secret_arn = _setup_stub_cluster_state()
try:
status, _headers, body = rds_data._execute_statement({
"resourceArn": cluster_arn,
"secretArn": secret_arn,
"sql": "SELECT definitely_unmodeled()",
})
payload = json.loads(body)
assert status == 400
assert payload["__type"] == "BadRequestException"
assert "unsupported" in payload["message"].lower()
finally:
rds._clusters.pop(cluster_id, None)
secretsmanager._secrets.pop(secret_name, None)
def test_rds_data_stub_drop_database(rds, sm):
"""CREATE then DROP DATABASE, verify gone from queries."""
cluster_arn, secret_arn = _setup_stub_cluster(rds, sm)
_exec(cluster_arn, secret_arn, "CREATE DATABASE dropme")
_exec(cluster_arn, secret_arn, "DROP DATABASE dropme")
status, body = _exec(
cluster_arn, secret_arn,
"SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'dropme'",
)
assert status == 200
names = [r[0]["stringValue"] for r in body.get("records", [])]
assert "dropme" not in names
def test_rds_data_stub_drop_user(rds, sm):
"""CREATE then DROP USER, verify gone from queries."""
cluster_arn, secret_arn = _setup_stub_cluster(rds, sm)
_exec(cluster_arn, secret_arn, "CREATE USER 'tempuser'@'%' IDENTIFIED BY 'pass'")
_exec(cluster_arn, secret_arn, "DROP USER 'tempuser'@'%'")
status, body = _exec(
cluster_arn, secret_arn,
"SELECT User FROM mysql.user WHERE User='tempuser'",
)
assert status == 200
# Should return no records (empty records list from _stub_success)
records = body.get("records", [])
names = [r[0]["stringValue"] for r in records] if records else []
assert "tempuser" not in names
def test_rds_data_real_endpoint_connection_failure_is_transient(monkeypatch):
"""Endpoint-backed clusters must not acknowledge writes through stub mode."""
from ministack.services import rds_data
rds_data.reset()
resource_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:real-cluster"
instance = {
"Endpoint": {"Address": "10.0.0.10", "Port": 3306},
"_docker_container_id": "container-id",
"Engine": "aurora-mysql",
}
cluster = {
"DBClusterIdentifier": "real-cluster",
"DBClusterArn": resource_arn,
"HttpEndpointEnabled": True,
}
monkeypatch.setattr(
rds_data,
"_resolve_target",
lambda _arn: (instance, "aurora-mysql", cluster),
)
monkeypatch.setattr(rds_data, "_require_secret_credentials", lambda _arn: ("admin", "pw", None))
def _raise_connection_error(*_args, **_kwargs):
raise OSError("Connection refused")
monkeypatch.setattr(rds_data, "_connect", _raise_connection_error)
status, headers, body = rds_data._execute_statement({
"resourceArn": resource_arn,
"secretArn": FAKE_SECRET_ARN,
"sql": "CREATE USER 'lost_write'@'%' IDENTIFIED BY 'pw'",
})
payload = json.loads(body)
assert status == 504
assert headers["x-amzn-errortype"] == "DatabaseUnavailableException"
assert payload["__type"] == "DatabaseUnavailableException"
assert "lost_write" not in rds_data._stub_users.get("real-cluster", set())
def test_rds_data_provisioned_cluster_without_members_is_unavailable():
"""An empty provisioned cluster exists but has no SQL compute."""
from ministack.services import rds, rds_data
cluster_id = f"empty-provisioned-{uuid.uuid4().hex[:8]}"
resource_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:{cluster_id}"
rds._clusters[cluster_id] = {
"DBClusterIdentifier": cluster_id,
"DBClusterArn": resource_arn,
"Engine": "aurora-mysql",
"EngineMode": "provisioned",
"HttpEndpointEnabled": True,
"Status": "available",
"DBClusterMembers": [],
"_shared_container_ready": False,
}
try:
assert rds_data._resolve_cluster(resource_arn) == (None, "aurora-mysql")
common = {
"resourceArn": resource_arn,
"secretArn": FAKE_SECRET_ARN,
}
cases = (
(rds_data._execute_statement, {"sql": "SELECT 1"}),
(rds_data._begin_transaction, {}),
(rds_data._batch_execute_statement, {"sql": "SELECT 1"}),
)
for handler, extra in cases:
status, headers, body = handler({**common, **extra})
payload = json.loads(body)
assert status == 504
assert headers["x-amzn-errortype"] == "DatabaseUnavailableException"
assert payload["__type"] == "DatabaseUnavailableException"
assert "no available DB instances" in payload["message"]
finally:
rds._clusters.pop(cluster_id, None)
@pytest.mark.parametrize(
("handler_name", "extra"),
(
("_execute_statement", {"sql": "SHOW DATABASES"}),
("_begin_transaction", {}),
("_batch_execute_statement", {"sql": "SHOW DATABASES"}),
),
ids=("execute", "begin", "batch"),
)
def test_rds_data_disabled_endpoint_precedes_missing_compute(handler_name, extra):
from ministack.services import rds, rds_data
cluster_id = f"disabled-empty-provisioned-{uuid.uuid4().hex[:8]}"
resource_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:{cluster_id}"
rds._clusters[cluster_id] = {
"DBClusterIdentifier": cluster_id,
"DBClusterArn": resource_arn,
"Engine": "aurora-mysql",
"EngineMode": "provisioned",
"HttpEndpointEnabled": False,
"Status": "available",
"DBClusterMembers": [],
"_shared_container_ready": False,
}
try:
handler = getattr(rds_data, handler_name)
status, headers, body = handler({
"resourceArn": resource_arn,
"secretArn": FAKE_SECRET_ARN,
**extra,
})
payload = json.loads(body)
assert status == 400
assert headers["x-amzn-errortype"] == "HttpEndpointNotEnabledException"
assert payload["__type"] == "HttpEndpointNotEnabledException"
finally:
rds._clusters.pop(cluster_id, None)
def test_rds_data_non_container_endpoint_keeps_stub_mode(monkeypatch):
"""Control-plane-only instances still use the lightweight SQL stub."""
from ministack.services import rds_data
rds_data.reset()
resource_arn = f"arn:aws:rds:{REGION}:{ACCOUNT_ID}:cluster:stub-cluster"
instance = {
"Endpoint": {"Address": "localhost", "Port": 3306},
"_docker_container_id": None,
"Engine": "aurora-mysql",
}
cluster = {
"DBClusterIdentifier": "stub-cluster",
"DBClusterArn": resource_arn,
"HttpEndpointEnabled": True,
}
monkeypatch.setattr(
rds_data,
"_resolve_target",
lambda _arn: (instance, "aurora-mysql", cluster),
)
monkeypatch.setattr(rds_data, "_require_secret_credentials", lambda _arn: ("admin", "pw", None))
status, _headers, body = rds_data._execute_statement({
"resourceArn": resource_arn,
"secretArn": FAKE_SECRET_ARN,
"sql": "CREATE USER 'stub_user'@'%' IDENTIFIED BY 'pw'",
})
payload = json.loads(body)
assert status == 200
assert payload["records"] == []
assert "stub_user" in rds_data._stub_users.get(
rds_data._cluster_id_from_arn(resource_arn),
set(),
)
def test_rds_data_lock_wait_timeout_is_not_connection_error():
"""MySQL lock wait timeout is a SQL error, not endpoint unavailability."""
from ministack.services import rds_data
error = Exception("(1205, 'Lock wait timeout exceeded; try restarting transaction')")
assert not rds_data._is_connection_error(error)
status, headers, body = rds_data._sql_execution_error(error)
payload = json.loads(body)
assert status == 400
assert headers["x-amzn-errortype"] == "BadRequestException"
assert payload["__type"] == "BadRequestException"
assert payload["message"].startswith("Database error:")
def test_rds_cluster_status_tracks_member_readiness():
"""Parent clusters remain creating until their member instance is available."""
from ministack.services import rds
cluster_id = "readiness-cluster"
instance_id = "readiness-instance"
rds._clusters[cluster_id] = {
"DBClusterIdentifier": cluster_id,
"Status": "available",
"DBClusterMembers": [],
}
rds._instances[instance_id] = {
"DBInstanceIdentifier": instance_id,
"DBClusterIdentifier": cluster_id,
"DBInstanceStatus": "creating",
"PromotionTier": 1,
}
try:
rds._register_instance_in_cluster(rds._instances[instance_id])
assert rds._clusters[cluster_id]["Status"] == "creating"
rds._instances[instance_id]["DBInstanceStatus"] = "available"
rds._refresh_cluster_status(cluster_id)
assert rds._clusters[cluster_id]["Status"] == "available"
finally:
rds._instances.pop(instance_id, None)
rds._clusters.pop(cluster_id, None)
def test_rds_cluster_endpoints_sync_to_shared_container():
"""Aurora cluster endpoints track the cluster-owned shared container."""
from ministack.services import rds
cluster_id = "endpoint-sync-cluster"
instance_id = "endpoint-sync-instance"
rds._clusters[cluster_id] = {
"DBClusterIdentifier": cluster_id,
"Status": "available",
"Endpoint": "original.cluster.local",
"ReaderEndpoint": "original-ro.cluster.local",
"Port": 3306,
"DBClusterMembers": [],
"_shared_endpoint": {
"Address": "10.0.0.15",
"Port": 3307,
},
}
rds._instances[instance_id] = {
"DBInstanceIdentifier": instance_id,
"DBClusterIdentifier": cluster_id,
"DBInstanceStatus": "available",
"Endpoint": {
"Address": "10.0.0.12",
"Port": 3306,
},
"PromotionTier": 1,
}
try:
rds._register_instance_in_cluster(rds._instances[instance_id])
cluster = rds._clusters[cluster_id]
assert cluster["Endpoint"] == "10.0.0.15"
assert cluster["ReaderEndpoint"] == "10.0.0.15"
assert cluster["Port"] == 3307
finally:
rds._instances.pop(instance_id, None)
rds._clusters.pop(cluster_id, None)
def test_rds_data_secret_credentials_parsing():
"""_get_secret_credentials extracts username and password from secret."""
from ministack.core.responses import set_request_account_id, set_request_region
from ministack.services import rds_data, secretsmanager
set_request_account_id("000000000000")
set_request_region("us-east-1")
# Create a secret with JSON credentials
secretsmanager._secrets["test-cred-secret"] = {
"ARN": "arn:aws:secretsmanager:us-east-1:000000000000:secret:test-cred",
"Name": "test-cred-secret",
"Versions": {
"v1": {
"Stages": ["AWSCURRENT"],
"SecretString": '{"username":"app_rw","password":"p@ss123"}',
}
},
}
user, pw = rds_data._get_secret_credentials(
"arn:aws:secretsmanager:us-east-1:000000000000:secret:test-cred")
assert user == "app_rw"
assert pw == "p@ss123"
# Clean up
del secretsmanager._secrets["test-cred-secret"]
def test_rds_data_secret_credentials_no_username():
"""_get_secret_credentials returns None username for password-only secret."""
from ministack.core.responses import set_request_account_id, set_request_region
from ministack.services import rds_data, secretsmanager
set_request_account_id("000000000000")
set_request_region("us-east-1")
secretsmanager._secrets["pw-only-secret"] = {
"ARN": "arn:aws:secretsmanager:us-east-1:000000000000:secret:pw-only",
"Name": "pw-only-secret",
"Versions": {
"v1": {
"Stages": ["AWSCURRENT"],
"SecretString": '{"password":"just-a-password"}',
}
},
}
user, pw = rds_data._get_secret_credentials(
"arn:aws:secretsmanager:us-east-1:000000000000:secret:pw-only")
assert user is None
assert pw == "just-a-password"
del secretsmanager._secrets["pw-only-secret"]
def test_rds_data_secret_credentials_use_secret_arn_region():
"""_get_secret_credentials resolves ARN-scoped secrets outside the request region."""
from ministack.core.responses import get_region, set_request_account_id, set_request_region
from ministack.services import rds_data, secretsmanager
original_region = get_region()
set_request_account_id("test")
set_request_region("us-east-1")
secretsmanager._secrets["cross-region-cred"] = {
"ARN": "arn:aws:secretsmanager:us-east-1:000000000000:secret:cross-region-cred",
"Name": "cross-region-cred",
"Versions": {
"v1": {
"Stages": ["AWSCURRENT"],
"SecretString": '{"username":"app_rw","password":"p@ss123"}',
}
},
}
try:
set_request_region("us-west-2")
user, pw = rds_data._get_secret_credentials(
"arn:aws:secretsmanager:us-east-1:000000000000:secret:cross-region-cred"
)
assert user == "app_rw"
assert pw == "p@ss123"
finally:
set_request_region("us-east-1")
secretsmanager._secrets.pop("cross-region-cred", None)
set_request_region(original_region)
def test_rds_data_secret_credentials_reject_cross_account_secret_arn():
from ministack.core.responses import (
get_account_id,
get_region,
set_request_account_id,
set_request_region,
)
from ministack.services import rds_data, secretsmanager
original_account = get_account_id()
original_region = get_region()
set_request_account_id("000000000000")
set_request_region("us-east-1")
secretsmanager._secrets.set_scoped("111111111111", "us-east-1", "cross-account-cred", {
"ARN": "arn:aws:secretsmanager:us-east-1:111111111111:secret:cross-account-cred",
"Name": "cross-account-cred",
"Versions": {
"v1": {
"Stages": ["AWSCURRENT"],
"SecretString": '{"username":"app_rw","password":"p@ss123"}',
}
},
})
try:
assert rds_data._get_secret_credentials(
"arn:aws:secretsmanager:us-east-1:111111111111:secret:cross-account-cred"
) == (None, None)
finally:
secretsmanager._secrets.pop_scoped("111111111111", "us-east-1", "cross-account-cred", None)
set_request_account_id(original_account)
set_request_region(original_region)
def test_rds_data_stub_state_is_region_isolated():
"""The stub SQL-tracking stores must isolate by region: a database recorded
against a cluster in us-east-1 must not be visible in us-west-2."""
import ministack.services.rds_data as rd
from ministack.core.responses import (
get_account_id,
get_region,
set_request_account_id,
set_request_region,
)
original_account = get_account_id()
original_region = get_region()
try:
set_request_account_id("000000000000")
set_request_region("us-east-1")
rd._stub_databases.setdefault("iso-cluster", set()).add("db_east")
set_request_region("us-west-2")
assert "iso-cluster" not in rd._stub_databases
rd._stub_databases.setdefault("iso-cluster", set()).add("db_west")
assert rd._stub_databases.get("iso-cluster") == {"db_west"}
set_request_region("us-east-1")
assert rd._stub_databases.get("iso-cluster") == {"db_east"}
finally:
set_request_region("us-east-1")
rd._stub_databases.pop("iso-cluster", None)
set_request_region("us-west-2")
rd._stub_databases.pop("iso-cluster", None)
set_request_account_id(original_account)
set_request_region(original_region)
# ---------------------------------------------------------------------------
# numberOfRecordsUpdated: PostgreSQL reports returned rows in cursor.rowcount
# for SELECT, so the command tag decides. Measured on PostgreSQL 16:
# "SELECT 3" for a 3-row select, "INSERT 0 1" even with RETURNING.
# ---------------------------------------------------------------------------
_PG_ENGINES = ("postgres", "aurora-postgresql")
_MYSQL_ENGINES = ("mysql", "aurora-mysql", "mariadb")
def _execute_with_cursor(monkeypatch, engine, rowcount, status=None, rows=None,
sql="SELECT 1", with_status=True, lastrowid=0):
"""Run _execute_statement against a stubbed driver cursor."""
from ministack.services import rds_data
cursor = SimpleNamespace(
rowcount=rowcount, lastrowid=lastrowid,
description=([("value", 23, None, None, None, None, None)]
if rows is not None else None),
execute=Mock(), fetchall=Mock(return_value=rows), close=Mock(),
)
if with_status:
cursor.statusmessage = status
connection = Mock()
connection.cursor.return_value = cursor
monkeypatch.setattr(rds_data, "_resolve_target",
lambda _arn: ({"DBInstanceIdentifier": "unit"}, engine, {}))
monkeypatch.setattr(rds_data, "_validate_http_endpoint_enabled", lambda *_a, **_k: None)
monkeypatch.setattr(rds_data, "_require_secret_credentials",
lambda _arn: ("user", "password", None))
monkeypatch.setattr(rds_data, "_has_real_endpoint", lambda *_a, **_k: True)
monkeypatch.setattr(rds_data, "_connect", lambda *_a, **_k: connection)
status_code, _headers, body = rds_data._execute_statement({
"resourceArn": "resource", "secretArn": "secret", "sql": sql,
"includeResultMetadata": True,
})
assert status_code == 200, body
cursor.execute.assert_called_once_with(sql, None)
cursor.close.assert_called_once()
connection.close.assert_called_once()
return json.loads(body)
@pytest.mark.parametrize("engine", _PG_ENGINES)
@pytest.mark.parametrize("rows", ([], [(1,)], [(1,), (2,)]), ids=("none", "one", "two"))
def test_rds_data_pg_select_reports_no_updated_records(monkeypatch, engine, rows):
"""A SELECT updates nothing, whatever psycopg2 puts in rowcount."""
result = _execute_with_cursor(
monkeypatch, engine, len(rows), f"SELECT {len(rows)}", rows,
sql="/* comment */ WITH x AS (SELECT 1) SELECT * FROM x")
assert result["numberOfRecordsUpdated"] == 0
assert result["records"] == [[{"longValue": row[0]}] for row in rows]
assert result["columnMetadata"][0]["name"] == "value"
@pytest.mark.parametrize("command", ("INSERT", "UPDATE", "DELETE"))
@pytest.mark.parametrize("count", (0, 2))
@pytest.mark.parametrize("returning", (False, True), ids=("plain", "returning"))
def test_rds_data_pg_dml_keeps_its_count(monkeypatch, command, count, returning):
"""DML keeps its count, RETURNING included: the tag stays INSERT/UPDATE/DELETE."""
rows = [(1,)] * count if returning else None
tag = f"INSERT 0 {count}" if command == "INSERT" else f"{command} {count}"
result = _execute_with_cursor(monkeypatch, "postgres", count, tag, rows)
assert result["numberOfRecordsUpdated"] == count
assert len(result["records"]) == (count if returning else 0)
@pytest.mark.parametrize("status", (
None, "", " ", 123, b"SELECT 2", "SELECTED 2", "select 2",
"CREATE TABLE AS", "FETCH 2",
))
def test_rds_data_pg_unrecognised_tag_preserves_the_count(monkeypatch, status):
assert _execute_with_cursor(
monkeypatch, "postgres", 2, status)["numberOfRecordsUpdated"] == 2
def test_rds_data_pg_missing_statusmessage_preserves_the_count(monkeypatch):
assert _execute_with_cursor(
monkeypatch, "postgres", 2, with_status=False)["numberOfRecordsUpdated"] == 2
@pytest.mark.parametrize("engine", _MYSQL_ENGINES)
def test_rds_data_mysql_insert_returns_its_auto_increment_id(monkeypatch, engine):
result = _execute_with_cursor(monkeypatch, engine, 1, sql="INSERT INTO t (name) VALUES ('a')", lastrowid=7)
assert result["generatedFields"] == [{"longValue": 7}]
assert _execute_with_cursor(monkeypatch, engine, 1, sql="UPDATE t SET name = 'b'")["generatedFields"] == []
def test_rds_data_mysql_batch_insert_returns_each_auto_increment_id(monkeypatch):
from ministack.services import rds_data
ids = iter((7, 8))
cursor = SimpleNamespace(lastrowid=0, close=Mock())
cursor.execute = Mock(side_effect=lambda *_a: setattr(cursor, "lastrowid", next(ids)))
connection = Mock()
connection.cursor.return_value = cursor
monkeypatch.setattr(rds_data, "_resolve_target",
lambda _arn: ({"DBInstanceIdentifier": "unit"}, "mysql", {}))
monkeypatch.setattr(rds_data, "_validate_http_endpoint_enabled", lambda *_a, **_k: None)
monkeypatch.setattr(rds_data, "_require_secret_credentials", lambda _arn: ("user", "password", None))
monkeypatch.setattr(rds_data, "_connect", lambda *_a, **_k: connection)
status_code, _headers, body = rds_data._batch_execute_statement({
"resourceArn": "resource", "secretArn": "secret", "sql": "INSERT INTO t (name) VALUES (:n)",
"parameterSets": [[{"name": "n", "value": {"stringValue": v}}] for v in ("a", "b")],
})
assert status_code == 200, body
assert json.loads(body)["updateResults"] == [{"generatedFields": [{"longValue": 7}]},
{"generatedFields": [{"longValue": 8}]}]
@pytest.mark.parametrize("engine", _PG_ENGINES)
def test_rds_data_pg_returns_no_generated_fields(monkeypatch, engine):
# Aurora PostgreSQL does not support generatedFields (ExecuteStatement API reference); RETURNING gives them.
assert _execute_with_cursor(monkeypatch, engine, 1, "INSERT 0 1", lastrowid=7)["generatedFields"] == []
@pytest.mark.parametrize("engine", _PG_ENGINES + ("mysql",))
def test_rds_data_negative_rowcount_is_clamped(monkeypatch, engine):
assert _execute_with_cursor(monkeypatch, engine, -1)["numberOfRecordsUpdated"] == 0
@pytest.mark.parametrize("engine", _MYSQL_ENGINES)
def test_rds_data_mysql_row_counts_are_unchanged(monkeypatch, engine):
"""pymysql has no statusmessage, so the MySQL path is untouched."""
assert _execute_with_cursor(
monkeypatch, engine, 2, "SELECT 2", [(1,), (2,)])["numberOfRecordsUpdated"] == 2