Skip to content

Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.

27.7 KB
Raw Blame
import os

import boto3
import pytest
from botocore.exceptions import ClientError

ENDPOINT = os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566")
REGION = "us-east-1"


@pytest.fixture(scope="module")
def backup():
    return boto3.client(
        "backup",
        endpoint_url=ENDPOINT,
        aws_access_key_id="test",
        aws_secret_access_key="test",
        region_name=REGION,
    )


@pytest.fixture(scope="module")
def backup_west():
    return boto3.client(
        "backup",
        endpoint_url=ENDPOINT,
        aws_access_key_id="test",
        aws_secret_access_key="test",
        region_name="us-west-2",
    )


def _uid():
    import uuid
    return uuid.uuid4().hex[:8]


# ---------------------------------------------------------------------------
# Vault tests
# ---------------------------------------------------------------------------

def test_backup_create_vault(backup):
    name = f"test-vault-{_uid()}"
    resp = backup.create_backup_vault(BackupVaultName=name)
    assert resp["BackupVaultName"] == name
    assert f"backup-vault:{name}" in resp["BackupVaultArn"]
    assert "CreationDate" in resp


def test_backup_describe_vault(backup):
    name = f"desc-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    desc = backup.describe_backup_vault(BackupVaultName=name)
    assert desc["BackupVaultName"] == name
    assert f"backup-vault:{name}" in desc["BackupVaultArn"]
    assert desc["NumberOfRecoveryPoints"] == 0


def test_backup_describe_vault_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.describe_backup_vault(BackupVaultName="no-such-vault-xyz")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_create_vault_duplicate(backup):
    name = f"dup-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    with pytest.raises(ClientError) as exc:
        backup.create_backup_vault(BackupVaultName=name)
    assert exc.value.response["Error"]["Code"] == "AlreadyExistsException"


def test_backup_list_vaults(backup):
    name = f"list-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    resp = backup.list_backup_vaults()
    names = [v["BackupVaultName"] for v in resp["BackupVaultList"]]
    assert name in names


def test_backup_delete_vault(backup):
    name = f"del-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    backup.delete_backup_vault(BackupVaultName=name)
    with pytest.raises(ClientError) as exc:
        backup.describe_backup_vault(BackupVaultName=name)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_delete_vault_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.delete_backup_vault(BackupVaultName="no-such-vault-xyz")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_vaults_are_region_scoped(backup, backup_west):
    name = f"region-vault-{_uid()}"

    east = backup.create_backup_vault(BackupVaultName=name)
    west_names_before = {
        vault["BackupVaultName"]
        for vault in backup_west.list_backup_vaults()["BackupVaultList"]
    }
    assert name not in west_names_before

    west = backup_west.create_backup_vault(BackupVaultName=name)

    assert f":{REGION}:" in east["BackupVaultArn"]
    assert ":us-west-2:" in west["BackupVaultArn"]

    backup.delete_backup_vault(BackupVaultName=name)
    with pytest.raises(ClientError) as exc:
        backup.describe_backup_vault(BackupVaultName=name)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"

    assert backup_west.describe_backup_vault(BackupVaultName=name)["BackupVaultName"] == name


# ---------------------------------------------------------------------------
# Plan tests
# ---------------------------------------------------------------------------

def _plan_body(name):
    return {
        "BackupPlanName": name,
        "Rules": [
            {
                "RuleName": "daily",
                "TargetBackupVaultName": "Default",
                "ScheduleExpression": "cron(0 12 * * ? *)",
            }
        ],
    }


def test_backup_create_plan(backup):
    resp = backup.create_backup_plan(BackupPlan=_plan_body(f"plan-{_uid()}"))
    assert "BackupPlanId" in resp
    assert "BackupPlanArn" in resp
    assert "VersionId" in resp


def test_backup_get_plan(backup):
    name = f"plan-get-{_uid()}"
    create = backup.create_backup_plan(BackupPlan=_plan_body(name))
    plan_id = create["BackupPlanId"]
    resp = backup.get_backup_plan(BackupPlanId=plan_id)
    assert resp["BackupPlanId"] == plan_id
    assert resp["BackupPlan"]["BackupPlanName"] == name


