Skip to content

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

29.7 KB
Raw Blame
import hashlib
import json
import os
import uuid as _uuid_mod

import boto3
import pytest
import requests
from botocore.exceptions import ClientError
from conftest import inprocess_iam_user, routed_request

from ministack.core.responses import (
    get_account_id,
    get_region,
    set_request_account_id,
    set_request_region,
)
from ministack.services import ecr as ecr_svc

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


def _ecr_client(region, access_key="test"):
    return boto3.client(
        "ecr",
        endpoint_url=ENDPOINT,
        region_name=region,
        aws_access_key_id=access_key,
        aws_secret_access_key="test",
    )


def test_ecr_create_repository(ecr):
    resp = ecr.create_repository(repositoryName="test-app")
    repo = resp["repository"]
    assert repo["repositoryName"] == "test-app"
    assert "repositoryUri" in repo
    assert "repositoryArn" in repo
    assert repo["imageTagMutability"] == "MUTABLE"

def test_ecr_create_duplicate_repository(ecr):
    import botocore.exceptions
    try:
        ecr.create_repository(repositoryName="test-app")
        assert False, "Should have raised"
    except botocore.exceptions.ClientError as e:
        assert "RepositoryAlreadyExistsException" in str(e)

def test_ecr_describe_repositories(ecr):
    resp = ecr.describe_repositories()
    names = [r["repositoryName"] for r in resp["repositories"]]
    assert "test-app" in names

def test_ecr_describe_repositories_by_name(ecr):
    resp = ecr.describe_repositories(repositoryNames=["test-app"])
    assert len(resp["repositories"]) == 1
    assert resp["repositories"][0]["repositoryName"] == "test-app"

def test_ecr_describe_nonexistent_repository(ecr):
    import botocore.exceptions
    try:
        ecr.describe_repositories(repositoryNames=["nonexistent"])
        assert False, "Should have raised"
    except botocore.exceptions.ClientError as e:
        assert "RepositoryNotFoundException" in str(e)

def test_ecr_put_image(ecr):
    manifest = '{"schemaVersion": 2, "config": {"digest": "sha256:abc123"}}'
    resp = ecr.put_image(
        repositoryName="test-app",
        imageManifest=manifest,
        imageTag="v1.0.0",
    )
    assert resp["image"]["repositoryName"] == "test-app"
    assert resp["image"]["imageId"]["imageTag"] == "v1.0.0"
    assert "imageDigest" in resp["image"]["imageId"]

def test_ecr_list_images(ecr):
    resp = ecr.list_images(repositoryName="test-app")
    assert len(resp["imageIds"]) >= 1
    tags = [iid.get("imageTag") for iid in resp["imageIds"]]
    assert "v1.0.0" in tags

def test_ecr_describe_images(ecr):
    resp = ecr.describe_images(repositoryName="test-app")
    assert len(resp["imageDetails"]) >= 1
    detail = resp["imageDetails"][0]
    assert "imageDigest" in detail
    assert "v1.0.0" in detail.get("imageTags", [])

def test_ecr_batch_get_image(ecr):
    resp = ecr.batch_get_image(
        repositoryName="test-app",
        imageIds=[{"imageTag": "v1.0.0"}],
    )
    assert len(resp["images"]) == 1
    assert resp["images"][0]["imageId"]["imageTag"] == "v1.0.0"
    assert len(resp["failures"]) == 0

def test_ecr_batch_get_image_not_found(ecr):
    resp = ecr.batch_get_image(
        repositoryName="test-app",
        imageIds=[{"imageTag": "nonexistent"}],
    )
    assert len(resp["images"]) == 0
    assert len(resp["failures"]) == 1

def test_ecr_batch_delete_image(ecr):
    ecr.put_image(
        repositoryName="test-app",
        imageManifest='{"schemaVersion": 2, "delete": "me"}',
        imageTag="to-delete",
    )
    resp = ecr.batch_delete_image(
        repositoryName="test-app",
        imageIds=[{"imageTag": "to-delete"}],
    )
    assert len(resp["imageIds"]) == 1
    assert len(resp["failures"]) == 0

