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
feat: add ECR (Elastic Container Registry) service emulator (#87)
Mo Abukar1481bddcc08b
diff --git a/ministack/app.py b/ministack/app.pyindex 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.pyindex 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.pynew file mode 100644index 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.pyindex 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.pyindex 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)# ═══════════════════════════════════════════════════════════════════════════════