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(logs): add CloudWatch Logs Delivery API (#469)
W. H. Wanga57b1bb10865
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex e79e0119..bb17719b 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -9,6 +9,9 @@ Versioning follows [Semantic Versioning](https://semver.org/).## [Unreleased]+### Added+- **CloudWatch Logs Delivery API** — `PutDeliverySource` / `GetDeliverySource` / `DeleteDeliverySource` / `DescribeDeliverySources`, `PutDeliveryDestination` / `GetDeliveryDestination` / `DeleteDeliveryDestination` / `DescribeDeliveryDestinations`, and `CreateDelivery` / `GetDelivery` / `DeleteDelivery` / `DescribeDeliveries` (12 actions total). This is the 2023-era replacement for subscription filters that vended-logs producers (Bedrock, AppSync, CodeWhisperer, …) use to ship logs into S3, CloudWatch Logs, or Firehose. Server-derived fields match AWS's contract: `service` is computed from a delivery source's `resourceArn` (e.g. `arn:aws:bedrock:…` → `bedrock`) and `deliveryDestinationType` from a destination's `destinationResourceArn` (`s3` → `S3`, `logs` → `CWL`, `firehose` → `FH`); callers cannot override either. `outputFormat` is validated against the AWS enum (`json` / `plain` / `w3c` / `raw` / `parquet`). `CreateDelivery` requires the `deliveryDestinationArn` to resolve to an already-registered destination (instead of silently defaulting to `CWL`) and rejects duplicate `(deliverySourceName, deliveryDestinationArn)` pairs with `ConflictException`, matching AWS's one-Delivery-per-pair contract.+### Fixed- **RDS Postgres 18+ container refused to start** — MiniStack mounted the RDS data volume (or tmpfs) at `/var/lib/postgresql/data` for every Postgres major, but the official `postgres:18+` image moved to a major-version-specific on-disk layout and refuses to start with the pre-18 path ([docker-library/postgres#1259](https://github.com/docker-library/postgres/pull/1259)). `CreateDBInstance Engine=postgres EngineVersion=18.x` returned "available" from the RDS API while the spawned `postgres:18-alpine` container exited immediately with a layout-mismatch error. The mount path is now chosen per major: `/var/lib/postgresql/data` for < 18 (unchanged), `/var/lib/postgresql` for ≥ 18. MySQL / MariaDB / Aurora MySQL unaffected. Also adds `postgres 18.3`, `17.5`, `16.4` to the `DescribeDBEngineVersions` matrix (and aurora-postgresql equivalents). Reported by @whittin3.diff --git a/ministack/services/cloudwatch_logs.py b/ministack/services/cloudwatch_logs.pyindex f113be4c..26dd1b76 100644--- a/ministack/services/cloudwatch_logs.py+++ b/ministack/services/cloudwatch_logs.py@@ -11,7 +11,10 @@ Supports: CreateLogGroup, DeleteLogGroup, DescribeLogGroups,PutDestination, DeleteDestination, DescribeDestinations,PutDestinationPolicy,PutMetricFilter, DeleteMetricFilter, DescribeMetricFilters,- StartQuery, GetQueryResults, StopQuery.+ StartQuery, GetQueryResults, StopQuery,+ PutDeliverySource, GetDeliverySource, DeleteDeliverySource, DescribeDeliverySources,+ PutDeliveryDestination, GetDeliveryDestination, DeleteDeliveryDestination, DescribeDeliveryDestinations,+ CreateDelivery, GetDelivery, DeleteDelivery, DescribeDeliveries."""import base64@@ -49,16 +52,36 @@ _metric_filters = AccountScopedDict()_queries = AccountScopedDict()# query_id -> {queryId, logGroupName, startTime, endTime, queryString, status}+_delivery_sources = AccountScopedDict()+# source_name -> {name, arn, resourceArns: [str], logType, service, tags}++_delivery_destinations = AccountScopedDict()+# dest_name -> {name, arn, deliveryDestinationType, outputFormat,+# deliveryDestinationConfiguration: {destinationResourceArn}, tags}++_deliveries = AccountScopedDict()+# delivery_id -> {id, arn, deliverySourceName, deliveryDestinationArn,+# deliveryDestinationType, recordFields, fieldDelimiter,+# s3DeliveryConfiguration, tags}+# ── Persistence ────────────────────────────────────────────def get_state():- return {"log_groups": copy.deepcopy(_log_groups)}+ return {+ "log_groups": copy.deepcopy(_log_groups),+ "delivery_sources": copy.deepcopy(_delivery_sources),+ "delivery_destinations": copy.deepcopy(_delivery_destinations),+ "deliveries": copy.deepcopy(_deliveries),+ }def restore_state(data):if data:_log_groups.update(data.get("log_groups", {}))+ _delivery_sources.update(data.get("delivery_sources", {}))+ _delivery_destinations.update(data.get("delivery_destinations", {}))+ _deliveries.update(data.get("deliveries", {}))try:@@ -149,6 +172,18 @@ async def handle_request(method, path, headers, body, query_params):"StartQuery": _start_query,"GetQueryResults": _get_query_results,"StopQuery": _stop_query,+ "PutDeliverySource": _put_delivery_source,+ "GetDeliverySource": _get_delivery_source,+ "DeleteDeliverySource": _delete_delivery_source,+ "DescribeDeliverySources": _describe_delivery_sources,+ "PutDeliveryDestination": _put_delivery_destination,+ "GetDeliveryDestination": _get_delivery_destination,+ "DeleteDeliveryDestination": _delete_delivery_destination,+ "DescribeDeliveryDestinations": _describe_delivery_destinations,+ "CreateDelivery": _create_delivery,+ "GetDelivery": _get_delivery,+ "DeleteDelivery": _delete_delivery,+ "DescribeDeliveries": _describe_deliveries,}handler = handlers.get(action)@@ -877,3 +912,321 @@ def reset():_destinations.clear()_metric_filters.clear()_queries.clear()+ _delivery_sources.clear()+ _delivery_destinations.clear()+ _deliveries.clear()+++# ---------------------------------------------------------------------------+# Log Delivery API — Sources, Destinations, Deliveries+# AWS's 2023-era replacement for subscription filters; lets services like+# Bedrock, AppSync, and CodeWhisperer ship vended logs to S3 / CloudWatch+# Logs / Firehose.+# ---------------------------------------------------------------------------++def _make_delivery_source_arn(name):+ return f"arn:aws:logs:{get_region()}:{get_account_id()}:delivery-source:{name}"+++def _make_delivery_destination_arn(name):+ return f"arn:aws:logs:{get_region()}:{get_account_id()}:delivery-destination:{name}"+++def _make_delivery_arn(delivery_id):+ return f"arn:aws:logs:{get_region()}:{get_account_id()}:delivery:{delivery_id}"+++# AWS derives the "service" label of a delivery source from the ARN's+# service component (e.g. arn:aws:bedrock:... -> "bedrock"). Callers do+# not supply it; any value in the request is ignored. The field is+# always server-computed so it stays stable across describe calls.+def _derive_service_from_arn(arn):+ parts = arn.split(":", 5)+ return parts[2] if len(parts) >= 3 else ""+++# AWS derives deliveryDestinationType from the destination resource ARN+# (S3 / CWL / FH); callers cannot override it.+def _derive_destination_type_from_arn(arn):+ """Parse arn:aws:<svc>:region:acct:<resource>/... and map to the+ deliveryDestinationType label AWS returns. Returns None if the ARN+ doesn't match a supported target service."""+ parts = arn.split(":", 5)+ if len(parts) < 3:+ return None+ svc = parts[2]+ if svc == "s3":+ return "S3"+ if svc == "logs":+ return "CWL"+ if svc == "firehose":+ return "FH"+ return None+++_VALID_OUTPUT_FORMATS = {"json", "plain", "w3c", "raw", "parquet"}+++def _put_delivery_source(data):+ name = data.get("name")+ if not name:+ return error_response_json("ValidationException", "name is required.", 400)+ resource_arn = data.get("resourceArn")+ if not resource_arn:+ return error_response_json("ValidationException", "resourceArn is required.", 400)+ log_type = data.get("logType")+ if not log_type:+ return error_response_json("ValidationException", "logType is required.", 400)++ # AWS derives the service label from the resource ARN; ignore any+ # caller-supplied value.+ derived_service = _derive_service_from_arn(resource_arn)++ existing = _delivery_sources.get(name)+ if existing:+ existing["resourceArns"] = [resource_arn]+ existing["logType"] = log_type+ existing["service"] = derived_service+ if "tags" in data:+ existing["tags"] = dict(data["tags"])+ source = existing+ else:+ source = {+ "name": name,+ "arn": _make_delivery_source_arn(name),+ "resourceArns": [resource_arn],+ "logType": log_type,+ "service": derived_service,+ "tags": dict(data.get("tags", {})),+ }+ _delivery_sources[name] = source+ return json_response({"deliverySource": _format_delivery_source(source)})+++def _format_delivery_source(source):+ return {+ "name": source["name"],+ "arn": source["arn"],+ "resourceArns": list(source.get("resourceArns", [])),+ "service": source.get("service", ""),+ "logType": source.get("logType", ""),+ "tags": dict(source.get("tags", {})),+ }+++def _get_delivery_source(data):+ name = data.get("name")+ source = _delivery_sources.get(name)+ if not source:+ return error_response_json(+ "ResourceNotFoundException",+ f"Delivery source does not exist: {name}", 400,+ )+ return json_response({"deliverySource": _format_delivery_source(source)})+++def _delete_delivery_source(data):+ name = data.get("name")+ if name not in _delivery_sources:+ return error_response_json(+ "ResourceNotFoundException",+ f"Delivery source does not exist: {name}", 400,+ )+ del _delivery_sources[name]+ return json_response({})+++def _describe_delivery_sources(data):+ sources = [_format_delivery_source(s) for s in _delivery_sources.values()]+ return json_response({"deliverySources": sources})+++def _put_delivery_destination(data):+ name = data.get("name")+ if not name:+ return error_response_json("ValidationException", "name is required.", 400)+ config = data.get("deliveryDestinationConfiguration", {}) or {}+ destination_resource_arn = config.get("destinationResourceArn")+ if not destination_resource_arn:+ return error_response_json(+ "ValidationException",+ "deliveryDestinationConfiguration.destinationResourceArn is required.", 400,+ )++ # AWS derives deliveryDestinationType from the destination resource+ # ARN (s3 -> S3, logs -> CWL, firehose -> FH); callers cannot+ # override it.+ derived_type = _derive_destination_type_from_arn(destination_resource_arn)+ if derived_type is None:+ return error_response_json(+ "ValidationException",+ "deliveryDestinationConfiguration.destinationResourceArn must target "+ "S3 (arn:aws:s3:::...), CloudWatch Logs (arn:aws:logs:...:log-group:...), "+ "or Firehose (arn:aws:firehose:...:deliverystream/...).", 400,+ )++ output_format = data.get("outputFormat", "json")+ # AWS enforces the enum; reject unknown values so callers fail early.+ if output_format not in _VALID_OUTPUT_FORMATS:+ return error_response_json(+ "ValidationException",+ f"outputFormat must be one of {sorted(_VALID_OUTPUT_FORMATS)}; got {output_format!r}.",+ 400,+ )++ existing = _delivery_destinations.get(name)+ if existing:+ existing["deliveryDestinationConfiguration"] = {"destinationResourceArn": destination_resource_arn}+ existing["outputFormat"] = output_format+ existing["deliveryDestinationType"] = derived_type+ if "tags" in data:+ existing["tags"] = dict(data["tags"])+ dest = existing+ else:+ dest = {+ "name": name,+ "arn": _make_delivery_destination_arn(name),+ "deliveryDestinationType": derived_type,+ "outputFormat": output_format,+ "deliveryDestinationConfiguration": {+ "destinationResourceArn": destination_resource_arn,+ },+ "tags": dict(data.get("tags", {})),+ }+ _delivery_destinations[name] = dest+ return json_response({"deliveryDestination": _format_delivery_destination(dest)})+++def _format_delivery_destination(dest):+ return {+ "name": dest["name"],+ "arn": dest["arn"],+ "deliveryDestinationType": dest.get("deliveryDestinationType", "CWL"),+ "outputFormat": dest.get("outputFormat", "json"),+ "deliveryDestinationConfiguration": dict(dest.get("deliveryDestinationConfiguration", {})),+ "tags": dict(dest.get("tags", {})),+ }+++def _get_delivery_destination(data):+ name = data.get("name")+ dest = _delivery_destinations.get(name)+ if not dest:+ return error_response_json(+ "ResourceNotFoundException",+ f"Delivery destination does not exist: {name}", 400,+ )+ return json_response({"deliveryDestination": _format_delivery_destination(dest)})+++def _delete_delivery_destination(data):+ name = data.get("name")+ if name not in _delivery_destinations:+ return error_response_json(+ "ResourceNotFoundException",+ f"Delivery destination does not exist: {name}", 400,+ )+ del _delivery_destinations[name]+ return json_response({})+++def _describe_delivery_destinations(data):+ dests = [_format_delivery_destination(d) for d in _delivery_destinations.values()]+ return json_response({"deliveryDestinations": dests})+++def _create_delivery(data):+ source_name = data.get("deliverySourceName")+ dest_arn = data.get("deliveryDestinationArn")+ if not source_name:+ return error_response_json("ValidationException", "deliverySourceName is required.", 400)+ if not dest_arn:+ return error_response_json("ValidationException", "deliveryDestinationArn is required.", 400)+ if source_name not in _delivery_sources:+ return error_response_json(+ "ResourceNotFoundException",+ f"Delivery source does not exist: {source_name}", 400,+ )++ # AWS rejects CreateDelivery unless the destination ARN resolves to a+ # destination we've previously recorded via PutDeliveryDestination —+ # the API cannot ship logs to an unknown sink.+ dest_type = None+ for d in _delivery_destinations.values():+ if d["arn"] == dest_arn:+ dest_type = d.get("deliveryDestinationType")+ break+ if dest_type is None:+ return error_response_json(+ "ResourceNotFoundException",+ f"Delivery destination does not exist: {dest_arn}", 400,+ )++ # AWS allows at most one Delivery per (deliverySourceName,+ # deliveryDestinationArn) pair; CreateDelivery on an existing pair+ # raises ConflictException.+ for existing in _deliveries.values():+ if (existing["deliverySourceName"] == source_name+ and existing["deliveryDestinationArn"] == dest_arn):+ return error_response_json(+ "ConflictException",+ f"A delivery already exists for source {source_name!r} → "+ f"destination {dest_arn!r}.",+ 400,+ )++ delivery_id = new_uuid()+ delivery = {+ "id": delivery_id,+ "arn": _make_delivery_arn(delivery_id),+ "deliverySourceName": source_name,+ "deliveryDestinationArn": dest_arn,+ "deliveryDestinationType": dest_type,+ "recordFields": list(data.get("recordFields", [])),+ "fieldDelimiter": data.get("fieldDelimiter", ""),+ "s3DeliveryConfiguration": dict(data.get("s3DeliveryConfiguration", {})),+ "tags": dict(data.get("tags", {})),+ }+ _deliveries[delivery_id] = delivery+ return json_response({"delivery": _format_delivery(delivery)})+++def _format_delivery(delivery):+ return {+ "id": delivery["id"],+ "arn": delivery["arn"],+ "deliverySourceName": delivery["deliverySourceName"],+ "deliveryDestinationArn": delivery["deliveryDestinationArn"],+ "deliveryDestinationType": delivery.get("deliveryDestinationType", "CWL"),+ "recordFields": list(delivery.get("recordFields", [])),+ "fieldDelimiter": delivery.get("fieldDelimiter", ""),+ "s3DeliveryConfiguration": dict(delivery.get("s3DeliveryConfiguration", {})),+ "tags": dict(delivery.get("tags", {})),+ }+++def _get_delivery(data):+ delivery_id = data.get("id")+ delivery = _deliveries.get(delivery_id)+ if not delivery:+ return error_response_json(+ "ResourceNotFoundException",+ f"Delivery does not exist: {delivery_id}", 400,+ )+ return json_response({"delivery": _format_delivery(delivery)})+++def _delete_delivery(data):+ delivery_id = data.get("id")+ if delivery_id not in _deliveries:+ return error_response_json(+ "ResourceNotFoundException",+ f"Delivery does not exist: {delivery_id}", 400,+ )+ del _deliveries[delivery_id]+ return json_response({})+++def _describe_deliveries(data):+ deliveries = [_format_delivery(d) for d in _deliveries.values()]+ return json_response({"deliveries": deliveries})diff --git a/tests/test_logs.py b/tests/test_logs.pyindex a284838e..a479940c 100644--- a/tests/test_logs.py+++ b/tests/test_logs.py@@ -445,3 +445,233 @@ def test_logs_stop_query(logs):# cleanuplogs.delete_log_group(logGroupName=group)+++# ---------------------------------------------------------------------------+# Log Delivery API (PutDeliverySource / DeliveryDestination / Create+Describe)+# ---------------------------------------------------------------------------++def test_logs_delivery_source_crud(logs):+ """Put/Get/Describe/Delete round-trip for a delivery source.++ Per AWS's contract ``PutDeliverySource`` is idempotent (upsert)+ and ``DescribeDeliverySources`` must include the record after+ creation.+ """+ uid = _uuid_mod.uuid4().hex[:8]+ src_name = f"intg-src-{uid}"+ resource_arn = f"arn:aws:bedrock:us-east-1:000000000000:model/anthropic.x-{uid}"++ put_resp = logs.put_delivery_source(+ name=src_name,+ resourceArn=resource_arn,+ logType="APPLICATION_LOGS",+ )+ assert put_resp["deliverySource"]["name"] == src_name+ assert put_resp["deliverySource"]["resourceArns"] == [resource_arn]+ assert put_resp["deliverySource"]["logType"] == "APPLICATION_LOGS"+ assert put_resp["deliverySource"]["arn"].endswith(f":delivery-source:{src_name}")++ get_resp = logs.get_delivery_source(name=src_name)+ assert get_resp["deliverySource"]["logType"] == "APPLICATION_LOGS"++ describe_resp = logs.describe_delivery_sources()+ assert any(s["name"] == src_name for s in describe_resp["deliverySources"])++ logs.delete_delivery_source(name=src_name)+ with pytest.raises(ClientError) as exc:+ logs.get_delivery_source(name=src_name)+ assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"+++def test_logs_delivery_destination_crud(logs):+ """Put/Get/Describe/Delete round-trip for a delivery destination."""+ uid = _uuid_mod.uuid4().hex[:8]+ dest_name = f"intg-dest-{uid}"+ dest_resource_arn = f"arn:aws:logs:us-east-1:000000000000:log-group:/intg/delivery-{uid}:*"++ put_resp = logs.put_delivery_destination(+ name=dest_name,+ deliveryDestinationConfiguration={+ "destinationResourceArn": dest_resource_arn,+ },+ )+ assert put_resp["deliveryDestination"]["name"] == dest_name+ assert (+ put_resp["deliveryDestination"]["deliveryDestinationConfiguration"]["destinationResourceArn"]+ == dest_resource_arn+ )+ assert put_resp["deliveryDestination"]["arn"].endswith(f":delivery-destination:{dest_name}")++ get_resp = logs.get_delivery_destination(name=dest_name)+ assert (+ get_resp["deliveryDestination"]["deliveryDestinationConfiguration"]["destinationResourceArn"]+ == dest_resource_arn+ )++ describe_resp = logs.describe_delivery_destinations()+ assert any(d["name"] == dest_name for d in describe_resp["deliveryDestinations"])++ logs.delete_delivery_destination(name=dest_name)+++def test_logs_delivery_create_binds_source_and_destination(logs):+ """CreateDelivery wires a source to a destination and returns a delivery id/ARN."""+ uid = _uuid_mod.uuid4().hex[:8]+ src_name = f"intg-src-{uid}"+ dest_name = f"intg-dest-{uid}"++ logs.put_delivery_source(+ name=src_name,+ resourceArn=f"arn:aws:bedrock:us-east-1:000000000000:model/test-{uid}",+ logType="APPLICATION_LOGS",+ )+ dest_resp = logs.put_delivery_destination(+ name=dest_name,+ deliveryDestinationConfiguration={+ "destinationResourceArn": f"arn:aws:logs:us-east-1:000000000000:log-group:/intg/d-{uid}:*",+ },+ )+ dest_arn = dest_resp["deliveryDestination"]["arn"]++ create_resp = logs.create_delivery(+ deliverySourceName=src_name,+ deliveryDestinationArn=dest_arn,+ )+ delivery = create_resp["delivery"]+ assert delivery["deliverySourceName"] == src_name+ assert delivery["deliveryDestinationArn"] == dest_arn+ assert delivery["arn"].startswith("arn:aws:logs:")++ describe_resp = logs.describe_deliveries()+ assert any(d["id"] == delivery["id"] for d in describe_resp["deliveries"])++ logs.delete_delivery(id=delivery["id"])+ logs.delete_delivery_destination(name=dest_name)+ logs.delete_delivery_source(name=src_name)+++# ---------------------------------------------------------------------------+# Log Delivery — validation & AWS-derived fields (hardening)+# ---------------------------------------------------------------------------++def test_logs_delivery_source_service_derived_from_resource_arn(logs):+ """PutDeliverySource must set ``service`` from the resource ARN, ignoring+ any value the caller sends. AWS treats this as a server-computed+ field — callers cannot override it."""+ uid = _uuid_mod.uuid4().hex[:8]+ src_name = f"intg-svc-{uid}"+ resp = logs.put_delivery_source(+ name=src_name,+ resourceArn=f"arn:aws:bedrock:us-east-1:000000000000:model/anthropic.claude-{uid}",+ logType="APPLICATION_LOGS",+ )+ assert resp["deliverySource"]["service"] == "bedrock"+ logs.delete_delivery_source(name=src_name)+++def test_logs_delivery_destination_type_derived_from_arn(logs):+ """PutDeliveryDestination must compute ``deliveryDestinationType`` from+ the destinationResourceArn (S3 / CWL / FH)."""+ uid = _uuid_mod.uuid4().hex[:8]+ cases = [+ (f"arn:aws:s3:::bucket-{uid}", "S3"),+ (f"arn:aws:logs:us-east-1:000000000000:log-group:/intg/{uid}:*", "CWL"),+ (f"arn:aws:firehose:us-east-1:000000000000:deliverystream/{uid}", "FH"),+ ]+ for i, (arn, expected_type) in enumerate(cases):+ dest_name = f"intg-type-{uid}-{i}"+ resp = logs.put_delivery_destination(+ name=dest_name,+ deliveryDestinationConfiguration={"destinationResourceArn": arn},+ )+ assert resp["deliveryDestination"]["deliveryDestinationType"] == expected_type+ logs.delete_delivery_destination(name=dest_name)+++def test_logs_delivery_destination_rejects_unknown_output_format(logs):+ """outputFormat outside the AWS-allowed set is rejected."""+ uid = _uuid_mod.uuid4().hex[:8]+ with pytest.raises(ClientError) as exc:+ logs.put_delivery_destination(+ name=f"intg-bad-{uid}",+ outputFormat="yaml",+ deliveryDestinationConfiguration={+ "destinationResourceArn": f"arn:aws:logs:us-east-1:000000000000:log-group:/x/{uid}:*",+ },+ )+ assert exc.value.response["Error"]["Code"] == "ValidationException"+++def test_logs_delivery_destination_rejects_unsupported_target(logs):+ """destinationResourceArn that isn't S3/CWL/FH is rejected upfront."""+ uid = _uuid_mod.uuid4().hex[:8]+ with pytest.raises(ClientError) as exc:+ logs.put_delivery_destination(+ name=f"intg-bad-target-{uid}",+ deliveryDestinationConfiguration={+ "destinationResourceArn": f"arn:aws:lambda:us-east-1:000000000000:function:anything-{uid}",+ },+ )+ assert exc.value.response["Error"]["Code"] == "ValidationException"+++def test_logs_create_delivery_requires_destination_to_exist(logs):+ """CreateDelivery pointed at a non-existent destination must raise+ ResourceNotFoundException (real AWS cannot ship to an unknown sink)."""+ uid = _uuid_mod.uuid4().hex[:8]+ src_name = f"intg-src-{uid}"+ logs.put_delivery_source(+ name=src_name,+ resourceArn=f"arn:aws:bedrock:us-east-1:000000000000:model/claude-{uid}",+ logType="APPLICATION_LOGS",+ )+ try:+ with pytest.raises(ClientError) as exc:+ logs.create_delivery(+ deliverySourceName=src_name,+ deliveryDestinationArn=f"arn:aws:logs:us-east-1:000000000000:delivery-destination:never-created-{uid}",+ )+ assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"+ finally:+ logs.delete_delivery_source(name=src_name)+++def test_logs_create_delivery_rejects_duplicate_pair(logs):+ """AWS allows at most one Delivery per (source, destination) pair;+ a second CreateDelivery against the same pair raises+ ConflictException."""+ uid = _uuid_mod.uuid4().hex[:8]+ src_name = f"intg-dup-src-{uid}"+ dest_name = f"intg-dup-dest-{uid}"++ logs.put_delivery_source(+ name=src_name,+ resourceArn=f"arn:aws:bedrock:us-east-1:000000000000:model/x-{uid}",+ logType="APPLICATION_LOGS",+ )+ dest_resp = logs.put_delivery_destination(+ name=dest_name,+ deliveryDestinationConfiguration={+ "destinationResourceArn": f"arn:aws:logs:us-east-1:000000000000:log-group:/intg/d-{uid}:*",+ },+ )+ dest_arn = dest_resp["deliveryDestination"]["arn"]++ try:+ first = logs.create_delivery(+ deliverySourceName=src_name,+ deliveryDestinationArn=dest_arn,+ )++ with pytest.raises(ClientError) as exc:+ logs.create_delivery(+ deliverySourceName=src_name,+ deliveryDestinationArn=dest_arn,+ )+ assert exc.value.response["Error"]["Code"] == "ConflictException"++ logs.delete_delivery(id=first["delivery"]["id"])+ finally:+ logs.delete_delivery_destination(name=dest_name)+ logs.delete_delivery_source(name=src_name)