def test_ecr_get_authorization_token(ecr):
    resp = ecr.get_authorization_token()
    assert len(resp["authorizationData"]) == 1
    assert "authorizationToken" in resp["authorizationData"][0]
    assert "proxyEndpoint" in resp["authorizationData"][0]

def test_ecr_lifecycle_policy(ecr):
    policy = '{"rules": [{"rulePriority": 1, "selection": {"tagStatus": "untagged", "countType": "sinceImagePushed", "countUnit": "days", "countNumber": 14}, "action": {"type": "expire"}}]}'
    ecr.put_lifecycle_policy(repositoryName="test-app", lifecyclePolicyText=policy)
    resp = ecr.get_lifecycle_policy(repositoryName="test-app")
    assert resp["lifecyclePolicyText"] == policy
    ecr.delete_lifecycle_policy(repositoryName="test-app")
    import botocore.exceptions
    try:
        ecr.get_lifecycle_policy(repositoryName="test-app")
        assert False, "Should have raised"
    except botocore.exceptions.ClientError as e:
        assert "LifecyclePolicyNotFoundException" in str(e)

def test_ecr_repository_policy(ecr):
    policy = '{"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Principal": "*", "Action": "ecr:GetDownloadUrlForLayer"}]}'
    ecr.set_repository_policy(repositoryName="test-app", policyText=policy)
    resp = ecr.get_repository_policy(repositoryName="test-app")
    assert resp["policyText"] == policy
    ecr.delete_repository_policy(repositoryName="test-app")
    import botocore.exceptions
    try:
        ecr.get_repository_policy(repositoryName="test-app")
        assert False, "Should have raised"
    except botocore.exceptions.ClientError as e:
        assert "RepositoryPolicyNotFoundException" in str(e)


def _policy_repository(effect, principal):
    """A repository whose policy has one statement, without a Resource, on ecr:ListImages."""
    name = f"rp-{_uuid_mod.uuid4().hex[:8]}"
    _create_repository(name)
    ecr_svc._set_repository_policy({"repositoryName": name, "policyText": json.dumps({
        "Version": "2012-10-17",
        "Statement": [{"Effect": effect, "Principal": {"AWS": principal}, "Action": "ecr:ListImages"}]})})
    return name


def _list_images(key, name, field="__type"):
    status, _headers, body = routed_request(
        key, "ecr", "POST", "/", json.dumps({"repositoryName": name}).encode(),
        {"content-type": "application/x-amz-json-1.1",
         "x-amz-target": "AmazonEC2ContainerRegistry_V20150921.ListImages"})
    return status, json.loads(body).get(field)


_ALLOW_ECR = {"Statement": [{"Effect": "Allow", "Action": "ecr:*", "Resource": "*"}]}


def test_repository_policy_naming_the_user_allows_without_identity_policy(auth):
    key, user = inprocess_iam_user()
    assert _list_images(key, _policy_repository("Allow", user)) == (200, None)


def test_repository_policy_naming_the_account_needs_an_identity_policy(auth):
    name = _policy_repository("Allow", "arn:aws:iam::000000000000:root")
    key, _user = inprocess_iam_user()
    assert _list_images(key, name) == (403, "AccessDeniedException")
    key, _user = inprocess_iam_user(_ALLOW_ECR)
    assert _list_images(key, name) == (200, None)


def test_repository_policy_deny_beats_an_identity_allow(auth):
    key, user = inprocess_iam_user(_ALLOW_ECR)
    name = _policy_repository("Deny", user)
    assert _list_images(key, name) == (403, "AccessDeniedException")
    assert _list_images(key, name, "message") == (403, (
        f"User: {user} is not authorized to perform: ecr:ListImages on resource: "
        f"arn:aws:ecr:us-east-1:000000000000:repository/{name} with an explicit deny in a resource-based policy"))


def test_ecr_image_tag_mutability(ecr):
    ecr.put_image_tag_mutability(repositoryName="test-app", imageTagMutability="IMMUTABLE")
    resp = ecr.describe_repositories(repositoryNames=["test-app"])
    assert resp["repositories"][0]["imageTagMutability"] == "IMMUTABLE"
    ecr.put_image_tag_mutability(repositoryName="test-app", imageTagMutability="MUTABLE")

