Skip to content

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

feat: add ECR (Elastic Container Registry) service emulator (#87)

Mo Abukar1481bddcc08b
diff --git a/ministack/app.py b/ministack/app.py
index a581ef53..7a4d4156 100644
--- a/ministack/app.py
+++ b/ministack/app.py
@@ -51,6 +51,7 @@ from ministack.services import (
cognito,
dynamodb,
ec2,
+ ecr,
ecs,
efs,
elasticache,
@@ -103,6 +104,7 @@ SERVICE_HANDLERS = {
"acm": acm.handle_request,
"wafv2": waf.handle_request,
"states": stepfunctions.handle_request,
+ "ecr": ecr.handle_request,
"ecs": ecs.handle_request,
"rds": rds.handle_request,
"elasticache": elasticache.handle_request,
@@ -134,6 +136,7 @@ SERVICE_NAME_ALIASES = {
"cognito-identity": "cognito-identity",
"elbv2": "elasticloadbalancing",
"elb": "elasticloadbalancing",
+ "ecr": "ecr",
}
@@ -170,7 +173,7 @@ BANNER = r"""
Services: S3, SQS, SNS, DynamoDB, Lambda, IAM, STS, SecretsManager, CloudWatch Logs,
SSM, EventBridge, Kinesis, CloudWatch, SES, SES v2, ACM, WAF v2, Step Functions,
ECS, RDS, ElastiCache, Glue, Athena, API Gateway, Firehose, Route53,
- Cognito, EC2, EMR, EBS, EFS, ALB/ELBv2, CloudFormation, KMS
+ Cognito, EC2, EMR, EBS, EFS, ALB/ELBv2, CloudFormation, KMS, ECR
"""
diff --git a/ministack/core/router.py b/ministack/core/router.py
index 2686a08d..c39d536a 100644
--- a/ministack/core/router.py
+++ b/ministack/core/router.py
@@ -126,6 +126,11 @@ SERVICE_PATTERNS = {
"path_prefixes": ["/2015-02-01/"],
"credential_scope": "elasticfilesystem",
},
+ "ecr": {
+ "target_prefixes": ["AmazonEC2ContainerRegistry_V20150921"],
+ "host_patterns": [r"api\.ecr\.", r"ecr\."],
+ "credential_scope": "ecr",
+ },
"ec2": {
"host_patterns": [r"ec2\."],
"path_patterns": [r"Action=.*Instance", r"Action=.*Security", r"Action=.*KeyPair",
@@ -197,6 +202,7 @@ def detect_service(method: str, path: str, headers: dict, query_params: dict) ->
"wafv2": "wafv2",
"cognito-idp": "cognito-idp",
"cognito-identity": "cognito-identity",
+ "ecr": "ecr",
"elasticmapreduce": "elasticmapreduce",
"elasticloadbalancing": "elasticloadbalancing",
"elasticfilesystem": "elasticfilesystem",
diff --git a/ministack/services/ecr.py b/ministack/services/ecr.py
new file mode 100644
index 00000000..32e5498a
--- /dev/null
+++ b/ministack/services/ecr.py
@@ -0,0 +1,577 @@
+"""
+ECR (Elastic Container Registry) Emulator.
+JSON-based API via X-Amz-Target (prefix: AmazonEC2ContainerRegistry_V20150921).
+"""
+
+import base64
+import hashlib
+import json
+import logging
+import os
+import time
+
+from ministack.core.responses import error_response_json, json_response, new_uuid
+
+logger = logging.getLogger("ecr")
+
+ACCOUNT_ID = "000000000000"
+REGION = os.environ.get("MINISTACK_REGION", "us-east-1")
+
+_repositories: dict = {}
+_images: dict = {}
+_lifecycle_policies: dict = {}
+_repo_policies: dict = {}
+
+
+def _repo_arn(name):
+ return f"arn:aws:ecr:{REGION}:{ACCOUNT_ID}:repository/{name}"
+
+
+def _registry_id():
+ return ACCOUNT_ID
+
+
+def _repo_uri(name):
+ return f"{ACCOUNT_ID}.dkr.ecr.{REGION}.amazonaws.com/{name}"
+
+
+def _image_digest(manifest):
+ raw = manifest.encode() if isinstance(manifest, str) else manifest
+ return "sha256:" + hashlib.sha256(raw).hexdigest()
+
+
+async def handle_request(method, path, headers, body, query_params):
+ target = headers.get("x-amz-target", "")
+ action = target.split(".")[-1] if "." in target else ""
+
+ try:
+ data = json.loads(body) if body else {}
+ except json.JSONDecodeError:
+ return error_response_json("SerializationException", "Invalid JSON", 400)
+
+ handlers = {
+ "CreateRepository": _create_repository,
+ "DescribeRepositories": _describe_repositories,
+ "DeleteRepository": _delete_repository,
+ "ListImages": _list_images,
+ "PutImage": _put_image,
+ "BatchGetImage": _batch_get_image,
+ "BatchDeleteImage": _batch_delete_image,
+ "GetAuthorizationToken": _get_authorization_token,
+ "GetRepositoryPolicy": _get_repository_policy,
+ "SetRepositoryPolicy": _set_repository_policy,
+ "DeleteRepositoryPolicy": _delete_repository_policy,
+ "PutLifecyclePolicy": _put_lifecycle_policy,
+ "GetLifecyclePolicy": _get_lifecycle_policy,
+ "DeleteLifecyclePolicy": _delete_lifecycle_policy,
+ "DescribeImages": _describe_images,
+ "ListTagsForResource": _list_tags_for_resource,
+ "TagResource": _tag_resource,
+ "UntagResource": _untag_resource,
+ "PutImageTagMutability": _put_image_tag_mutability,
+ "PutImageScanningConfiguration": _put_image_scanning_configuration,
+ "DescribeRegistry": _describe_registry,
+ "GetDownloadUrlForLayer": _get_download_url_for_layer,
+ "BatchCheckLayerAvailability": _batch_check_layer_availability,
+ "InitiateLayerUpload": _initiate_layer_upload,
+ "UploadLayerPart": _upload_layer_part,
+ "CompleteLayerUpload": _complete_layer_upload,
+ }
+
+ handler = handlers.get(action)
+ if not handler:
+ return error_response_json("InvalidAction", f"Unknown action: {action}", 400)
+
+ return handler(data)
+
+
+def _create_repository(data):
+ name = data.get("repositoryName", "")
+ if not name:
+ return error_response_json("InvalidParameterException", "repositoryName is required", 400)
+ if name in _repositories:
+ return error_response_json("RepositoryAlreadyExistsException",
+ f"The repository with name '{name}' already exists", 400)
+
+ repo = {
+ "repositoryArn": _repo_arn(name),
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "repositoryUri": _repo_uri(name),
+ "createdAt": time.time(),
+ "imageTagMutability": data.get("imageTagMutability", "MUTABLE"),
+ "imageScanningConfiguration": data.get("imageScanningConfiguration", {"scanOnPush": False}),
+ "encryptionConfiguration": data.get("encryptionConfiguration", {"encryptionType": "AES256"}),
+ "tags": data.get("tags", []),
+ }
+ _repositories[name] = repo
+ _images[name] = []
+ return json_response({"repository": _repo_shape(repo)})
+
+
+def _describe_repositories(data):
+ names = data.get("repositoryNames", [])
+ max_results = data.get("maxResults", 1000)
+
+ if names:
+ repos = []
+ for n in names:
+ if n not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{n}' does not exist", 400)
+ repos.append(_repositories[n])
+ else:
+ repos = list(_repositories.values())
+
+ return json_response({"repositories": [_repo_shape(r) for r in repos[:max_results]]})
+
+
+def _delete_repository(data):
+ name = data.get("repositoryName", "")
+ force = data.get("force", False)
+
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+
+ if not force and _images.get(name):
+ return error_response_json("RepositoryNotEmptyException",
+ f"The repository with name '{name}' is not empty", 400)
+
+ repo = _repositories.pop(name)
+ _images.pop(name, None)
+ _lifecycle_policies.pop(name, None)
+ _repo_policies.pop(name, None)
+ return json_response({"repository": _repo_shape(repo)})
+
+
+def _put_image(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+
+ manifest = data.get("imageManifest", "")
+ manifest_type = data.get("imageManifestMediaType",
+ "application/vnd.docker.distribution.manifest.v2+json")
+ tag = data.get("imageTag")
+ digest = data.get("imageDigest") or _image_digest(manifest)
+
+ repo = _repositories[name]
+ if tag and repo.get("imageTagMutability") == "IMMUTABLE":
+ for img in _images[name]:
+ if tag in img.get("imageTags", []):
+ return error_response_json("ImageTagAlreadyExistsException",
+ f"The image tag '{tag}' already exists", 400)
+
+ if tag:
+ for img in _images[name]:
+ tags = img.get("imageTags", [])
+ if tag in tags:
+ tags.remove(tag)
+
+ image = {
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "imageId": {"imageDigest": digest},
+ "imageManifest": manifest,
+ "imageManifestMediaType": manifest_type,
+ "imageTags": [tag] if tag else [],
+ "imagePushedAt": time.time(),
+ "imageDigest": digest,
+ }
+ if tag:
+ image["imageId"]["imageTag"] = tag
+
+ existing = next((img for img in _images[name] if img["imageDigest"] == digest), None)
+ if existing:
+ if tag:
+ existing.setdefault("imageTags", [])
+ if tag not in existing["imageTags"]:
+ existing["imageTags"].append(tag)
+ existing["imageId"]["imageTag"] = tag
+ image = existing
+ else:
+ _images[name].append(image)
+
+ return json_response({"image": {
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "imageId": image["imageId"],
+ "imageManifest": manifest,
+ "imageManifestMediaType": manifest_type,
+ }})
+
+
+def _batch_get_image(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+
+ image_ids = data.get("imageIds", [])
+ found = []
+ failures = []
+
+ for iid in image_ids:
+ match = _find_image(name, iid)
+ if match:
+ found.append({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "imageId": match["imageId"],
+ "imageManifest": match.get("imageManifest", "{}"),
+ "imageManifestMediaType": match.get("imageManifestMediaType",
+ "application/vnd.docker.distribution.manifest.v2+json"),
+ })
+ else:
+ failures.append({
+ "imageId": iid,
+ "failureCode": "ImageNotFound",
+ "failureReason": "Requested image not found",
+ })
+
+ return json_response({"images": found, "failures": failures})
+
+
+def _batch_delete_image(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+
+ image_ids = data.get("imageIds", [])
+ deleted = []
+ failures = []
+
+ for iid in image_ids:
+ match = _find_image(name, iid)
+ if match:
+ _images[name].remove(match)
+ deleted.append(match["imageId"])
+ else:
+ failures.append({
+ "imageId": iid,
+ "failureCode": "ImageNotFound",
+ "failureReason": "Requested image not found",
+ })
+
+ return json_response({"imageIds": deleted, "failures": failures})
+
+
+def _list_images(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+
+ tag_status = data.get("filter", {}).get("tagStatus")
+ result = []
+ for img in _images.get(name, []):
+ tags = img.get("imageTags", [])
+ if tag_status == "TAGGED" and not tags:
+ continue
+ if tag_status == "UNTAGGED" and tags:
+ continue
+ result.append(img["imageId"])
+
+ return json_response({"imageIds": result})
+
+
+def _describe_images(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+
+ image_ids = data.get("imageIds")
+ images = _images.get(name, [])
+
+ if image_ids:
+ filtered = []
+ for iid in image_ids:
+ match = _find_image(name, iid)
+ if match:
+ filtered.append(match)
+ images = filtered
+
+ details = []
+ for img in images:
+ manifest = img.get("imageManifest", "{}")
+ details.append({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "imageDigest": img["imageDigest"],
+ "imageTags": img.get("imageTags", []),
+ "imageSizeInBytes": len(manifest),
+ "imagePushedAt": img.get("imagePushedAt", time.time()),
+ "imageManifestMediaType": img.get("imageManifestMediaType",
+ "application/vnd.docker.distribution.manifest.v2+json"),
+ "artifactMediaType": img.get("imageManifestMediaType",
+ "application/vnd.docker.distribution.manifest.v2+json"),
+ })
+
+ return json_response({"imageDetails": details})
+
+
+def _get_authorization_token(data):
+ token = base64.b64encode(b"AWS:ministack-auth-token").decode()
+ return json_response({
+ "authorizationData": [{
+ "authorizationToken": token,
+ "expiresAt": time.time() + 43200,
+ "proxyEndpoint": f"https://{ACCOUNT_ID}.dkr.ecr.{REGION}.amazonaws.com",
+ }]
+ })
+
+
+def _get_repository_policy(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ if name not in _repo_policies:
+ return error_response_json("RepositoryPolicyNotFoundException",
+ f"Repository policy does not exist for '{name}'", 400)
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "policyText": _repo_policies[name],
+ })
+
+
+def _set_repository_policy(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ policy = data.get("policyText", "")
+ _repo_policies[name] = policy
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "policyText": policy,
+ })
+
+
+def _delete_repository_policy(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ if name not in _repo_policies:
+ return error_response_json("RepositoryPolicyNotFoundException",
+ f"Repository policy does not exist for '{name}'", 400)
+ policy = _repo_policies.pop(name)
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "policyText": policy,
+ })
+
+
+def _put_lifecycle_policy(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ policy = data.get("lifecyclePolicyText", "")
+ _lifecycle_policies[name] = policy
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "lifecyclePolicyText": policy,
+ })
+
+
+def _get_lifecycle_policy(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ if name not in _lifecycle_policies:
+ return error_response_json("LifecyclePolicyNotFoundException",
+ f"Lifecycle policy does not exist for '{name}'", 400)
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "lifecyclePolicyText": _lifecycle_policies[name],
+ "lastEvaluatedAt": time.time(),
+ })
+
+
+def _delete_lifecycle_policy(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ if name not in _lifecycle_policies:
+ return error_response_json("LifecyclePolicyNotFoundException",
+ f"Lifecycle policy does not exist for '{name}'", 400)
+ policy = _lifecycle_policies.pop(name)
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "lifecyclePolicyText": policy,
+ "lastEvaluatedAt": time.time(),
+ })
+
+
+def _list_tags_for_resource(data):
+ arn = data.get("resourceArn", "")
+ repo = _find_repo_by_arn(arn)
+ if not repo:
+ return error_response_json("RepositoryNotFoundException", "Repository not found", 400)
+ return json_response({"tags": repo.get("tags", [])})
+
+
+def _tag_resource(data):
+ arn = data.get("resourceArn", "")
+ repo = _find_repo_by_arn(arn)
+ if not repo:
+ return error_response_json("RepositoryNotFoundException", "Repository not found", 400)
+ new_tags = data.get("tags", [])
+ existing = {t["Key"]: t for t in repo.get("tags", [])}
+ for t in new_tags:
+ existing[t["Key"]] = t
+ repo["tags"] = list(existing.values())
+ return json_response({})
+
+
+def _untag_resource(data):
+ arn = data.get("resourceArn", "")
+ repo = _find_repo_by_arn(arn)
+ if not repo:
+ return error_response_json("RepositoryNotFoundException", "Repository not found", 400)
+ keys = set(data.get("tagKeys", []))
+ repo["tags"] = [t for t in repo.get("tags", []) if t["Key"] not in keys]
+ return json_response({})
+
+
+def _put_image_tag_mutability(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ mutability = data.get("imageTagMutability", "MUTABLE")
+ _repositories[name]["imageTagMutability"] = mutability
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "imageTagMutability": mutability,
+ })
+
+
+def _put_image_scanning_configuration(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ config = data.get("imageScanningConfiguration", {"scanOnPush": False})
+ _repositories[name]["imageScanningConfiguration"] = config
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "imageScanningConfiguration": config,
+ })
+
+
+def _describe_registry(data):
+ return json_response({
+ "registryId": _registry_id(),
+ "replicationConfiguration": {"rules": []},
+ })
+
+
+def _get_download_url_for_layer(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ layer_digest = data.get("layerDigest", "")
+ return json_response({
+ "downloadUrl": f"https://{ACCOUNT_ID}.dkr.ecr.{REGION}.amazonaws.com/v2/{name}/blobs/{layer_digest}",
+ "layerDigest": layer_digest,
+ })
+
+
+def _batch_check_layer_availability(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ digests = data.get("layerDigests", [])
+ layers = [{"layerDigest": d, "layerAvailability": "UNAVAILABLE", "layerSize": 0} for d in digests]
+ return json_response({"layers": layers, "failures": []})
+
+
+def _initiate_layer_upload(data):
+ name = data.get("repositoryName", "")
+ if name not in _repositories:
+ return error_response_json("RepositoryNotFoundException",
+ f"The repository with name '{name}' does not exist", 400)
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "uploadId": new_uuid(),
+ "partSize": 10485760,
+ })
+
+
+def _upload_layer_part(data):
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": data.get("repositoryName", ""),
+ "uploadId": data.get("uploadId", ""),
+ "lastByteReceived": 0,
+ })
+
+
+def _complete_layer_upload(data):
+ name = data.get("repositoryName", "")
+ digests = data.get("layerDigests", [])
+ layer_digest = digests[0] if digests else "sha256:" + new_uuid().replace("-", "")
+ return json_response({
+ "registryId": _registry_id(),
+ "repositoryName": name,
+ "uploadId": data.get("uploadId", ""),
+ "layerDigest": layer_digest,
+ })
+
+
+def _find_image(repo_name, image_id):
+ digest = image_id.get("imageDigest")
+ tag = image_id.get("imageTag")
+ for img in _images.get(repo_name, []):
+ if digest and img["imageDigest"] == digest:
+ return img
+ if tag and tag in img.get("imageTags", []):
+ return img
+ return None
+
+
+def _find_repo_by_arn(arn):
+ for repo in _repositories.values():
+ if repo["repositoryArn"] == arn:
+ return repo
+ return None
+
+
+def _repo_shape(repo):
+ return {
+ "repositoryArn": repo["repositoryArn"],
+ "registryId": repo["registryId"],
+ "repositoryName": repo["repositoryName"],
+ "repositoryUri": repo["repositoryUri"],
+ "createdAt": repo["createdAt"],
+ "imageTagMutability": repo.get("imageTagMutability", "MUTABLE"),
+ "imageScanningConfiguration": repo.get("imageScanningConfiguration", {"scanOnPush": False}),
+ "encryptionConfiguration": repo.get("encryptionConfiguration", {"encryptionType": "AES256"}),
+ }
+
+
+def reset():
+ _repositories.clear()
+ _images.clear()
+ _lifecycle_policies.clear()
+ _repo_policies.clear()
diff --git a/tests/conftest.py b/tests/conftest.py
index 1bbec075..a0a8293a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -106,6 +106,10 @@ def ecs():
def rds():
return make_client("rds")
[email protected](scope="session")
+def ecr():
+ return make_client("ecr")
+
@pytest.fixture(scope="session")
def ec():
return make_client("elasticache")
diff --git a/tests/test_services.py b/tests/test_services.py
index 0ecb7456..9d5b0a7e 100644
--- a/tests/test_services.py
+++ b/tests/test_services.py
@@ -16959,6 +16959,195 @@ def test_kms_delete_alias(kms_client):
assert "NotFoundException" in str(exc.value)
+# ── ECR ────────────────────────────────────────────────────────────────────────
+
+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 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
# ═══════════════════════════════════════════════════════════════════════════════
# State Persistence — get_state / restore_state round-trip (unit tests)
# ═══════════════════════════════════════════════════════════════════════════════