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 io
import logging
import tarfile
import types
from ministack.services import rds as rds_service
from ministack.services import rds_iam_plugin as plugin
class FakeCursor:
def __init__(self, rows):
self.rows = iter(rows)
self.executed = []
self.closed = False
def execute(self, statement, params=None):
self.executed.append((statement, params))
def fetchone(self):
return next(self.rows)
def close(self):
self.closed = True
class FakeConnection:
def __init__(self, rows):
self.cursor_value = FakeCursor(rows)
self.closed = False
def cursor(self):
return self.cursor_value
def close(self):
self.closed = True
class FakeContainer:
def __init__(self, arch="amd64", put_result=True):
self.image = types.SimpleNamespace(attrs={"Architecture": arch})
self.put_result = put_result
self.archives = []
def put_archive(self, path, data):
self.archives.append((path, data))
return self.put_result
def _write_artifact(tmp_path, series="8.0", arch="amd64"):
artifact = tmp_path / series / arch / plugin.PLUGIN_FILE
artifact.parent.mkdir(parents=True)
artifact.write_bytes(b"plugin-payload")
return artifact
def test_rds_iam_plugin_absent_is_silent_and_does_not_connect(
monkeypatch, tmp_path, caplog,
):
monkeypatch.setattr(plugin, "DEFAULT_ARTIFACT_ROOT", str(tmp_path))
connections = []
with caplog.at_level(logging.WARNING, logger="rds"):
installed = plugin.ensure_iam_auth_plugin(
FakeContainer(),
lambda: connections.append(True),
"8.0",
"db-1",
)
assert installed is False
assert connections == []
assert caplog.records == []
def test_rds_iam_plugin_unsupported_series_avoids_docker_work(
monkeypatch, tmp_path,
):
_write_artifact(tmp_path, series="8.0")
monkeypatch.setattr(plugin, "DEFAULT_ARTIFACT_ROOT", str(tmp_path))
assert plugin.iam_auth_plugin_enabled("8.0") is True
assert plugin.iam_auth_plugin_enabled("5.7") is False
def test_rds_iam_plugin_installs_matching_series_and_arch(monkeypatch, tmp_path):
_write_artifact(tmp_path, series="8.4", arch="arm64")
monkeypatch.setattr(plugin, "DEFAULT_ARTIFACT_ROOT", str(tmp_path))
container = FakeContainer(arch="aarch64")
connection = FakeConnection(
[None, None, ("/usr/lib64/mysql/plugin",), (plugin.PLUGIN_NAME,)]
)
installed = plugin.ensure_iam_auth_plugin(
container,
lambda: connection,
"8.4",
"cluster-1",
)
assert installed is True
assert connection.closed is True
assert connection.cursor_value.closed is True
assert connection.cursor_value.executed == [
("SET SESSION sql_log_bin = 0", None),
(
"SELECT PLUGIN_NAME FROM INFORMATION_SCHEMA.PLUGINS "
"WHERE PLUGIN_NAME = %s AND PLUGIN_STATUS = 'ACTIVE'",
(plugin.PLUGIN_NAME,),
),
(
"SELECT name, dl FROM mysql.plugin WHERE name = %s",
(plugin.PLUGIN_NAME,),
),
("SELECT @@plugin_dir", None),
(
"INSTALL PLUGIN AWSAuthenticationPlugin "
"SONAME 'aws_auth_plugin.so'",
None,
),
(
"SELECT PLUGIN_NAME FROM INFORMATION_SCHEMA.PLUGINS "
"WHERE PLUGIN_NAME = %s AND PLUGIN_STATUS = 'ACTIVE'",
(plugin.PLUGIN_NAME,),
),
]
assert len(container.archives) == 1
archive_path, archive_data = container.archives[0]
assert archive_path == "/usr/lib64/mysql/plugin"
with tarfile.open(fileobj=io.BytesIO(archive_data), mode="r:") as archive:
member = archive.getmember(plugin.PLUGIN_FILE)
assert member.mode == 0o755
assert archive.extractfile(member).read() == b"plugin-payload"
def test_rds_iam_plugin_is_idempotent(monkeypatch, tmp_path):
_write_artifact(tmp_path)
monkeypatch.setattr(plugin, "DEFAULT_ARTIFACT_ROOT", str(tmp_path))
container = FakeContainer()
connection = FakeConnection([("AWSAuthenticationPlugin",)])
installed = plugin.ensure_iam_auth_plugin(
container,
lambda: connection,
"8.0",
"db-1",
)
assert installed is True
assert container.archives == []
assert connection.cursor_value.executed == [
("SET SESSION sql_log_bin = 0", None),
(
"SELECT PLUGIN_NAME FROM INFORMATION_SCHEMA.PLUGINS "
"WHERE PLUGIN_NAME = %s AND PLUGIN_STATUS = 'ACTIVE'",
(plugin.PLUGIN_NAME,),
),
]
def test_rds_iam_plugin_recovers_boot_failed_registration(
monkeypatch, tmp_path, caplog,
):
_write_artifact(tmp_path)
monkeypatch.setattr(plugin, "DEFAULT_ARTIFACT_ROOT", str(tmp_path))
container = FakeContainer()
connection = FakeConnection(
[
None,
(plugin.PLUGIN_NAME, plugin.PLUGIN_FILE),
("/usr/lib64/mysql/plugin",),
(plugin.PLUGIN_NAME,),
]
)
original_execute = connection.cursor_value.execute
def execute(statement, params=None):
original_execute(statement, params)
if statement == f"UNINSTALL PLUGIN {plugin.PLUGIN_NAME}":
raise RuntimeError("plugin is registered but not loaded")
connection.cursor_value.execute = execute
with caplog.at_level(logging.WARNING, logger="rds"):
assert plugin.ensure_iam_auth_plugin(
container,
lambda: connection,
"8.0",
"db-1",
) is True
statements = connection.cursor_value.executed
assert statements[0] == ("SET SESSION sql_log_bin = 0", None)
assert statements.index(
(f"UNINSTALL PLUGIN {plugin.PLUGIN_NAME}", None)
) < statements.index(
("DELETE FROM mysql.plugin WHERE name = %s", (plugin.PLUGIN_NAME,))
)
assert statements.index(
("DELETE FROM mysql.plugin WHERE name = %s", (plugin.PLUGIN_NAME,))
) < statements.index(
(
"INSTALL PLUGIN AWSAuthenticationPlugin "
"SONAME 'aws_auth_plugin.so'",
None,
)
)
assert "removing mysql.plugin row" in caplog.text
def test_rds_iam_plugin_failure_warns_once_and_does_not_escape(
monkeypatch, tmp_path, caplog,
):
_write_artifact(tmp_path)
monkeypatch.setattr(plugin, "DEFAULT_ARTIFACT_ROOT", str(tmp_path))
container = FakeContainer(put_result=False)
connection = FakeConnection(
[None, None, ("/usr/lib64/mysql/plugin",)]
)
with caplog.at_level(logging.WARNING, logger="rds"):
installed = plugin.ensure_iam_auth_plugin(
container,
lambda: connection,
"8.0",
"db-1",
)
assert installed is False
warnings = [
record for record in caplog.records
if "failed to install AWSAuthenticationPlugin" in record.message
]
assert len(warnings) == 1
def test_mysql_compatibility_wait_resolves_container_before_procedures(
monkeypatch, tmp_path,
):
monkeypatch.setattr(plugin, "DEFAULT_ARTIFACT_ROOT", str(tmp_path))
connection = object()
calls = []
class ReadyContainer:
status = "running"
def reload(self):
calls.append("reload")
container = ReadyContainer()
class Containers:
def get(self, container_id):
calls.append(("get", container_id))
return container
docker_client = types.SimpleNamespace(containers=Containers())
def wait_for_ready(*args):
calls.append("wait")
assert args[-1]() is True
return True
def ensure_procedures(
connection_factory, resource_id, engine, engine_series,
):
calls.append(("procedures", resource_id))
assert engine == "aurora-mysql"
assert engine_series == "8.0"
assert connection_factory() is connection
return True
monkeypatch.setattr(rds_service, "_get_docker", lambda: docker_client)
monkeypatch.setattr(rds_service, "_wait_for_database_ready", wait_for_ready)
monkeypatch.setattr(
rds_service,
"_mysql_endpoint_admin_connection",
lambda *_args: connection,
)
monkeypatch.setattr(
rds_service,
"ensure_rds_compatibility_procedures",
ensure_procedures,
)
assert rds_service._ensure_mysql_compatibility(
"container-1",
"127.0.0.1",
3306,
"password",
"8.0.mysql_aurora.3.10.3",
"db-1",
wait_for_ready=True,
) == (True, False)
assert calls == [
("get", "container-1"),
("procedures", "db-1"),
"wait",
"reload",
]
def test_mariadb_compatibility_skips_plugin_and_roles(monkeypatch):
calls = []
def enabled(engine_series):
calls.append(("plugin-enabled", engine_series))
return True
def ensure_procedures(
_connection_factory, resource_id, engine, engine_series,
):
calls.append(("procedures", resource_id, engine, engine_series))
return True
monkeypatch.setattr(rds_service, "iam_auth_plugin_enabled", enabled)
monkeypatch.setattr(
rds_service,
"ensure_rds_compatibility_procedures",
ensure_procedures,
)
assert rds_service._ensure_mysql_compatibility(
None,
"127.0.0.1",
3306,
"password",
"10.6.14",
"db-1",
engine="mariadb",
) == (True, False)
assert calls == [("procedures", "db-1", "mariadb", None)]
def test_rds_iam_plugin_broker_config_carries_a_live_capability(monkeypatch):
from ministack.core import rds_iam
issued = {}
def issue(**kwargs):
issued.update(kwargs)
return "c" * 64
monkeypatch.setattr(rds_iam, "issue_capability", issue)
container = FakeContainer()
assert plugin.configure_iam_auth_broker(container, "cluster", "aurora-1", "172.18.0.2", "4566")
assert issued["resource_kind"] == "cluster" and issued["resource_identifier"] == "aurora-1"
path, data = container.archives[0]
assert path == "/"
with tarfile.open(fileobj=io.BytesIO(data)) as archive:
member = archive.getmember(plugin.CONFIG_PATH.lstrip("/"))
assert member.mode == 0o644
assert archive.extractfile(member).read() == b"172.18.0.2 4566 " + b"c" * 64 + b"\n"
def test_rds_iam_plugin_broker_config_failure_is_swallowed(monkeypatch, caplog):
from ministack.core import rds_iam
monkeypatch.setattr(rds_iam, "issue_capability", lambda **kwargs: "c" * 64)
with caplog.at_level(logging.WARNING, logger="rds"):
assert not plugin.configure_iam_auth_broker(
FakeContainer(put_result=False), "instance", "db-1", "host.docker.internal", "4566")
assert "failed to configure AWSAuthenticationPlugin for db-1" in caplog.text