def test_ecr_image_scanning_configuration(ecr):
    ecr.put_image_scanning_configuration(
        repositoryName="test-app",
        imageScanningConfiguration={"scanOnPush": True},
    )
    resp = ecr.describe_repositories(repositoryNames=["test-app"])
    assert resp["repositories"][0]["imageScanningConfiguration"]["scanOnPush"] is True

def test_ecr_tag_resource(ecr):
    resp = ecr.describe_repositories(repositoryNames=["test-app"])
    arn = resp["repositories"][0]["repositoryArn"]
    ecr.tag_resource(resourceArn=arn, tags=[{"Key": "env", "Value": "dev"}])
    tags_resp = ecr.list_tags_for_resource(resourceArn=arn)
    tag_keys = [t["Key"] for t in tags_resp["tags"]]
    assert "env" in tag_keys
    ecr.untag_resource(resourceArn=arn, tagKeys=["env"])
    tags_resp = ecr.list_tags_for_resource(resourceArn=arn)
    tag_keys = [t["Key"] for t in tags_resp["tags"]]
    assert "env" not in tag_keys

def test_ecr_delete_repository_not_empty(ecr):
    import botocore.exceptions
    try:
        ecr.delete_repository(repositoryName="test-app")
        assert False, "Should have raised"
    except botocore.exceptions.ClientError as e:
        assert "RepositoryNotEmptyException" in str(e)

def test_ecr_delete_repository_force(ecr):
    ecr.create_repository(repositoryName="to-force-delete")
    ecr.put_image(
        repositoryName="to-force-delete",
        imageManifest='{"schemaVersion": 2}',
        imageTag="latest",
    )
    resp = ecr.delete_repository(repositoryName="to-force-delete", force=True)
    assert resp["repository"]["repositoryName"] == "to-force-delete"

def test_ecr_describe_registry(ecr):
    resp = ecr.describe_registry()
    assert "registryId" in resp
    assert "replicationConfiguration" in resp


def test_ecr_repositories_are_region_scoped():
    east = _ecr_client("us-east-1")
    west = _ecr_client("us-west-2")
    same_name = "regional-same-" + _uuid_mod.uuid4().hex[:8]
    east_only = "regional-east-" + _uuid_mod.uuid4().hex[:8]
    west_only = "regional-west-" + _uuid_mod.uuid4().hex[:8]

    east_repo = east.create_repository(repositoryName=same_name)["repository"]
    west_repo = west.create_repository(repositoryName=same_name)["repository"]
    east.create_repository(repositoryName=east_only)
    west.create_repository(repositoryName=west_only)

    assert f":us-east-1:000000000000:repository/{same_name}" in east_repo["repositoryArn"]
    assert f":us-west-2:000000000000:repository/{same_name}" in west_repo["repositoryArn"]
    with pytest.raises(ClientError) as exc_info:
        east.create_repository(repositoryName=same_name)
    assert exc_info.value.response["Error"]["Code"] == (
        "RepositoryAlreadyExistsException"
    )

    east_names = {
        repo["repositoryName"] for repo in east.describe_repositories()["repositories"]
    }
    west_names = {
        repo["repositoryName"] for repo in west.describe_repositories()["repositories"]
    }
    assert east_only in east_names
    assert west_only not in east_names
    assert west_only in west_names
    assert east_only not in west_names

    with pytest.raises(ClientError) as exc_info:
        east.describe_repositories(repositoryNames=[west_only])
    assert exc_info.value.response["Error"]["Code"] == "RepositoryNotFoundException"

    catalog = requests.get(f"{ENDPOINT}/v2/_catalog")
    assert catalog.status_code == 200
    assert west_only not in catalog.json()["repositories"]

    west_namespace = "000000000000.dkr.ecr.us-west-2.amazonaws.com"
    catalog = requests.get(
        f"{ENDPOINT}/v2/_catalog", headers={"Host": west_namespace}
    )
    assert catalog.status_code == 200
    assert west_only in catalog.json()["repositories"]
    assert east_only not in catalog.json()["repositories"]
    catalog = requests.get(
        f"{ENDPOINT}/v2/_catalog", params={"ns": west_namespace}
    )
    assert catalog.status_code == 200
    assert west_only in catalog.json()["repositories"]
    assert east_only not in catalog.json()["repositories"]