def test_backup_get_plan_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.get_backup_plan(BackupPlanId="no-such-plan-id")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_update_plan(backup):
    name = f"plan-upd-{_uid()}"
    plan_id = backup.create_backup_plan(BackupPlan=_plan_body(name))["BackupPlanId"]
    v1 = backup.get_backup_plan(BackupPlanId=plan_id)["VersionId"]
    backup.update_backup_plan(
        BackupPlanId=plan_id,
        BackupPlan=_plan_body(f"{name}-updated"),
    )
    v2 = backup.get_backup_plan(BackupPlanId=plan_id)["VersionId"]
    assert v1 != v2


def test_backup_list_plan_versions(backup):
    plan_id = backup.create_backup_plan(BackupPlan=_plan_body(f"ver-{_uid()}"))["BackupPlanId"]
    backup.update_backup_plan(BackupPlanId=plan_id, BackupPlan=_plan_body(f"ver-v2-{_uid()}"))
    resp = backup.list_backup_plan_versions(BackupPlanId=plan_id)
    assert len(resp["BackupPlanVersionsList"]) == 2


def test_backup_list_plan_versions_single_version(backup):
    plan_id = backup.create_backup_plan(BackupPlan=_plan_body(f"ver-single-{_uid()}"))["BackupPlanId"]
    resp = backup.list_backup_plan_versions(BackupPlanId=plan_id)
    assert len(resp["BackupPlanVersionsList"]) == 1


def test_backup_list_plan_versions_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.list_backup_plan_versions(BackupPlanId="no-such-plan-id")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_delete_plan_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.delete_backup_plan(BackupPlanId="no-such-plan-id")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_update_plan_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.update_backup_plan(
            BackupPlanId="no-such-plan-id",
            BackupPlan=_plan_body(f"upd-missing-{_uid()}"),
        )
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_list_plans(backup):
    plan_id = backup.create_backup_plan(BackupPlan=_plan_body(f"listed-{_uid()}"))["BackupPlanId"]
    resp = backup.list_backup_plans()
    ids = [p["BackupPlanId"] for p in resp["BackupPlansList"]]
    assert plan_id in ids


def test_backup_delete_plan(backup):
    plan_id = backup.create_backup_plan(BackupPlan=_plan_body(f"del-{_uid()}"))["BackupPlanId"]
    backup.delete_backup_plan(BackupPlanId=plan_id)
    with pytest.raises(ClientError) as exc:
        backup.get_backup_plan(BackupPlanId=plan_id)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_plans_are_region_scoped(backup, backup_west):
    plan_id = backup.create_backup_plan(BackupPlan=_plan_body(f"regional-plan-{_uid()}"))["BackupPlanId"]

    with pytest.raises(ClientError) as exc:
        backup_west.get_backup_plan(BackupPlanId=plan_id)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"

    west_plans = backup_west.list_backup_plans()["BackupPlansList"]
    assert plan_id not in {plan["BackupPlanId"] for plan in west_plans}


# ---------------------------------------------------------------------------
# Selection tests
# ---------------------------------------------------------------------------

def _make_plan(backup):
    return backup.create_backup_plan(BackupPlan=_plan_body(f"sel-plan-{_uid()}"))["BackupPlanId"]


def test_backup_create_selection_plan_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.create_backup_selection(
            BackupPlanId="no-such-plan-id",
            BackupSelection={
                "SelectionName": "sel-x",
                "IamRoleArn": "arn:aws:iam::000000000000:role/BackupRole",
            },
        )
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_create_selection(backup):
    plan_id = _make_plan(backup)
    resp = backup.create_backup_selection(
        BackupPlanId=plan_id,
        BackupSelection={
            "SelectionName": "sel-1",
            "IamRoleArn": "arn:aws:iam::000000000000:role/BackupRole",
            "Resources": ["arn:aws:dynamodb:us-east-1:000000000000:table/MyTable"],
        },
    )
    assert "SelectionId" in resp
    assert resp["BackupPlanId"] == plan_id


def test_backup_get_selection(backup):
    plan_id = _make_plan(backup)
    sel_id = backup.create_backup_selection(
        BackupPlanId=plan_id,
        BackupSelection={
            "SelectionName": "sel-get",
            "IamRoleArn": "arn:aws:iam::000000000000:role/BackupRole",
        },
    )["SelectionId"]
    resp = backup.get_backup_selection(BackupPlanId=plan_id, SelectionId=sel_id)
    assert resp["SelectionId"] == sel_id
    assert resp["BackupSelection"]["SelectionName"] == "sel-get"