# ──────────────────────────────────────────────────────────────────────────
# Docker Registry HTTP API V2 — `docker push` / `docker pull` wire protocol.
# Issue #606: paths starting with /v2/ were routing to S3 (which returned 405).
# ──────────────────────────────────────────────────────────────────────────


def _digest(data: bytes) -> str:
    return "sha256:" + hashlib.sha256(data).hexdigest()


def _v2_single_shot_upload(repo, payload, *, headers=None, namespace=None):
    digest = _digest(payload)
    params = {"digest": digest}
    if namespace is not None:
        params["ns"] = namespace
    response = requests.post(
        f"{ENDPOINT}/v2/{repo}/blobs/uploads/",
        params=params,
        data=payload,
        headers=headers,
    )
    return response, digest


def test_v2_version_probe():
    r = requests.get(f"{ENDPOINT}/v2/")
    assert r.status_code == 200
    assert r.headers.get("Docker-Distribution-API-Version") == "registry/2.0"


def test_v2_unknown_repo_returns_404(ecr):
    r = requests.head(
        f"{ENDPOINT}/v2/no-such-repo-{_uuid_mod.uuid4().hex[:8]}/blobs/sha256:" + "0" * 64
    )
    assert r.status_code == 404


def test_v2_registry_scope_uses_host_ns_and_unique_region_fallback():
    west = _ecr_client("us-west-2")
    europe = _ecr_client("eu-west-1")
    account = "000000000000"

    host_repo = "v2-host-region-" + _uuid_mod.uuid4().hex[:8]
    host_account = "111111111111"
    host_account_west = _ecr_client("us-west-2", access_key=host_account)
    host_account_west.create_repository(repositoryName=host_repo)
    west_host = {"Host": f"{host_account}.dkr.ecr.us-west-2.amazonaws.com"}
    response, digest = _v2_single_shot_upload(
        host_repo, b"host-region", headers=west_host
    )
    assert response.status_code == 201, response.text
    response = requests.get(
        f"{ENDPOINT}/v2/{host_repo}/blobs/{digest}", headers=west_host
    )
    assert response.status_code == 200
    assert response.content == b"host-region"

    # Unique fallback never crosses accounts, so the same request without
    # the host hint stays in the default account and cannot see this repo.
    response = requests.get(f"{ENDPOINT}/v2/{host_repo}/blobs/{digest}")
    assert response.status_code == 404

    # Plain localhost requests model an EKS/containerd mirror without an
    # original-host hint. A unique repository match selects its region.
    unique_repo = "v2-unique-region-" + _uuid_mod.uuid4().hex[:8]
    west.create_repository(repositoryName=unique_repo)
    response, unique_digest = _v2_single_shot_upload(
        unique_repo, b"unique-region"
    )
    assert response.status_code == 201, response.text
    response = requests.get(f"{ENDPOINT}/v2/{unique_repo}/blobs/{unique_digest}")
    assert response.status_code == 200
    assert response.content == b"unique-region"

    ns_repo = "v2-ns-region-" + _uuid_mod.uuid4().hex[:8]
    europe.create_repository(repositoryName=ns_repo)
    namespace = f"{account}.dkr.ecr.eu-west-1.amazonaws.com"
    response, ns_digest = _v2_single_shot_upload(
        ns_repo, b"namespace-region", namespace=namespace
    )
    assert response.status_code == 201, response.text
    response = requests.get(
        f"{ENDPOINT}/v2/{ns_repo}/blobs/{ns_digest}",
        params={"ns": namespace},
    )
    assert response.status_code == 200
    assert response.content == b"namespace-region"


def test_v2_registry_scope_prefers_ambient_and_rejects_ambiguous_fallback():
    east = _ecr_client("us-east-1")
    west = _ecr_client("us-west-2")
    europe = _ecr_client("eu-west-1")
    account = "000000000000"

    ambient_repo = "v2-ambient-region-" + _uuid_mod.uuid4().hex[:8]
    east.create_repository(repositoryName=ambient_repo)
    west.create_repository(repositoryName=ambient_repo)
    response, digest = _v2_single_shot_upload(ambient_repo, b"ambient-region")
    assert response.status_code == 201, response.text
    east_host = {"Host": f"{account}.dkr.ecr.us-east-1.amazonaws.com"}
    west_host = {"Host": f"{account}.dkr.ecr.us-west-2.amazonaws.com"}
    assert requests.get(
        f"{ENDPOINT}/v2/{ambient_repo}/blobs/{digest}", headers=east_host
    ).status_code == 200
    assert requests.get(
        f"{ENDPOINT}/v2/{ambient_repo}/blobs/{digest}", headers=west_host
    ).status_code == 404

    ambiguous_repo = "v2-ambiguous-region-" + _uuid_mod.uuid4().hex[:8]
    west.create_repository(repositoryName=ambiguous_repo)
    europe.create_repository(repositoryName=ambiguous_repo)
    response, _digest_value = _v2_single_shot_upload(
        ambiguous_repo, b"ambiguous-region"
    )
    assert response.status_code == 404
    assert response.json()["errors"][0]["code"] == "NAME_UNKNOWN"


def test_v2_chunked_blob_upload_then_manifest_then_describe_images(ecr):
    repo = "v2-pushflow-" + _uuid_mod.uuid4().hex[:8]
    ecr.create_repository(repositoryName=repo)

    # Two layers — first chunked, second single-shot.
    layer_a = b"layer-a-bytes" * 100
    layer_b = b"layer-b-bytes" * 50
    digest_a = _digest(layer_a)
    digest_b = _digest(layer_b)

    # Chunked upload of layer A.
    r = requests.post(f"{ENDPOINT}/v2/{repo}/blobs/uploads/")
    assert r.status_code == 202, r.text
    upload_url = r.headers["Location"]
    assert upload_url.startswith("/v2/")

    # PATCH first half.
    half = len(layer_a) // 2
    r = requests.patch(f"{ENDPOINT}{upload_url}", data=layer_a[:half])
    assert r.status_code == 202, r.text
    # PATCH second half.
    upload_url = r.headers["Location"]
    r = requests.patch(f"{ENDPOINT}{upload_url}", data=layer_a[half:])
    assert r.status_code == 202

    # PUT to finalise with digest query.
    upload_url = r.headers["Location"]
    r = requests.put(f"{ENDPOINT}{upload_url}", params={"digest": digest_a})
    assert r.status_code == 201, r.text
    assert r.headers["Docker-Content-Digest"] == digest_a

    # Single-shot upload of layer B.
    r = requests.post(
        f"{ENDPOINT}/v2/{repo}/blobs/uploads/",
        params={"digest": digest_b},
        data=layer_b,
    )
    assert r.status_code == 201
    assert r.headers["Docker-Content-Digest"] == digest_b

    # HEAD + GET round-trip layer A bytes.
    r = requests.head(f"{ENDPOINT}/v2/{repo}/blobs/{digest_a}")
    assert r.status_code == 200
    assert r.headers["Docker-Content-Digest"] == digest_a
    assert int(r.headers["Content-Length"]) == len(layer_a)

    r = requests.get(f"{ENDPOINT}/v2/{repo}/blobs/{digest_a}")
    assert r.status_code == 200
    assert r.content == layer_a

    # PUT manifest by tag.
    manifest = json.dumps({
        "schemaVersion": 2,
        "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
        "config": {
            "mediaType": "application/vnd.docker.container.image.v1+json",
            "size": len(layer_b),
            "digest": digest_b,
        },
        "layers": [{
            "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
            "size": len(layer_a),
            "digest": digest_a,
        }],
    }).encode()
    manifest_digest = _digest(manifest)

    r = requests.put(
        f"{ENDPOINT}/v2/{repo}/manifests/v1.0.0",
        data=manifest,
        headers={"Content-Type": "application/vnd.docker.distribution.manifest.v2+json"},
    )
    assert r.status_code == 201, r.text
    assert r.headers["Docker-Content-Digest"] == manifest_digest

    # GET manifest by tag.
    r = requests.get(f"{ENDPOINT}/v2/{repo}/manifests/v1.0.0")
    assert r.status_code == 200
    assert r.content == manifest
    assert r.headers["Docker-Content-Digest"] == manifest_digest
    assert r.headers["Content-Type"] == (
        "application/vnd.docker.distribution.manifest.v2+json"
    )

    # GET manifest by digest.
    r = requests.get(f"{ENDPOINT}/v2/{repo}/manifests/{manifest_digest}")
    assert r.status_code == 200
    assert r.content == manifest

    # HEAD manifest by tag.
    r = requests.head(f"{ENDPOINT}/v2/{repo}/manifests/v1.0.0")
    assert r.status_code == 200
    assert r.headers["Docker-Content-Digest"] == manifest_digest

    # /v2/<repo>/tags/list returns the tag.
    r = requests.get(f"{ENDPOINT}/v2/{repo}/tags/list")
    assert r.status_code == 200
    body = r.json()
    assert body["name"] == repo
    assert "v1.0.0" in body["tags"]

    # AWS ECR DescribeImages now sees the pushed image.
    desc = ecr.describe_images(repositoryName=repo)
    digests = [img["imageDigest"] for img in desc["imageDetails"]]
    assert manifest_digest in digests
    pushed = next(img for img in desc["imageDetails"] if img["imageDigest"] == manifest_digest)
    assert "v1.0.0" in pushed.get("imageTags", [])