def test_backup_list_selections(backup):
    plan_id = _make_plan(backup)
    sel_id = backup.create_backup_selection(
        BackupPlanId=plan_id,
        BackupSelection={
            "SelectionName": "sel-list",
            "IamRoleArn": "arn:aws:iam::000000000000:role/BackupRole",
        },
    )["SelectionId"]
    resp = backup.list_backup_selections(BackupPlanId=plan_id)
    ids = [s["SelectionId"] for s in resp["BackupSelectionsList"]]
    assert sel_id in ids


def test_backup_list_selections_plan_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.list_backup_selections(BackupPlanId="no-such-plan-id")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_get_selection_not_found(backup):
    plan_id = _make_plan(backup)
    with pytest.raises(ClientError) as exc:
        backup.get_backup_selection(BackupPlanId=plan_id, SelectionId="no-such-sel-id")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_delete_selection(backup):
    plan_id = _make_plan(backup)
    sel_id = backup.create_backup_selection(
        BackupPlanId=plan_id,
        BackupSelection={
            "SelectionName": "sel-del",
            "IamRoleArn": "arn:aws:iam::000000000000:role/BackupRole",
        },
    )["SelectionId"]
    backup.delete_backup_selection(BackupPlanId=plan_id, SelectionId=sel_id)
    with pytest.raises(ClientError) as exc:
        backup.get_backup_selection(BackupPlanId=plan_id, SelectionId=sel_id)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_selections_are_plan_region_scoped(backup, backup_west):
    plan_id = _make_plan(backup)
    sel_id = backup.create_backup_selection(
        BackupPlanId=plan_id,
        BackupSelection={
            "SelectionName": "sel-regional",
            "IamRoleArn": "arn:aws:iam::000000000000:role/BackupRole",
        },
    )["SelectionId"]

    with pytest.raises(ClientError) as exc:
        backup_west.get_backup_selection(BackupPlanId=plan_id, SelectionId=sel_id)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"

    with pytest.raises(ClientError) as exc:
        backup_west.list_backup_selections(BackupPlanId=plan_id)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


# ---------------------------------------------------------------------------
# Job tests
# ---------------------------------------------------------------------------

def test_backup_start_job(backup):
    vault_name = f"job-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=vault_name)
    resp = backup.start_backup_job(
        BackupVaultName=vault_name,
        ResourceArn="arn:aws:dynamodb:us-east-1:000000000000:table/MyTable",
        IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
    )
    assert "BackupJobId" in resp
    assert "RecoveryPointArn" in resp


def test_backup_describe_job(backup):
    vault_name = f"desc-job-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=vault_name)
    job_id = backup.start_backup_job(
        BackupVaultName=vault_name,
        ResourceArn="arn:aws:dynamodb:us-east-1:000000000000:table/MyTable",
        IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
    )["BackupJobId"]
    resp = backup.describe_backup_job(BackupJobId=job_id)
    assert resp["BackupJobId"] == job_id
    assert resp["State"] == "COMPLETED"
    assert resp["BackupVaultName"] == vault_name


def test_backup_describe_job_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.describe_backup_job(BackupJobId="no-such-job-id")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_list_jobs(backup):
    vault_name = f"list-job-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=vault_name)
    job_id = backup.start_backup_job(
        BackupVaultName=vault_name,
        ResourceArn="arn:aws:s3:::my-bucket",
        IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
    )["BackupJobId"]
    resp = backup.list_backup_jobs(ByBackupVaultName=vault_name)
    ids = [j["BackupJobId"] for j in resp["BackupJobs"]]
    assert job_id in ids


def test_backup_start_job_vault_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.start_backup_job(
            BackupVaultName="no-such-vault-xyz",
            ResourceArn="arn:aws:s3:::my-bucket",
            IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
        )
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_start_job_increments_recovery_point_count(backup):
    vault_name = f"rp-count-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=vault_name)
    before = backup.describe_backup_vault(BackupVaultName=vault_name)["NumberOfRecoveryPoints"]
    backup.start_backup_job(
        BackupVaultName=vault_name,
        ResourceArn="arn:aws:dynamodb:us-east-1:000000000000:table/MyTable",
        IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
    )
    after = backup.describe_backup_vault(BackupVaultName=vault_name)["NumberOfRecoveryPoints"]
    assert after == before + 1