def test_v2_digest_mismatch_returns_400(ecr):
    repo = "v2-bad-digest-" + _uuid_mod.uuid4().hex[:8]
    ecr.create_repository(repositoryName=repo)

    payload = b"actual-bytes"
    wrong_digest = "sha256:" + "f" * 64

    r = requests.post(f"{ENDPOINT}/v2/{repo}/blobs/uploads/")
    assert r.status_code == 202
    upload_url = r.headers["Location"]
    r = requests.patch(f"{ENDPOINT}{upload_url}", data=payload)
    assert r.status_code == 202
    upload_url = r.headers["Location"]
    r = requests.put(f"{ENDPOINT}{upload_url}", params={"digest": wrong_digest})
    assert r.status_code == 400
    body = r.json()
    assert body["errors"][0]["code"] == "DIGEST_INVALID"


def test_v2_cross_repo_blob_mount(ecr):
    src = "v2-mount-src-" + _uuid_mod.uuid4().hex[:8]
    dst = "v2-mount-dst-" + _uuid_mod.uuid4().hex[:8]
    ecr.create_repository(repositoryName=src)
    ecr.create_repository(repositoryName=dst)

    layer = b"shared-layer" * 200
    digest = _digest(layer)

    r = requests.post(
        f"{ENDPOINT}/v2/{src}/blobs/uploads/",
        params={"digest": digest},
        data=layer,
    )
    assert r.status_code == 201

    # Mount into dst without re-uploading.
    r = requests.post(
        f"{ENDPOINT}/v2/{dst}/blobs/uploads/",
        params={"mount": digest, "from": src},
    )
    assert r.status_code == 201, r.text
    assert r.headers["Docker-Content-Digest"] == digest

    r = requests.get(f"{ENDPOINT}/v2/{dst}/blobs/{digest}")
    assert r.status_code == 200
    assert r.content == layer


def test_v2_repo_named_after_a_path_does_not_route_to_s3(ecr):
    """Regression for #606: /v2/<name>/blobs/uploads/ used to hit S3."""
    repo = "review-service-" + _uuid_mod.uuid4().hex[:8]
    ecr.create_repository(repositoryName=repo)

    # The exact request `docker push` makes first.
    r = requests.post(f"{ENDPOINT}/v2/{repo}/blobs/uploads/")
    # Before the fix this was a 405 from S3. Now it is a 202 from ECR.
    assert r.status_code == 202
    assert "Location" in r.headers
    assert r.headers.get("Docker-Distribution-API-Version") == "registry/2.0"


def test_v2_catalog_lists_repos(ecr):
    name = "v2-catalog-" + _uuid_mod.uuid4().hex[:8]
    ecr.create_repository(repositoryName=name)
    r = requests.get(f"{ENDPOINT}/v2/_catalog")
    assert r.status_code == 200
    assert name in r.json()["repositories"]


def test_v2_cancel_upload(ecr):
    repo = "v2-cancel-" + _uuid_mod.uuid4().hex[:8]
    ecr.create_repository(repositoryName=repo)
    r = requests.post(f"{ENDPOINT}/v2/{repo}/blobs/uploads/")
    assert r.status_code == 202
    upload_url = r.headers["Location"]
    r = requests.delete(f"{ENDPOINT}{upload_url}")
    assert r.status_code == 204
    # Subsequent PATCH on a cancelled upload must 404.
    r = requests.patch(f"{ENDPOINT}{upload_url}", data=b"after-cancel")
    assert r.status_code == 404


def test_v2_apis_path_still_routes_to_apigwv2():
    """Regression: `/v2/apis/...` is the API Gateway v2 management API, not ECR.
    Earlier iteration of the registry routing hijacked every `/v2/*` path and
    broke 60+ apigwv2 tests in CI."""
    apigwv2 = boto3.client(
        "apigatewayv2",
        endpoint_url=ENDPOINT,
        region_name=REGION,
        aws_access_key_id="test",
        aws_secret_access_key="test",
    )
    api = apigwv2.create_api(Name="v2-routing-regression-" + _uuid_mod.uuid4().hex[:8], ProtocolType="HTTP")
    assert "ApiId" in api
    apigwv2.delete_api(ApiId=api["ApiId"])


def test_v2_email_path_still_routes_to_ses(ses):
    """The SES v2 carve-out (`/v2/email/...`) must NOT be hijacked by ECR."""
    # boto3 SES v2 client uses /v2/email/identities under the hood — verify the
    # client still works after our /v2/ → ECR routing change. We just call it;
    # if the route were broken we'd get a 4xx from the ECR registry handler.
    sesv2 = boto3.client(
        "sesv2",
        endpoint_url=ENDPOINT,
        region_name=REGION,
        aws_access_key_id="test",
        aws_secret_access_key="test",
    )
    resp = sesv2.list_email_identities()
    assert "EmailIdentities" in resp


# ---------------------------------------------------------------------------
# ARN-parser / tag-scope in-process unit tests. Folded from
# test_ecr_arn_parser.py (drive ecr_svc directly).
# ---------------------------------------------------------------------------


def _body(response):
    return json.loads(response[2].decode("utf-8"))


def _reset_ecr_state():
    for store in (
        ecr_svc._repositories,
        ecr_svc._images,
        ecr_svc._lifecycle_policies,
        ecr_svc._repo_policies,
        ecr_svc._layer_blobs,
        ecr_svc._manifest_blobs,
        ecr_svc._uploads,
    ):
        store.clear()


@pytest.fixture(autouse=True)
def ecr_module_state():
    original_account = get_account_id()
    original_region = get_region()
    _reset_ecr_state()
    set_request_account_id("000000000000")
    set_request_region("us-east-1")
    yield
    _reset_ecr_state()
    set_request_account_id(original_account)
    set_request_region(original_region)


def _create_repository(name):
    response = ecr_svc._create_repository({"repositoryName": name})
    assert response[0] == 200, _body(response)
    return _body(response)["repository"]


def _assert_repository_not_found(response):
    assert response[0] == 400
    assert _body(response)["__type"] == "RepositoryNotFoundException"


def test_ecr_tag_apis_require_request_scope_and_stored_repository_arn_match():
    repo_name = "arn-parser-region-scope"
    stored = _create_repository(repo_name)
    stored_arn = stored["repositoryArn"]
    assert stored_arn == f"arn:aws:ecr:us-east-1:000000000000:repository/{repo_name}"

    seed_response = ecr_svc._tag_resource({
        "resourceArn": stored_arn,
        "tags": [{"Key": "env", "Value": "east"}],
    })
    assert seed_response[0] == 200, _body(seed_response)

    set_request_region("us-west-2")
    fabricated_request_region_arn = f"arn:aws:ecr:us-west-2:000000000000:repository/{repo_name}"
    for resource_arn in (stored_arn, fabricated_request_region_arn):
        _assert_repository_not_found(ecr_svc._tag_resource({
            "resourceArn": resource_arn,
            "tags": [{"Key": "bad", "Value": "tag"}],
        }))
        _assert_repository_not_found(ecr_svc._list_tags_for_resource({"resourceArn": resource_arn}))
        _assert_repository_not_found(ecr_svc._untag_resource({
            "resourceArn": resource_arn,
            "tagKeys": ["env"],
        }))

    set_request_region("us-east-1")
    assert _body(ecr_svc._list_tags_for_resource({"resourceArn": stored_arn}))["tags"] == [
        {"Key": "env", "Value": "east"}
    ]