def test_backup_jobs_are_region_scoped_and_increment_local_vault(backup, backup_west):
    vault_name = f"job-region-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=vault_name)

    with pytest.raises(ClientError) as exc:
        backup_west.start_backup_job(
            BackupVaultName=vault_name,
            ResourceArn="arn:aws:dynamodb:us-west-2:000000000000:table/MyTable",
            IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
        )
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"

    before = backup.describe_backup_vault(BackupVaultName=vault_name)["NumberOfRecoveryPoints"]
    job_id = backup.start_backup_job(
        BackupVaultName=vault_name,
        ResourceArn="arn:aws:dynamodb:us-east-1:000000000000:table/MyTable",
        IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
    )["BackupJobId"]
    assert backup.describe_backup_vault(BackupVaultName=vault_name)["NumberOfRecoveryPoints"] == before + 1

    with pytest.raises(ClientError) as exc:
        backup_west.describe_backup_job(BackupJobId=job_id)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
    west_job_ids = {
        job["BackupJobId"]
        for job in backup_west.list_backup_jobs(ByBackupVaultName=vault_name)["BackupJobs"]
    }
    assert job_id not in west_job_ids


def test_backup_stop_job_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.stop_backup_job(BackupJobId="no-such-job-id")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"



def test_backup_list_jobs_by_state(backup):
    vault_name = f"state-filter-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=vault_name)
    job_id = backup.start_backup_job(
        BackupVaultName=vault_name,
        ResourceArn="arn:aws:s3:::my-bucket",
        IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
    )["BackupJobId"]
    resp = backup.list_backup_jobs(ByState="COMPLETED")
    ids = [j["BackupJobId"] for j in resp["BackupJobs"]]
    assert job_id in ids
    resp_fail = backup.list_backup_jobs(ByState="FAILED")
    ids_fail = [j["BackupJobId"] for j in resp_fail["BackupJobs"]]
    assert job_id not in ids_fail


def test_backup_list_jobs_by_resource_arn(backup):
    vault_name = f"res-filter-vault-{_uid()}"
    resource = f"arn:aws:dynamodb:us-east-1:000000000000:table/table-{_uid()}"
    backup.create_backup_vault(BackupVaultName=vault_name)
    job_id = backup.start_backup_job(
        BackupVaultName=vault_name,
        ResourceArn=resource,
        IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
    )["BackupJobId"]
    resp = backup.list_backup_jobs(ByResourceArn=resource)
    ids = [j["BackupJobId"] for j in resp["BackupJobs"]]
    assert job_id in ids


def test_backup_stop_job_already_completed(backup):
    vault_name = f"stop-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=vault_name)
    job_id = backup.start_backup_job(
        BackupVaultName=vault_name,
        ResourceArn="arn:aws:s3:::my-bucket",
        IamRoleArn="arn:aws:iam::000000000000:role/BackupRole",
    )["BackupJobId"]
    with pytest.raises(ClientError) as exc:
        backup.stop_backup_job(BackupJobId=job_id)
    assert exc.value.response["Error"]["Code"] == "InvalidRequestException"


# ---------------------------------------------------------------------------
# Tag tests
# ---------------------------------------------------------------------------

def test_backup_tag_vault(backup):
    name = f"tag-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    arn = f"arn:aws:backup:{REGION}:000000000000:backup-vault:{name}"
    backup.tag_resource(ResourceArn=arn, Tags={"Env": "test", "Team": "platform"})
    resp = backup.list_tags(ResourceArn=arn)
    assert resp["Tags"]["Env"] == "test"
    assert resp["Tags"]["Team"] == "platform"


def test_backup_untag_vault(backup):
    name = f"untag-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    arn = f"arn:aws:backup:{REGION}:000000000000:backup-vault:{name}"
    backup.tag_resource(ResourceArn=arn, Tags={"Env": "test", "Team": "platform"})
    backup.untag_resource(ResourceArn=arn, TagKeyList=["Team"])
    resp = backup.list_tags(ResourceArn=arn)
    assert "Team" not in resp["Tags"]
    assert resp["Tags"]["Env"] == "test"


def test_backup_tag_plan(backup):
    plan_id = backup.create_backup_plan(BackupPlan=_plan_body(f"tag-plan-{_uid()}"))["BackupPlanId"]
    arn = f"arn:aws:backup:{REGION}:000000000000:backup-plan:{plan_id}"
    backup.tag_resource(ResourceArn=arn, Tags={"Owner": "data-team"})
    resp = backup.list_tags(ResourceArn=arn)
    assert resp["Tags"]["Owner"] == "data-team"


def test_backup_tag_rejects_malformed_arn(backup):
    with pytest.raises(ClientError) as exc:
        backup.tag_resource(ResourceArn="not-an-arn", Tags={"k": "v"})
    assert exc.value.response["Error"]["Code"] == "InvalidParameterValueException"


def test_backup_tag_rejects_wrong_service_arn(backup):
    arn = f"arn:aws:sns:{REGION}:000000000000:backup-vault:not-a-vault"
    with pytest.raises(ClientError) as exc:
        backup.tag_resource(ResourceArn=arn, Tags={"k": "v"})
    assert exc.value.response["Error"]["Code"] == "InvalidParameterValueException"


def test_backup_tag_does_not_resolve_foreign_region_arn_by_tail(backup):
    name = f"tag-foreign-region-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    arn = f"arn:aws:backup:us-west-2:000000000000:backup-vault:{name}"
    with pytest.raises(ClientError) as exc:
        backup.tag_resource(ResourceArn=arn, Tags={"k": "v"})
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_tag_does_not_resolve_foreign_account_arn_by_tail(backup):
    name = f"tag-foreign-account-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    arn = f"arn:aws:backup:{REGION}:111111111111:backup-vault:{name}"
    with pytest.raises(ClientError) as exc:
        backup.tag_resource(ResourceArn=arn, Tags={"k": "v"})
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_tag_not_found(backup):
    arn = "arn:aws:backup:us-east-1:000000000000:backup-vault:no-such-vault"
    with pytest.raises(ClientError) as exc:
        backup.tag_resource(ResourceArn=arn, Tags={"k": "v"})
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_untag_resource_not_found(backup):
    arn = "arn:aws:backup:us-east-1:000000000000:backup-vault:no-such-vault"
    with pytest.raises(ClientError) as exc:
        backup.untag_resource(ResourceArn=arn, TagKeyList=["k"])
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_list_tags_not_found(backup):
    arn = "arn:aws:backup:us-east-1:000000000000:backup-vault:no-such-vault"
    with pytest.raises(ClientError) as exc:
        backup.list_tags(ResourceArn=arn)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_list_tags_empty(backup):
    name = f"empty-tag-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    arn = f"arn:aws:backup:{REGION}:000000000000:backup-vault:{name}"
    resp = backup.list_tags(ResourceArn=arn)
    assert resp["Tags"] == {}


def test_backup_tags_are_region_scoped(backup, backup_west):
    name = f"tag-region-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    backup_west.create_backup_vault(BackupVaultName=name)

    east_arn = f"arn:aws:backup:{REGION}:000000000000:backup-vault:{name}"
    west_arn = f"arn:aws:backup:us-west-2:000000000000:backup-vault:{name}"
    backup.tag_resource(ResourceArn=east_arn, Tags={"Env": "east"})

    assert backup.list_tags(ResourceArn=east_arn)["Tags"] == {"Env": "east"}
    assert backup_west.list_tags(ResourceArn=west_arn)["Tags"] == {}


# ---------------------------------------------------------------------------
# Read-only surface (empty-list / default documents)
# ---------------------------------------------------------------------------

def test_backup_list_copy_jobs_empty(backup):
    resp = backup.list_copy_jobs()
    assert resp["CopyJobs"] == []


def test_backup_list_restore_jobs_empty(backup):
    resp = backup.list_restore_jobs()
    assert resp["RestoreJobs"] == []


def test_backup_list_report_jobs_empty(backup):
    resp = backup.list_report_jobs()
    assert resp["ReportJobs"] == []