def test_ecr_child_stores_are_region_scoped_and_reset_clears_all_regions():
    name = "direct-region-scope"
    _create_repository(name)
    ecr_svc._images[name].append({"scope": "east"})
    ecr_svc._lifecycle_policies[name] = "east-lifecycle"
    ecr_svc._repo_policies[name] = "east-policy"
    ecr_svc._layer_blobs[name] = {"sha256:east": b"east-layer"}
    ecr_svc._manifest_blobs[name] = {"sha256:east": b"east-manifest"}
    ecr_svc._uploads[name] = {"east-upload": bytearray(b"east")}

    set_request_region("us-west-2")
    _create_repository(name)
    ecr_svc._images[name].append({"scope": "west"})
    ecr_svc._lifecycle_policies[name] = "west-lifecycle"
    ecr_svc._repo_policies[name] = "west-policy"
    ecr_svc._layer_blobs[name] = {"sha256:west": b"west-layer"}
    ecr_svc._manifest_blobs[name] = {"sha256:west": b"west-manifest"}
    ecr_svc._uploads[name] = {"west-upload": bytearray(b"west")}

    assert ecr_svc._images[name] == [{"scope": "west"}]
    assert ecr_svc._repo_policies[name] == "west-policy"
    set_request_region("us-east-1")
    assert ecr_svc._images[name] == [{"scope": "east"}]
    assert ecr_svc._repo_policies[name] == "east-policy"

    ecr_svc.reset()
    for store in (
        ecr_svc._repositories,
        ecr_svc._images,
        ecr_svc._lifecycle_policies,
        ecr_svc._repo_policies,
        ecr_svc._layer_blobs,
        ecr_svc._manifest_blobs,
        ecr_svc._uploads,
    ):
        assert not store.has_any()


@pytest.mark.parametrize(
    "resource_arn",
    [
        "not-an-arn",
        "arn:aws-cn:ecr:us-east-1:000000000000:repository/arn-parser-scope",
        "arn:aws:ecr:us-west-2:000000000000:repository/arn-parser-scope",
        "arn:aws:ecr:us-east-1:111111111111:repository/arn-parser-scope",
        "arn:aws:sns:us-east-1:000000000000:repository/arn-parser-scope",
        "arn:aws:ecr:us-east-1:000000000000:image/arn-parser-scope",
        "arn:aws:ecr:us-east-1:000000000000:repository/",
    ],
)
def test_ecr_tag_apis_reject_invalid_or_out_of_scope_repository_arns(resource_arn):
    repo_name = "arn-parser-scope"
    valid_arn = _create_repository(repo_name)["repositoryArn"]

    seed_response = ecr_svc._tag_resource({
        "resourceArn": valid_arn,
        "tags": [{"Key": "existing", "Value": "tag"}],
    })
    assert seed_response[0] == 200, _body(seed_response)

    _assert_repository_not_found(ecr_svc._tag_resource({
        "resourceArn": resource_arn,
        "tags": [{"Key": "bad", "Value": "tag"}],
    }))
    _assert_repository_not_found(ecr_svc._list_tags_for_resource({"resourceArn": resource_arn}))
    _assert_repository_not_found(ecr_svc._untag_resource({
        "resourceArn": resource_arn,
        "tagKeys": ["existing"],
    }))

    tags = _body(ecr_svc._list_tags_for_resource({"resourceArn": valid_arn}))["tags"]
    assert tags == [{"Key": "existing", "Value": "tag"}]