def test_backup_list_report_plans_empty(backup):
    resp = backup.list_report_plans()
    assert resp["ReportPlans"] == []


def test_backup_list_frameworks_empty(backup):
    resp = backup.list_frameworks()
    assert resp["Frameworks"] == []


def test_backup_list_protected_resources_empty(backup):
    resp = backup.list_protected_resources()
    assert resp["Results"] == []


def test_backup_list_legal_holds_empty(backup):
    resp = backup.list_legal_holds()
    assert resp["LegalHolds"] == []


def test_backup_list_backup_plan_templates_empty(backup):
    resp = backup.list_backup_plan_templates()
    assert resp["BackupPlanTemplatesList"] == []


def test_backup_list_restore_testing_plans_empty(backup):
    resp = backup.list_restore_testing_plans()
    assert resp["RestoreTestingPlans"] == []


def test_backup_list_recovery_points_by_vault_empty(backup):
    name = f"rp-list-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    resp = backup.list_recovery_points_by_backup_vault(BackupVaultName=name)
    assert resp["RecoveryPoints"] == []


def test_backup_list_recovery_points_by_vault_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.list_recovery_points_by_backup_vault(BackupVaultName="no-such-vault-xyz")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_list_recovery_points_by_resource_empty(backup):
    resp = backup.list_recovery_points_by_resource(
        ResourceArn="arn:aws:dynamodb:us-east-1:000000000000:table/MyTable"
    )
    assert resp["RecoveryPoints"] == []


def test_backup_list_protected_resources_by_vault_empty(backup):
    name = f"prv-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    resp = backup.list_protected_resources_by_backup_vault(BackupVaultName=name)
    assert resp["Results"] == []


def test_backup_get_vault_access_policy_not_found(backup):
    name = f"policy-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    with pytest.raises(ClientError) as exc:
        backup.get_backup_vault_access_policy(BackupVaultName=name)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_get_vault_notifications_not_found(backup):
    name = f"notif-vault-{_uid()}"
    backup.create_backup_vault(BackupVaultName=name)
    with pytest.raises(ClientError) as exc:
        backup.get_backup_vault_notifications(BackupVaultName=name)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_describe_copy_job_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.describe_copy_job(CopyJobId="no-such-copy-job")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_describe_framework_not_found(backup):
    with pytest.raises(ClientError) as exc:
        backup.describe_framework(FrameworkName="no-such-framework")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_backup_describe_region_settings(backup):
    resp = backup.describe_region_settings()
    assert resp["ResourceTypeOptInPreference"] == {}
    assert resp["ResourceTypeManagementPreference"] == {}


def test_backup_describe_global_settings(backup):
    resp = backup.describe_global_settings()
    assert resp["GlobalSettings"] == {}


def test_backup_get_supported_resource_types(backup):
    resp = backup.get_supported_resource_types()
    assert "DynamoDB" in resp["ResourceTypes"]
    assert "S3" in resp["ResourceTypes"]


def test_backup_list_scan_jobs_empty(backup):
    resp = backup.list_scan_jobs()
    assert resp["ScanJobs"] == []


def test_backup_list_tiering_configurations_empty(backup):
    resp = backup.list_tiering_configurations()
    assert resp["TieringConfigurations"] == []


def test_backup_list_indexed_recovery_points_empty(backup):
    resp = backup.list_indexed_recovery_points()
    assert resp["IndexedRecoveryPoints"] == []


def test_backup_list_backup_job_summaries_empty(backup):
    resp = backup.list_backup_job_summaries()
    assert resp["BackupJobSummaries"] == []


def test_backup_reset_clears_all_regions():
    from ministack.core.responses import get_region, set_request_region
    from ministack.services import backup as backup_service

    original_region = get_region()
    try:
        set_request_region(REGION)
        backup_service._vaults["reset-east"] = {"BackupVaultName": "reset-east"}
        set_request_region("us-west-2")
        backup_service._vaults["reset-west"] = {"BackupVaultName": "reset-west"}

        backup_service.reset()

        assert not backup_service._vaults.has_any()
        assert not backup_service._plans.has_any()
        assert not backup_service._selections.has_any()
        assert not backup_service._jobs.has_any()
    finally:
        backup_service.reset()
        set_request_region(original_region)