diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/getting_started_with_idempotency_redis_client.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/getting_started_with_idempotency_redis_client.py new file mode 100644 index 0000000000000000000000000000000000000000..24dfe1be117a67d30bb2b753aeb651a07508e86c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/getting_started_with_idempotency_redis_client.py @@ -0,0 +1,51 @@ +import os +from dataclasses import dataclass, field +from uuid import uuid4 + +from redis import Redis + +from aws_lambda_powertools.utilities.idempotency import ( + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import ( + RedisCachePersistenceLayer, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +redis_endpoint = os.getenv("REDIS_CLUSTER_ENDPOINT", "localhost") +client = Redis( + host=redis_endpoint, + port=6379, + socket_connect_timeout=5, + socket_timeout=5, + max_connections=1000, +) + +persistence_layer = RedisCachePersistenceLayer(client=client) + + +@dataclass +class Payment: + user_id: str + product_id: str + payment_id: str = field(default_factory=lambda: f"{uuid4()}") + + +class PaymentError(Exception): ... + + +@idempotent(persistence_store=persistence_layer) +def lambda_handler(event: dict, context: LambdaContext): + try: + payment: Payment = create_subscription_payment(event) + return { + "payment_id": payment.payment_id, + "message": "success", + "statusCode": 200, + } + except Exception as exc: + raise PaymentError(f"Error creating payment {str(exc)}") + + +def create_subscription_payment(event: dict) -> Payment: + return Payment(**event) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/getting_started_with_idempotency_redis_config.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/getting_started_with_idempotency_redis_config.py new file mode 100644 index 0000000000000000000000000000000000000000..f3917042b287bd23dbc13bc3a4cbe4376afb4b28 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/getting_started_with_idempotency_redis_config.py @@ -0,0 +1,41 @@ +import os +from dataclasses import dataclass, field +from uuid import uuid4 + +from aws_lambda_powertools.utilities.idempotency import ( + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import ( + RedisCachePersistenceLayer, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +redis_endpoint = os.getenv("REDIS_CLUSTER_ENDPOINT", "localhost") +persistence_layer = RedisCachePersistenceLayer(host=redis_endpoint, port=6379) + + +@dataclass +class Payment: + user_id: str + product_id: str + payment_id: str = field(default_factory=lambda: f"{uuid4()}") + + +class PaymentError(Exception): ... + + +@idempotent(persistence_store=persistence_layer) +def lambda_handler(event: dict, context: LambdaContext): + try: + payment: Payment = create_subscription_payment(event) + return { + "payment_id": payment.payment_id, + "message": "success", + "statusCode": 200, + } + except Exception as exc: + raise PaymentError(f"Error creating payment {str(exc)}") + + +def create_subscription_payment(event: dict) -> Payment: + return Payment(**event) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/integrate_idempotency_with_validator.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/integrate_idempotency_with_validator.py new file mode 100644 index 0000000000000000000000000000000000000000..675dbd249a953557b8cc76ea4ea9a44ff87a6046 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/integrate_idempotency_with_validator.py @@ -0,0 +1,19 @@ +import os + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import envelopes, validator + +table = os.getenv("IDEMPOTENCY_TABLE", "") +config = IdempotencyConfig(event_key_jmespath='["message", "username"]') +persistence_layer = DynamoDBPersistenceLayer(table_name=table) + + +@validator(envelope=envelopes.API_GATEWAY_HTTP) +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context: LambdaContext): + return {"message": event["message"], "statusCode": 200} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/using_redis_client_with_aws_secrets.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/using_redis_client_with_aws_secrets.py new file mode 100644 index 0000000000000000000000000000000000000000..ee9e6d78c4545a48d57037abb90229be23b0035c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/using_redis_client_with_aws_secrets.py @@ -0,0 +1,33 @@ +from __future__ import annotations + +from typing import Any + +from redis import Redis + +from aws_lambda_powertools.utilities import parameters +from aws_lambda_powertools.utilities.idempotency import IdempotencyConfig, idempotent +from aws_lambda_powertools.utilities.idempotency.persistence.redis import ( + RedisCachePersistenceLayer, +) + +redis_values: dict[str, Any] = parameters.get_secret("redis_info", transform="json") # (1)! + +redis_client = Redis( + host=redis_values.get("REDIS_HOST", "localhost"), + port=redis_values.get("REDIS_PORT", 6379), + password=redis_values.get("REDIS_PASSWORD"), + decode_responses=True, + socket_timeout=10.0, + ssl=True, + retry_on_timeout=True, +) + +persistence_layer = RedisCachePersistenceLayer(client=redis_client) +config = IdempotencyConfig( + expires_after_seconds=2 * 60, # 2 minutes +) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + return {"message": "Hello"} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/using_redis_client_with_local_certs.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/using_redis_client_with_local_certs.py new file mode 100644 index 0000000000000000000000000000000000000000..2b6a5892c5b9f466c610e405483f82bea951308b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/using_redis_client_with_local_certs.py @@ -0,0 +1,38 @@ +from __future__ import annotations + +from typing import Any + +from redis import Redis + +from aws_lambda_powertools.shared.functions import abs_lambda_path +from aws_lambda_powertools.utilities import parameters +from aws_lambda_powertools.utilities.idempotency import IdempotencyConfig, idempotent +from aws_lambda_powertools.utilities.idempotency.persistence.redis import ( + RedisCachePersistenceLayer, +) + +redis_values: dict[str, Any] = parameters.get_secret("redis_info", transform="json") # (1)! + + +redis_client = Redis( + host=redis_values.get("REDIS_HOST", "localhost"), + port=redis_values.get("REDIS_PORT", 6379), + password=redis_values.get("REDIS_PASSWORD"), + decode_responses=True, + socket_timeout=10.0, + ssl=True, + retry_on_timeout=True, + ssl_certfile=f"{abs_lambda_path()}/certs/redis_user.crt", # (2)! + ssl_keyfile=f"{abs_lambda_path()}/certs/redis_user_private.key", # (3)! + ssl_ca_certs=f"{abs_lambda_path()}/certs/redis_ca.pem", # (4)! +) + +persistence_layer = RedisCachePersistenceLayer(client=redis_client) +config = IdempotencyConfig( + expires_after_seconds=2 * 60, # 2 minutes +) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + return {"message": "Hello"} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_dataclass_deduced_output_serializer.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_dataclass_deduced_output_serializer.py new file mode 100644 index 0000000000000000000000000000000000000000..e6f74cb8f9afe832f667aa408ade6d60fa96f360 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_dataclass_deduced_output_serializer.py @@ -0,0 +1,51 @@ +import os +from dataclasses import dataclass + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent_function, +) +from aws_lambda_powertools.utilities.idempotency.serialization.dataclass import DataclassSerializer +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +dynamodb = DynamoDBPersistenceLayer(table_name=table) +config = IdempotencyConfig(event_key_jmespath="order_id") # see Choosing a payload subset section + + +@dataclass +class OrderItem: + sku: str + description: str + + +@dataclass +class Order: + item: OrderItem + order_id: int + + +@dataclass +class OrderOutput: + order_id: int + + +@idempotent_function( + data_keyword_argument="order", + config=config, + persistence_store=dynamodb, + output_serializer=DataclassSerializer, +) +# order output is inferred from return type +def process_order(order: Order) -> OrderOutput: # (1)! + return OrderOutput(order_id=order.order_id) + + +def lambda_handler(event: dict, context: LambdaContext): + config.register_lambda_context(context) # see Lambda timeouts section + order_item = OrderItem(sku="fake", description="sample") + order = Order(item=order_item, order_id=1) + + # `order` parameter must be called as a keyword argument to work + process_order(order=order) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_idempotent_function_dataclass.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_idempotent_function_dataclass.py new file mode 100644 index 0000000000000000000000000000000000000000..3a4e347b22ac8d492be5a2fcd5f91607baf11a1e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_idempotent_function_dataclass.py @@ -0,0 +1,41 @@ +import os +from dataclasses import dataclass + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent_function, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +dynamodb = DynamoDBPersistenceLayer(table_name=table) +config = IdempotencyConfig(event_key_jmespath="order_id") # see Choosing a payload subset section + + +@dataclass +class OrderItem: + sku: str + description: str + + +@dataclass +class Order: + item: OrderItem + order_id: int + + +@idempotent_function(data_keyword_argument="order", config=config, persistence_store=dynamodb) +def process_order(order: Order): # (1)! + return f"processed order {order.order_id}" + + +def lambda_handler(event: dict, context: LambdaContext): + # see Lambda timeouts section + config.register_lambda_context(context) # (2)! + + order_item = OrderItem(sku="fake", description="sample") + order = Order(item=order_item, order_id=1) + + # `order` parameter must be called as a keyword argument to work + process_order(order=order) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_idempotent_function_pydantic.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_idempotent_function_pydantic.py new file mode 100644 index 0000000000000000000000000000000000000000..45b57499a29776a854675c9b78e29880ff07f21d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_idempotent_function_pydantic.py @@ -0,0 +1,37 @@ +import os + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent_function, +) +from aws_lambda_powertools.utilities.parser import BaseModel +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +dynamodb = DynamoDBPersistenceLayer(table_name=table) +config = IdempotencyConfig(event_key_jmespath="order_id") # see Choosing a payload subset section + + +class OrderItem(BaseModel): + sku: str + description: str + + +class Order(BaseModel): + item: OrderItem + order_id: int + + +@idempotent_function(data_keyword_argument="order", config=config, persistence_store=dynamodb) +def process_order(order: Order): + return f"processed order {order.order_id}" + + +def lambda_handler(event: dict, context: LambdaContext): + config.register_lambda_context(context) # see Lambda timeouts section + order_item = OrderItem(sku="fake", description="sample") + order = Order(item=order_item, order_id=1) + + # `order` parameter must be called as a keyword argument to work + process_order(order=order) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_lambda_timeout.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_lambda_timeout.py new file mode 100644 index 0000000000000000000000000000000000000000..eac423607ada95cf234b56b86a5e58b36ba640bc --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_lambda_timeout.py @@ -0,0 +1,25 @@ +import os + +from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent_function, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=table) + +config = IdempotencyConfig() + + +@idempotent_function(data_keyword_argument="record", persistence_store=persistence_layer, config=config) +def record_handler(record: SQSRecord): + return {"message": record["body"]} + + +def lambda_handler(event: dict, context: LambdaContext): + config.register_lambda_context(context) + + return record_handler(event) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_local_cache.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_local_cache.py new file mode 100644 index 0000000000000000000000000000000000000000..571098715f7e5eba2b1e4ad0905d42cffb9b2d4c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_local_cache.py @@ -0,0 +1,21 @@ +import os + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=table) +config = IdempotencyConfig( + event_key_jmespath="powertools_json(body)", + # by default, it holds 256 items in a Least-Recently-Used (LRU) manner + use_local_cache=True, # (1)! +) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context: LambdaContext): + return event diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_payload_subset.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_payload_subset.py new file mode 100644 index 0000000000000000000000000000000000000000..c16508cbbb274c3e1e3c1afbded1fddc95def052 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_payload_subset.py @@ -0,0 +1,46 @@ +import json +import os +from dataclasses import dataclass, field +from uuid import uuid4 + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=table) + +# Deserialize JSON string under the "body" key +# then extract "user" and "product_id" data +config = IdempotencyConfig(event_key_jmespath='powertools_json(body).["user_id", "product_id"]') + + +@dataclass +class Payment: + user_id: str + product_id: str + payment_id: str = field(default_factory=lambda: f"{uuid4()}") + + +class PaymentError(Exception): ... + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event: dict, context: LambdaContext): + try: + payment_info: str = event.get("body", "") + payment: Payment = create_subscription_payment(json.loads(payment_info)) + return { + "payment_id": payment.payment_id, + "message": "success", + "statusCode": 200, + } + except Exception as exc: + raise PaymentError(f"Error creating payment {str(exc)}") + + +def create_subscription_payment(event: dict) -> Payment: + return Payment(**event) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_pydantic_deduced_output_serializer.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_pydantic_deduced_output_serializer.py new file mode 100644 index 0000000000000000000000000000000000000000..b904a5ad67047166892b8b35cd94ebc1601c4cb2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_pydantic_deduced_output_serializer.py @@ -0,0 +1,48 @@ +import os + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent_function, +) +from aws_lambda_powertools.utilities.idempotency.serialization.pydantic import PydanticSerializer +from aws_lambda_powertools.utilities.parser import BaseModel +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +dynamodb = DynamoDBPersistenceLayer(table_name=table) +config = IdempotencyConfig(event_key_jmespath="order_id") # see Choosing a payload subset section + + +class OrderItem(BaseModel): + sku: str + description: str + + +class Order(BaseModel): + item: OrderItem + order_id: int + + +class OrderOutput(BaseModel): + order_id: int + + +@idempotent_function( + data_keyword_argument="order", + config=config, + persistence_store=dynamodb, + output_serializer=PydanticSerializer, +) +# order output is inferred from return type +def process_order(order: Order) -> OrderOutput: # (1)! + return OrderOutput(order_id=order.order_id) + + +def lambda_handler(event: dict, context: LambdaContext): + config.register_lambda_context(context) # see Lambda timeouts section + order_item = OrderItem(sku="fake", description="sample") + order = Order(item=order_item, order_id=1) + + # `order` parameter must be called as a keyword argument to work + process_order(order=order) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_pydantic_explicitly_output_serializer.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_pydantic_explicitly_output_serializer.py new file mode 100644 index 0000000000000000000000000000000000000000..b888b58a87ca3f9aeff9e8bc3e2b51ca4c8cc5ba --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_pydantic_explicitly_output_serializer.py @@ -0,0 +1,47 @@ +import os + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent_function, +) +from aws_lambda_powertools.utilities.idempotency.serialization.pydantic import PydanticSerializer +from aws_lambda_powertools.utilities.parser import BaseModel +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +dynamodb = DynamoDBPersistenceLayer(table_name=table) +config = IdempotencyConfig(event_key_jmespath="order_id") # see Choosing a payload subset section + + +class OrderItem(BaseModel): + sku: str + description: str + + +class Order(BaseModel): + item: OrderItem + order_id: int + + +class OrderOutput(BaseModel): + order_id: int + + +@idempotent_function( + data_keyword_argument="order", + config=config, + persistence_store=dynamodb, + output_serializer=PydanticSerializer(model=OrderOutput), +) +def process_order(order: Order): + return OrderOutput(order_id=order.order_id) + + +def lambda_handler(event: dict, context: LambdaContext): + config.register_lambda_context(context) # see Lambda timeouts section + order_item = OrderItem(sku="fake", description="sample") + order = Order(item=order_item, order_id=1) + + # `order` parameter must be called as a keyword argument to work + process_order(order=order) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_record_expiration.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_record_expiration.py new file mode 100644 index 0000000000000000000000000000000000000000..e1696ee7bbf0bbf7ff656ee99c858a08a70cce2a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_record_expiration.py @@ -0,0 +1,20 @@ +import os + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +table = os.getenv("IDEMPOTENCY_TABLE", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=table) +config = IdempotencyConfig( + event_key_jmespath="body", + expires_after_seconds=24 * 60 * 60, # 24 hours +) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context: LambdaContext): + return event diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_record_expiration_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_record_expiration_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..d2b720442a1e50d941c376d577e3f32c59bb3177 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_record_expiration_payload.json @@ -0,0 +1,3 @@ +{ + "body": "{\"user_id\":\"xyz\",\"product_id\":\"123456789\"}" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_response_hook_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_response_hook_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..85fdd958d59d52af1eae5776d936f28f63dfefcb --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_response_hook_payload.json @@ -0,0 +1,8 @@ +{ + "order" : { + "user_id": "xyz", + "product_id": "123456789", + "quantity": 2, + "value": 30 + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload.py new file mode 100644 index 0000000000000000000000000000000000000000..12b8423e7c4900b608e630b8ef4367ea6a672461 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload.py @@ -0,0 +1,56 @@ +import os +from dataclasses import dataclass, field +from uuid import uuid4 + +from aws_lambda_powertools import Logger +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.exceptions import IdempotencyValidationError +from aws_lambda_powertools.utilities.typing import LambdaContext + +logger = Logger() + +table = os.getenv("IDEMPOTENCY_TABLE", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=table) +config = IdempotencyConfig( + event_key_jmespath='["user_id", "product_id"]', + payload_validation_jmespath="amount", +) + + +@dataclass +class Payment: + user_id: str + product_id: str + charge_type: str + amount: int + payment_id: str = field(default_factory=lambda: f"{uuid4()}") + + +class PaymentError(Exception): ... + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event: dict, context: LambdaContext): + try: + payment: Payment = create_subscription_payment(event) + return { + "payment_id": payment.payment_id, + "message": "success", + "statusCode": 200, + } + except IdempotencyValidationError: + logger.exception("Payload tampering detected", payment=payment, failure_type="validation") + return { + "message": "Unable to process payment at this time. Try again later.", + "statusCode": 500, + } + except Exception as exc: + raise PaymentError(f"Error creating payment {str(exc)}") + + +def create_subscription_payment(event: dict) -> Payment: + return Payment(**event) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload_payload1.json b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload_payload1.json new file mode 100644 index 0000000000000000000000000000000000000000..7f94aa04a0767aad54c51d1ff633c6e8801d39fd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload_payload1.json @@ -0,0 +1,6 @@ +{ + "user_id": 1, + "product_id": 1500, + "charge_type": "subscription", + "amount": 500 +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload_payload2.json b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload_payload2.json new file mode 100644 index 0000000000000000000000000000000000000000..f400627f89143345e215e66f61810b003e8c14d3 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload_payload2.json @@ -0,0 +1,6 @@ +{ + "user_id": 1, + "product_id": 1500, + "charge_type": "subscription", + "amount": 10 +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/cdk.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/cdk.py new file mode 100644 index 0000000000000000000000000000000000000000..1203d17a8d31722c3a8a6413e4ec9dec9c89e261 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/cdk.py @@ -0,0 +1,25 @@ +from aws_cdk import RemovalPolicy +from aws_cdk import aws_dynamodb as dynamodb +from aws_cdk import aws_iam as iam +from constructs import Construct + + +class IdempotencyConstruct(Construct): + def __init__(self, scope: Construct, name: str, lambda_role: iam.Role) -> None: + super().__init__(scope, name) + self.idempotency_table = dynamodb.Table( + self, + "IdempotencyTable", + partition_key=dynamodb.Attribute(name="id", type=dynamodb.AttributeType.STRING), + billing_mode=dynamodb.BillingMode.PAY_PER_REQUEST, + removal_policy=RemovalPolicy.DESTROY, + time_to_live_attribute="expiration", + point_in_time_recovery=True, + ) + self.idempotency_table.grant( + lambda_role, + "dynamodb:PutItem", + "dynamodb:GetItem", + "dynamodb:UpdateItem", + "dynamodb:DeleteItem", + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/cfn_redis_serverless.yaml b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/cfn_redis_serverless.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8ce9d67f3cb99f9beab0bfd6ae2d23a0bacab14f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/cfn_redis_serverless.yaml @@ -0,0 +1,31 @@ +AWSTemplateFormatVersion: "2010-09-09" +Transform: AWS::Serverless-2016-10-31 + +Resources: + RedisServerlessIdempotency: + Type: AWS::ElastiCache::ServerlessCache + Properties: + Engine: redis + ServerlessCacheName: redis-cache + SecurityGroupIds: # (1)! + - security-{your_sg_id} + SubnetIds: + - subnet-{your_subnet_id_1} + - subnet-{your_subnet_id_2} + + HelloWorldFunction: + Type: AWS::Serverless::Function + Properties: + Runtime: python3.12 + Handler: app.py + VpcConfig: # (1)! + SecurityGroupIds: + - security-{your_sg_id} + SubnetIds: + - subnet-{your_subnet_id_1} + - subnet-{your_subnet_id_2} + Environment: + Variables: + POWERTOOLS_SERVICE_NAME: sample + REDIS_HOST: !GetAtt RedisServerlessIdempotency.Endpoint.Address + REDIS_PORT: !GetAtt RedisServerlessIdempotency.Endpoint.Port diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/sam.yaml b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/sam.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4faab5c42257fdee3cbba12e2beaca81ade3ea16 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/sam.yaml @@ -0,0 +1,34 @@ +Transform: AWS::Serverless-2016-10-31 +Resources: + IdempotencyTable: + Type: AWS::DynamoDB::Table + Properties: + AttributeDefinitions: + - AttributeName: id + AttributeType: S + KeySchema: + - AttributeName: id + KeyType: HASH + TimeToLiveSpecification: + AttributeName: expiration + Enabled: true + BillingMode: PAY_PER_REQUEST + + HelloWorldFunction: + Type: AWS::Serverless::Function + Properties: + Runtime: python3.12 + Handler: app.py + Policies: + - Statement: + - Sid: AllowDynamodbReadWrite + Effect: Allow + Action: + - dynamodb:PutItem + - dynamodb:GetItem + - dynamodb:UpdateItem + - dynamodb:DeleteItem + Resource: !GetAtt IdempotencyTable.Arn + Environment: + Variables: + IDEMPOTENCY_TABLE: !Ref IdempotencyTable diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/terraform.tf b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/terraform.tf new file mode 100644 index 0000000000000000000000000000000000000000..61c48d83f375ebe81a9c396c1be9f7994e058f36 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/terraform.tf @@ -0,0 +1,79 @@ +terraform { + required_providers { + aws = { + source = "hashicorp/aws" + version = "~> 4.0" + } + } +} + +provider "aws" { + region = "us-east-1" # Replace with your desired AWS region +} + +resource "aws_dynamodb_table" "IdempotencyTable" { + name = "IdempotencyTable" + billing_mode = "PAY_PER_REQUEST" + hash_key = "id" + attribute { + name = "id" + type = "S" + } + ttl { + attribute_name = "expiration" + enabled = true + } +} + +resource "aws_lambda_function" "IdempotencyFunction" { + function_name = "IdempotencyFunction" + role = aws_iam_role.IdempotencyFunctionRole.arn + runtime = "python3.12" + handler = "app.lambda_handler" + filename = "lambda.zip" + +} + +resource "aws_iam_role" "IdempotencyFunctionRole" { + name = "IdempotencyFunctionRole" + + assume_role_policy = jsonencode({ + Version = "2012-10-17" + Statement = [ + { + Sid = "" + Effect = "Allow" + Principal = { + Service = "lambda.amazonaws.com" + } + Action = "sts:AssumeRole" + }, + ] + }) +} + +resource "aws_iam_policy" "LambdaDynamoDBPolicy" { + name = "LambdaDynamoDBPolicy" + description = "IAM policy for Lambda function to access DynamoDB" + policy = jsonencode({ + Version = "2012-10-17" + Statement = [ + { + Sid = "AllowDynamodbReadWrite" + Effect = "Allow" + Action = [ + "dynamodb:PutItem", + "dynamodb:GetItem", + "dynamodb:UpdateItem", + "dynamodb:DeleteItem", + ] + Resource = aws_dynamodb_table.IdempotencyTable.arn + }, + ] + }) +} + +resource "aws_iam_role_policy_attachment" "IdempotencyFunctionRoleAttachment" { + role = aws_iam_role.IdempotencyFunctionRole.name + policy_arn = aws_iam_policy.LambdaDynamoDBPolicy.arn +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_disabling_idempotency_utility.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_disabling_idempotency_utility.py new file mode 100644 index 0000000000000000000000000000000000000000..0405ea6e729e8a7eac314074e0da14c2994ec911 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_disabling_idempotency_utility.py @@ -0,0 +1,17 @@ +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + idempotent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +persistence_layer = DynamoDBPersistenceLayer(table_name="IdempotencyTable") + + +@idempotent(persistence_store=persistence_layer) +def lambda_handler(event: dict, context: LambdaContext): + print("expensive operation") + return { + "payment_id": 12345, + "message": "success", + "statusCode": 200, + } diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_dynamodb_local.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_dynamodb_local.py new file mode 100644 index 0000000000000000000000000000000000000000..0405ea6e729e8a7eac314074e0da14c2994ec911 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_dynamodb_local.py @@ -0,0 +1,17 @@ +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + idempotent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +persistence_layer = DynamoDBPersistenceLayer(table_name="IdempotencyTable") + + +@idempotent(persistence_store=persistence_layer) +def lambda_handler(event: dict, context: LambdaContext): + print("expensive operation") + return { + "payment_id": 12345, + "message": "success", + "statusCode": 200, + } diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_io_operations.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_io_operations.py new file mode 100644 index 0000000000000000000000000000000000000000..0405ea6e729e8a7eac314074e0da14c2994ec911 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_io_operations.py @@ -0,0 +1,17 @@ +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + idempotent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +persistence_layer = DynamoDBPersistenceLayer(table_name="IdempotencyTable") + + +@idempotent(persistence_store=persistence_layer) +def lambda_handler(event: dict, context: LambdaContext): + print("expensive operation") + return { + "payment_id": 12345, + "message": "success", + "statusCode": 200, + } diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/mock_redis.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/mock_redis.py new file mode 100644 index 0000000000000000000000000000000000000000..89b68e4873cc2edcd3550e080cbdb7a550341841 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/mock_redis.py @@ -0,0 +1,37 @@ +import time as t +from typing import Dict + + +# Mock redis class that includes all operations we used in Idempotency +class MockRedis: + def __init__(self, decode_responses, cache: Dict, **kwargs): + self.cache = cache or {} + self.expire_dict: Dict = {} + self.decode_responses = decode_responses + self.acl: Dict = {} + self.username = "" + + def hset(self, name, mapping): + self.expire_dict.pop(name, {}) + self.cache[name] = mapping + + def from_url(self, url: str): + pass + + def expire(self, name, time): + self.expire_dict[name] = t.time() + time + + # return {} if no match + def hgetall(self, name): + if self.expire_dict.get(name, t.time() + 1) < t.time(): + self.cache.pop(name, {}) + return self.cache.get(name, {}) + + def get_connection_kwargs(self): + return {"decode_responses": self.decode_responses} + + def auth(self, username, **kwargs): + self.username = username + + def delete(self, name): + self.cache.pop(name, {}) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_disabling_idempotency_utility.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_disabling_idempotency_utility.py new file mode 100644 index 0000000000000000000000000000000000000000..f33174cde3d6629c8bc4dfff39f21b7fe5923e8d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_disabling_idempotency_utility.py @@ -0,0 +1,28 @@ +from dataclasses import dataclass + +import app_test_disabling_idempotency_utility +import pytest + + +@pytest.fixture +def lambda_context(): + @dataclass + class LambdaContext: + function_name: str = "test" + memory_limit_in_mb: int = 128 + invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test" + aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72" + + def get_remaining_time_in_millis(self) -> int: + return 5 + + return LambdaContext() + + +def test_idempotent_lambda_handler(monkeypatch, lambda_context): + # Set POWERTOOLS_IDEMPOTENCY_DISABLED before calling decorated functions + monkeypatch.setenv("POWERTOOLS_IDEMPOTENCY_DISABLED", 1) + + result = app_test_disabling_idempotency_utility.lambda_handler({}, lambda_context) + + assert result diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_dynamodb_local.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_dynamodb_local.py new file mode 100644 index 0000000000000000000000000000000000000000..7a9a8fc023432b3a9cc9e44d69fd3a474bebd065 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_dynamodb_local.py @@ -0,0 +1,32 @@ +from dataclasses import dataclass + +import app_test_dynamodb_local +import boto3 +import pytest + + +@pytest.fixture +def lambda_context(): + @dataclass + class LambdaContext: + function_name: str = "test" + memory_limit_in_mb: int = 128 + invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test" + aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72" + + def get_remaining_time_in_millis(self) -> int: + return 5 + + return LambdaContext() + + +def test_idempotent_lambda(lambda_context): + # Configure the boto3 to use the endpoint for the DynamoDB Local instance + dynamodb_local_client = boto3.client("dynamodb", endpoint_url="http://localhost:8000") + app_test_dynamodb_local.persistence_layer.client = dynamodb_local_client + + # If desired, you can use a different DynamoDB Local table name than what your code already uses + # app.persistence_layer.table_name = "another table name" # noqa: ERA001 + + result = app_test_dynamodb_local.handler({"testkey": "testvalue"}, lambda_context) + assert result["payment_id"] == 12345 diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_io_operations.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_io_operations.py new file mode 100644 index 0000000000000000000000000000000000000000..9d455906889ff79a369c5c331af9642b9318e6d7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_io_operations.py @@ -0,0 +1,28 @@ +from dataclasses import dataclass +from unittest.mock import MagicMock + +import app_test_io_operations +import pytest + + +@pytest.fixture +def lambda_context(): + @dataclass + class LambdaContext: + function_name: str = "test" + memory_limit_in_mb: int = 128 + invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test" + aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72" + + def get_remaining_time_in_millis(self) -> int: + return 5 + + return LambdaContext() + + +def test_idempotent_lambda(lambda_context): + mock_client = MagicMock() + app_test_io_operations.persistence_layer.client = mock_client + result = app_test_io_operations.handler({"testkey": "testvalue"}, lambda_context) + mock_client.put_item.assert_called() + assert result diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_mock_redis.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_mock_redis.py new file mode 100644 index 0000000000000000000000000000000000000000..6842e818d27041517fa26eb061e51c32c3dd5a64 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_mock_redis.py @@ -0,0 +1,48 @@ +from dataclasses import dataclass + +import pytest +from mock_redis import MockRedis + +from aws_lambda_powertools.utilities.idempotency import ( + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import ( + RedisCachePersistenceLayer, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + + +@pytest.fixture +def lambda_context(): + @dataclass + class LambdaContext: + function_name: str = "test" + memory_limit_in_mb: int = 128 + invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test" + aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72" + + def get_remaining_time_in_millis(self) -> int: + return 1000 + + return LambdaContext() + + +def test_idempotent_lambda(lambda_context): + # Init the Mock redis client + redis_client = MockRedis(decode_responses=True) + # Establish persistence layer using the mock redis client + persistence_layer = RedisCachePersistenceLayer(client=redis_client) + + # setup idempotent with redis persistence layer + @idempotent(persistence_store=persistence_layer) + def lambda_handler(event: dict, context: LambdaContext): + print("expensive operation") + return { + "payment_id": 12345, + "message": "success", + "statusCode": 200, + } + + # Inovke the sim lambda handler + result = lambda_handler({"testkey": "testvalue"}, lambda_context) + assert result["payment_id"] == 12345 diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_real_redis.py b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_real_redis.py new file mode 100644 index 0000000000000000000000000000000000000000..a465592eb05415fa11cf0bbf2327b41d5c76108f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_real_redis.py @@ -0,0 +1,59 @@ +from dataclasses import dataclass + +import pytest +import redis + +from aws_lambda_powertools.utilities.idempotency import ( + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import ( + RedisCachePersistenceLayer, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + + +@pytest.fixture +def lambda_context(): + @dataclass + class LambdaContext: + function_name: str = "test" + memory_limit_in_mb: int = 128 + invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test" + aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72" + + def get_remaining_time_in_millis(self) -> int: + return 1000 + + return LambdaContext() + + +@pytest.fixture +def persistence_store_standalone_redis(): + # init a Real Redis client and connect to the Port set in the Makefile + redis_client = redis.Redis( + host="localhost", + port="63005", + decode_responses=True, + ) + + # return a persistence layer with real Redis + return RedisCachePersistenceLayer(client=redis_client) + + +def test_idempotent_lambda(lambda_context, persistence_store_standalone_redis): + # Establish persistence layer using the real redis client + persistence_layer = persistence_store_standalone_redis + + # setup idempotent with redis persistence layer + @idempotent(persistence_store=persistence_layer) + def lambda_handler(event: dict, context: LambdaContext): + print("expensive operation") + return { + "payment_id": 12345, + "message": "success", + "statusCode": 200, + } + + # Inovke the sim lambda handler + result = lambda_handler({"testkey": "testvalue"}, lambda_context) + assert result["payment_id"] == 12345 diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_builtin_envelope.json b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_builtin_envelope.json new file mode 100644 index 0000000000000000000000000000000000000000..6fe1d1655abd8f67d04583a5ca2959d464afa7fc --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_builtin_envelope.json @@ -0,0 +1,20 @@ +{ + "Records": [ + { + "messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78", + "receiptHandle": "MessageReceiptHandle", + "body": "{\"customerId\":\"dd4649e6-2484-4993-acb8-0f9123103394\",\"booking\":{\"id\":\"5b2c4803-330b-42b7-811a-c68689425de1\",\"reference\":\"ySz7oA\",\"outboundFlightId\":\"20c0d2f2-56a3-4068-bf20-ff7703db552d\"},\"payment\":{\"receipt\":\"https:\/\/pay.stripe.com\/receipts\/acct_1Dvn7pF4aIiftV70\/ch_3JTC14F4aIiftV700iFq2CHB\/rcpt_K7QsrFln9FgFnzUuBIiNdkkRYGxUL0X\",\"amount\":100}}", + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1523232000000", + "SenderId": "123456789012", + "ApproximateFirstReceiveTimestamp": "1523232000001" + }, + "messageAttributes": {}, + "md5OfBody": "7b270e59b47ff90a553787216d55d91d", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:MyQueue", + "awsRegion": "us-east-1" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_builtin_envelope.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_builtin_envelope.py new file mode 100644 index 0000000000000000000000000000000000000000..be8ecd407261347164185e03538affceae0e9438 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_builtin_envelope.py @@ -0,0 +1,18 @@ +from __future__ import annotations + +from aws_lambda_powertools import Logger +from aws_lambda_powertools.utilities.jmespath_utils import ( + envelopes, + query, +) +from aws_lambda_powertools.utilities.typing import LambdaContext + +logger = Logger() + + +def handler(event: dict, context: LambdaContext) -> dict: + records: list = query(data=event, envelope=envelopes.SQS) + for record in records: # records is a list + logger.info(record.get("customerId")) # now deserialized + + return {"message": "success", "statusCode": 200} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_envelope.json b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_envelope.json new file mode 100644 index 0000000000000000000000000000000000000000..0a0f076327902f9b0adbecc8d8c39406d72d55e1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_envelope.json @@ -0,0 +1,12 @@ +{ + "body": "{\"customerId\":\"dd4649e6-2484-4993-acb8-0f9123103394\"}", + "deeply_nested": [ + { + "some_data": [ + 1, + 2, + 3 + ] + } + ] +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_function.py new file mode 100644 index 0000000000000000000000000000000000000000..b73e794ed742f2c44fff0eda9f1b8438322b2959 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_function.py @@ -0,0 +1,41 @@ +import base64 +import binascii +import gzip +import json + +import powertools_base64_gzip_jmespath_schema as schemas +from jmespath.exceptions import JMESPathTypeError + +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate + + +def lambda_handler(event, context: LambdaContext) -> dict: + try: + validate(event=event, schema=schemas.INPUT, envelope="powertools_base64_gzip(payload) | powertools_json(@)") + + # Alternatively, query works here too + encoded_payload = base64.b64decode(event["payload"]) + uncompressed_payload = gzip.decompress(encoded_payload).decode() + log: dict = json.loads(uncompressed_payload) + + return { + "message": "Logs processed", + "log_group": log.get("logGroup"), + "owner": log.get("owner"), + "success": True, + } + + except JMESPathTypeError: + return return_error_message("The powertools_base64_gzip() envelope function must match a valid path.") + except binascii.Error: + return return_error_message("Payload must be a valid base64 encoded string") + except json.JSONDecodeError: + return return_error_message("Payload must be valid JSON (base64 encoded).") + except SchemaValidationError as exception: + # SchemaValidationError indicates where a data mismatch is + return return_error_message(str(exception)) + + +def return_error_message(message: str) -> dict: + return {"message": message, "success": False} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..13995523099056d0cf2c4793c6e573731df53801 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_payload.json @@ -0,0 +1,3 @@ +{ + "payload": "H4sIACZAXl8C/52PzUrEMBhFX2UILpX8tPbHXWHqIOiq3Q1F0ubrWEiakqTWofTdTYYB0YWL2d5zvnuTFellBIOedoiyKH5M0iwnlKH7HZL6dDB6ngLDfLFYctUKjie9gHFaS/sAX1xNEq525QxwFXRGGMEkx4Th491rUZdV3YiIZ6Ljfd+lfSyAtZloacQgAkqSJCGhxM6t7cwwuUGPz4N0YKyvO6I9WDeMPMSo8Z4Ca/kJ6vMEYW5f1MX7W1lVxaG8vqX8hNFdjlc0iCBBSF4ERT/3Pl7RbMGMXF2KZMh/C+gDpNS7RRsp0OaRGzx0/t8e0jgmcczyLCWEePhni/23JWalzjdu0a3ZvgEaNLXeugEAAA==" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..d95a295df692069a0c2547c6bcddbf3b500f29cd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_schema.py @@ -0,0 +1,47 @@ +INPUT = { + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "http://example.com/example.json", + "type": "object", + "title": "Sample schema", + "description": "The root schema comprises the entire JSON document.", + "examples": [ + { + "owner": "123456789012", + "logGroup": "/aws/lambda/powertools-example", + "logStream": "2022/08/07/[$LATEST]d3a8dcaffc7f4de2b8db132e3e106660", + "logEvents": {}, + }, + ], + "required": ["owner", "logGroup", "logStream", "logEvents"], + "properties": { + "owner": { + "$id": "#/properties/owner", + "type": "string", + "title": "The owner", + "examples": ["123456789012"], + "maxLength": 12, + }, + "logGroup": { + "$id": "#/properties/logGroup", + "type": "string", + "title": "The logGroup", + "examples": ["/aws/lambda/powertools-example"], + "maxLength": 100, + }, + "logStream": { + "$id": "#/properties/logStream", + "type": "string", + "title": "The logGroup", + "examples": ["2022/08/07/[$LATEST]d3a8dcaffc7f4de2b8db132e3e106660"], + "maxLength": 100, + }, + "logEvents": { + "$id": "#/properties/logEvents", + "type": "array", + "title": "The logEvents", + "examples": [ + "{'id': 'eventId1', 'message': {'username': 'lessa', 'message': 'hello world'}, 'timestamp': 1440442987000}" # noqa E501 + ], + }, + }, +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_function.py new file mode 100644 index 0000000000000000000000000000000000000000..85c8fb171373acd04263a6aa6d5b893b37cd59b0 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_function.py @@ -0,0 +1,62 @@ +import base64 +import binascii +import json +from dataclasses import asdict, dataclass, field, is_dataclass +from uuid import uuid4 + +import powertools_base64_jmespath_schema as schemas +from jmespath.exceptions import JMESPathTypeError + +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate + + +@dataclass +class Order: + user_id: int + product_id: int + quantity: int + price: float + currency: str + order_id: str = field(default_factory=lambda: f"{uuid4()}") + + +class DataclassCustomEncoder(json.JSONEncoder): + """A custom JSON encoder to serialize dataclass obj""" + + def default(self, obj): + # Only called for values that aren't JSON serializable + # where `obj` will be an instance of Todo in this example + return asdict(obj) if is_dataclass(obj) else super().default(obj) + + +def lambda_handler(event, context: LambdaContext) -> dict: + # Try to validate the schema + try: + validate(event=event, schema=schemas.INPUT, envelope="powertools_json(powertools_base64(payload))") + + # alternatively, query works here too + payload_decoded = base64.b64decode(event["payload"]).decode() + + order_payload: dict = json.loads(payload_decoded) + + return { + "order": json.dumps(Order(**order_payload), cls=DataclassCustomEncoder), + "message": "order created", + "success": True, + } + except JMESPathTypeError: + return return_error_message( + "The powertools_json(powertools_base64()) envelope function must match a valid path.", + ) + except binascii.Error: + return return_error_message("Payload must be a valid base64 encoded string") + except json.JSONDecodeError: + return return_error_message("Payload must be valid JSON (base64 encoded).") + except SchemaValidationError as exception: + # SchemaValidationError indicates where a data mismatch is + return return_error_message(str(exception)) + + +def return_error_message(message: str) -> dict: + return {"order": None, "message": message, "success": False} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..b4ea41d1d09cbaf6e1efe4ceeb2f3fb052045bd2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_payload.json @@ -0,0 +1,3 @@ +{ + "payload":"eyJ1c2VyX2lkIjogMTIzLCAicHJvZHVjdF9pZCI6IDEsICJxdWFudGl0eSI6IDIsICJwcmljZSI6IDEwLjQwLCAiY3VycmVuY3kiOiAiVVNEIn0=" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..bd643a11c13439fdc05001f9c6d9a53dbeed3754 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_schema.py @@ -0,0 +1,46 @@ +INPUT = { + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "http://example.com/example.json", + "type": "object", + "title": "Sample order schema", + "description": "The root schema comprises the entire JSON document.", + "examples": [{"user_id": 123, "product_id": 1, "quantity": 2, "price": 10.40, "currency": "USD"}], + "required": ["user_id", "product_id", "quantity", "price", "currency"], + "properties": { + "user_id": { + "$id": "#/properties/user_id", + "type": "integer", + "title": "The unique identifier of the user", + "examples": [123], + "maxLength": 10, + }, + "product_id": { + "$id": "#/properties/product_id", + "type": "integer", + "title": "The unique identifier of the product", + "examples": [1], + "maxLength": 10, + }, + "quantity": { + "$id": "#/properties/quantity", + "type": "integer", + "title": "The quantity of the product", + "examples": [2], + "maxLength": 10, + }, + "price": { + "$id": "#/properties/price", + "type": "number", + "title": "The individual price of the product", + "examples": [10.40], + "maxLength": 10, + }, + "currency": { + "$id": "#/properties/currency", + "type": "string", + "title": "The currency", + "examples": ["The currency of the order"], + "maxLength": 100, + }, + }, +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_custom_jmespath_function.json b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_custom_jmespath_function.json new file mode 100644 index 0000000000000000000000000000000000000000..ca77505d8ed9d3cebcbef911231f892c8b21eef0 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_custom_jmespath_function.json @@ -0,0 +1,9 @@ +{ + "Records": [ + { + "application": "notification", + "datetime": "2022-01-01T00:00:00.000Z", + "log": "eJxtUNFOwkAQ/JXN+dJq6e22tMD5ZHwQRYSEJpqQhtRy2AvlWq+tEr/eg6DExOzDJjM7M5tZsgCDgGPMKQaKRRAJRFjmRrUphBjRcIQXpy3gkiCvtJZ567jQVkDBwEc7JCK0sk2mSrkGh0IBc2l2qmlUpWEttZJrFz4LS/8YKP12cOjqpjUy23mQl0rqVpw9PWik+ZBGwMoDI9872ViazebJ/expARzGSTLn5BPzfm0sX7RtLTj/+xq3N0V11J+JITELnwHo2VlSzB86zQ+1CFtIiIJGcIWEmP4bDgH2AYH1GLBp9aXKMuORj+C8EF3Do9LdHvbDeBX3Xbip61I+y9eJankUDvwwBmcyTqaPHpRqK+FO5tvKhdvCVDvJCYPjYwiLbJMZdZKwQxZL02+NI3Vs" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_custom_jmespath_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_custom_jmespath_function.py new file mode 100644 index 0000000000000000000000000000000000000000..98eefbe9958fd7480762983ee40f45c7cea30fce --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_custom_jmespath_function.py @@ -0,0 +1,47 @@ +import base64 +import binascii +import zlib + +from jmespath.exceptions import JMESPathTypeError +from jmespath.functions import signature + +from aws_lambda_powertools.utilities.jmespath_utils import ( + PowertoolsFunctions, + query, +) + + +class CustomFunctions(PowertoolsFunctions): + # only decode if value is a string + # see supported data types: https://jmespath.org/specification.html#built-in-functions + @signature({"types": ["string"]}) + def _func_decode_zlib_compression(self, payload: str): + decoded: bytes = base64.b64decode(payload) + return zlib.decompress(decoded) + + +custom_jmespath_options = {"custom_functions": CustomFunctions()} + + +def lambda_handler(event, context) -> dict: + try: + logs = [] + logs.append( + query( + data=event, + # NOTE: Use the prefix `_func_` before the name of the function + envelope="Records[*].decode_zlib_compression(log)", + jmespath_options=custom_jmespath_options, + ), + ) + return {"logs": logs, "message": "Extracted messages", "success": True} + except JMESPathTypeError: + return return_error_message("The envelope function must match a valid path.") + except zlib.error: + return return_error_message("Log must be a valid zlib compressed message") + except binascii.Error: + return return_error_message("Log must be a valid base64 encoded string") + + +def return_error_message(message: str) -> dict: + return {"logs": None, "message": message, "success": False} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_idempotency_jmespath.json b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_idempotency_jmespath.json new file mode 100644 index 0000000000000000000000000000000000000000..31d61c3183979a1d72e30fa937637abfb122d7c7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_idempotency_jmespath.json @@ -0,0 +1,30 @@ +{ + "version":"2.0", + "routeKey":"ANY /createpayment", + "rawPath":"/createpayment", + "rawQueryString":"", + "headers": { + "Header1": "value1", + "Header2": "value2" + }, + "requestContext":{ + "accountId":"123456789012", + "apiId":"api-id", + "domainName":"id.execute-api.us-east-1.amazonaws.com", + "domainPrefix":"id", + "http":{ + "method":"POST", + "path":"/createpayment", + "protocol":"HTTP/1.1", + "sourceIp":"ip", + "userAgent":"agent" + }, + "requestId":"id", + "routeKey":"ANY /createpayment", + "stage":"$default", + "time":"10/Feb/2021:13:40:43 +0000", + "timeEpoch":1612964443723 + }, + "body":"{\"user\":\"xyz\",\"product_id\":\"123456789\"}", + "isBase64Encoded":false + } diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_idempotency_jmespath.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_idempotency_jmespath.py new file mode 100644 index 0000000000000000000000000000000000000000..776d54857411c2e4c4812319141eb58d578e32f1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_idempotency_jmespath.py @@ -0,0 +1,38 @@ +import json +from uuid import uuid4 + +import requests + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) + +persistence_layer = DynamoDBPersistenceLayer(table_name="IdempotencyTable") + +# Treat everything under the "body" key +# in the event json object as our payload +config = IdempotencyConfig(event_key_jmespath="powertools_json(body)") + + +class PaymentError(Exception): + ... + + +@idempotent(config=config, persistence_store=persistence_layer) +def handler(event, context) -> dict: + body = json.loads(event["body"]) + try: + payment: dict = create_subscription_payment(user=body["user"], product_id=body["product_id"]) + return {"payment_id": payment.get("id"), "message": "success", "statusCode": 200} + except requests.HTTPError as e: + raise PaymentError("Unable to create payment subscription") from e + + +def create_subscription_payment(user: str, product_id: str) -> dict: + payload = {"user": user, "product_id": product_id} + ret: requests.Response = requests.post(url="https://httpbin.org/anything", data=payload) + ret.raise_for_status() + + return {"id": f"{uuid4()}", "message": "paid"} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_function.py new file mode 100644 index 0000000000000000000000000000000000000000..ab84c6783af8b282dbb2ce76b659f54925026359 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_function.py @@ -0,0 +1,56 @@ +import json +from dataclasses import asdict, dataclass, field, is_dataclass +from uuid import uuid4 + +import powertools_json_jmespath_schema as schemas +from jmespath.exceptions import JMESPathTypeError + +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate + + +@dataclass +class Order: + user_id: int + product_id: int + quantity: int + price: float + currency: str + order_id: str = field(default_factory=lambda: f"{uuid4()}") + + +class DataclassCustomEncoder(json.JSONEncoder): + """A custom JSON encoder to serialize dataclass obj""" + + def default(self, obj): + # Only called for values that aren't JSON serializable + # where `obj` will be an instance of Order in this example + return asdict(obj) if is_dataclass(obj) else super().default(obj) + + +def lambda_handler(event, context: LambdaContext) -> dict: + try: + # Validate order against our schema + validate(event=event, schema=schemas.INPUT, envelope="powertools_json(payload)") + + # Deserialize JSON string order as dict + # alternatively, query works here too + order_payload: dict = json.loads(event.get("payload")) + + return { + "order": json.dumps(Order(**order_payload), cls=DataclassCustomEncoder), + "message": "order created", + "success": True, + } + except JMESPathTypeError: + # The powertools_json() envelope function must match a valid path + return return_error_message("Invalid request.") + except SchemaValidationError as exception: + # SchemaValidationError indicates where a data mismatch is + return return_error_message(str(exception)) + except json.JSONDecodeError: + return return_error_message("Payload must be valid JSON (base64 encoded).") + + +def return_error_message(message: str) -> dict: + return {"order": None, "message": message, "success": False} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..647583bba824ecf13507af397dcd01dfddcc42ec --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_payload.json @@ -0,0 +1,3 @@ +{ + "payload":"{\"user_id\": 123, \"product_id\": 1, \"quantity\": 2, \"price\": 10.40, \"currency\": \"USD\"}" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..bd643a11c13439fdc05001f9c6d9a53dbeed3754 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_schema.py @@ -0,0 +1,46 @@ +INPUT = { + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "http://example.com/example.json", + "type": "object", + "title": "Sample order schema", + "description": "The root schema comprises the entire JSON document.", + "examples": [{"user_id": 123, "product_id": 1, "quantity": 2, "price": 10.40, "currency": "USD"}], + "required": ["user_id", "product_id", "quantity", "price", "currency"], + "properties": { + "user_id": { + "$id": "#/properties/user_id", + "type": "integer", + "title": "The unique identifier of the user", + "examples": [123], + "maxLength": 10, + }, + "product_id": { + "$id": "#/properties/product_id", + "type": "integer", + "title": "The unique identifier of the product", + "examples": [1], + "maxLength": 10, + }, + "quantity": { + "$id": "#/properties/quantity", + "type": "integer", + "title": "The quantity of the product", + "examples": [2], + "maxLength": 10, + }, + "price": { + "$id": "#/properties/price", + "type": "number", + "title": "The individual price of the product", + "examples": [10.40], + "maxLength": 10, + }, + "currency": { + "$id": "#/properties/currency", + "type": "string", + "title": "The currency", + "examples": ["The currency of the order"], + "maxLength": 100, + }, + }, +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/query.py b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/query.py new file mode 100644 index 0000000000000000000000000000000000000000..1168cd7a40d144073f7b44451f5e7a987472ef1b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/query.py @@ -0,0 +1,12 @@ +from aws_lambda_powertools.utilities.jmespath_utils import query +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def handler(event: dict, context: LambdaContext) -> dict: + payload = query(data=event, envelope="powertools_json(body)") + customer_id = payload.get("customerId") # now deserialized + + # also works for fetching and flattening deeply nested data + some_data = query(data=event, envelope="deeply_nested[*].some_data[]") + + return {"customer_id": customer_id, "message": "success", "context": some_data, "statusCode": 200} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_extra.py b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_extra.py new file mode 100644 index 0000000000000000000000000000000000000000..066bff9f084c5aabeabc8304dba878c1dbd526a2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_extra.py @@ -0,0 +1,11 @@ +from aws_lambda_powertools import Logger +from aws_lambda_powertools.utilities.typing import LambdaContext + +logger = Logger() + + +def lambda_handler(event: dict, context: LambdaContext) -> str: + fields = {"request_id": "1123"} + logger.info("Collecting payment", extra=fields) + + return "hello world" diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_kwargs.py b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_kwargs.py new file mode 100644 index 0000000000000000000000000000000000000000..285e0c154710215a32efb2e168d4c780ef486055 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_kwargs.py @@ -0,0 +1,10 @@ +from aws_lambda_powertools import Logger +from aws_lambda_powertools.utilities.typing import LambdaContext + +logger = Logger() + + +def lambda_handler(event: dict, context: LambdaContext) -> str: + logger.info("Collecting payment", request_id="1123") + + return "hello world" diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_output.json b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_output.json new file mode 100644 index 0000000000000000000000000000000000000000..b4eb223484c5fc490dcfe3ba83286babaa25bb20 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_output.json @@ -0,0 +1,8 @@ +{ + "level": "INFO", + "location": "collect.handler:11", + "message": "Collecting payment", + "timestamp": "2021-05-03 11:47:12,494+0000", + "service": "payment", + "order_id": "order_id_value" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_formatter_from_scratch.py b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_formatter_from_scratch.py new file mode 100644 index 0000000000000000000000000000000000000000..425f00b0d28edc2e2f313bfbaa262ac19af835d1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_formatter_from_scratch.py @@ -0,0 +1,46 @@ +import json +import logging +from typing import Any, Dict, Iterable, List, Optional + +from aws_lambda_powertools import Logger +from aws_lambda_powertools.logging.formatter import BasePowertoolsFormatter + + +class CustomFormatter(BasePowertoolsFormatter): + def __init__(self, log_record_order: Optional[List[str]] = None, *args, **kwargs): + self.log_record_order = log_record_order or ["level", "location", "message", "timestamp"] + self.log_format = dict.fromkeys(self.log_record_order) + super().__init__(*args, **kwargs) + + def append_keys(self, **additional_keys): + # also used by `inject_lambda_context` decorator + self.log_format.update(additional_keys) + + def current_keys(self) -> Dict[str, Any]: + return self.log_format + + def remove_keys(self, keys: Iterable[str]): + for key in keys: + self.log_format.pop(key, None) + + def clear_state(self): + self.log_format = dict.fromkeys(self.log_record_order) + + def format(self, record: logging.LogRecord) -> str: # noqa: A003 + """Format logging record as structured JSON str""" + return json.dumps( + { + "event": super().format(record), + "timestamp": self.formatTime(record), + "my_default_key": "test", + **self.log_format, + }, + ) + + +logger = Logger(service="payment", logger_formatter=CustomFormatter()) + + +@logger.inject_lambda_context +def lambda_handler(event, context): + logger.info("Collecting payment") diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_formatter_from_scratch_output.json b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_formatter_from_scratch_output.json new file mode 100644 index 0000000000000000000000000000000000000000..34494ad55f8b3d3557f38645d7aed6aca0d3a78e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_formatter_from_scratch_output.json @@ -0,0 +1,10 @@ +{ + "event": "Collecting payment", + "timestamp": "2021-05-03 11:47:12,494", + "my_default_key": "test", + "cold_start": true, + "function_name": "test", + "function_memory_size": 128, + "function_arn": "arn:aws:lambda:eu-west-1:12345678910:function:test", + "function_request_id": "52fdfc07-2182-154f-163f-5f0f9a621d72" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_json_serializer.py b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_json_serializer.py new file mode 100644 index 0000000000000000000000000000000000000000..7954cb3eb9008847176b78780921c31cc6b73725 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/bring_your_own_json_serializer.py @@ -0,0 +1,19 @@ +import functools + +import orjson + +from aws_lambda_powertools import Logger + +custom_serializer = orjson.dumps +custom_deserializer = orjson.loads + +logger = Logger(service="payment", json_serializer=custom_serializer, json_deserializer=custom_deserializer) + +# NOTE: when using parameters, you can pass a partial +custom_serializer_with_parameters = functools.partial(orjson.dumps, option=orjson.OPT_SERIALIZE_NUMPY) + +logger_two = Logger( + service="payment", + json_serializer=custom_serializer_with_parameters, + json_deserializer=custom_deserializer, +) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/clear_state.py b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/clear_state.py new file mode 100644 index 0000000000000000000000000000000000000000..4cfa44a3ae81770207674eb3d2b6a816ea7d6a2d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/clear_state.py @@ -0,0 +1,16 @@ +from aws_lambda_powertools import Logger +from aws_lambda_powertools.utilities.typing import LambdaContext + +logger = Logger() + + +@logger.inject_lambda_context(clear_state=True) +def lambda_handler(event: dict, context: LambdaContext) -> str: + if event.get("special_key"): + # Should only be available in the first request log + # as the second request doesn't contain `special_key` + logger.append_keys(debugging_key="value") + + logger.info("Collecting payment") + + return "hello world" diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/date_formatting_output.json b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/date_formatting_output.json new file mode 100644 index 0000000000000000000000000000000000000000..6adebb0de2a59969c6d9f797dee86ad4deef2da8 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/date_formatting_output.json @@ -0,0 +1,16 @@ +[ + { + "level": "INFO", + "location": ":6", + "message": "Collecting payment", + "timestamp": "2022-10-28T14:35:03.210+00:00", + "service": "payment" + }, + { + "level": "INFO", + "location": ":9", + "message": "Calculating points", + "timestamp": "10/28/2022 02:35:03 PM", + "service": "loyalty" + } +] \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/fake_lambda_context_for_logger_module.py b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/fake_lambda_context_for_logger_module.py new file mode 100644 index 0000000000000000000000000000000000000000..f5140febaba7bd6cb390fe3b41eb8fbbae2d733b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/logger/src/fake_lambda_context_for_logger_module.py @@ -0,0 +1,11 @@ +from aws_lambda_powertools import Logger +from aws_lambda_powertools.utilities.typing import LambdaContext + +logger = Logger() + + +@logger.inject_lambda_context +def lambda_handler(event: dict, context: LambdaContext) -> str: + logger.info("Collecting payment") + + return "hello world" diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/parser/src/sqs_model_event.py b/testbed/aws-powertools__powertools-lambda-python/examples/parser/src/sqs_model_event.py new file mode 100644 index 0000000000000000000000000000000000000000..8093a230df683381d3496e25328b36bd341ef596 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/parser/src/sqs_model_event.py @@ -0,0 +1,17 @@ +from aws_lambda_powertools.utilities.parser import parse +from aws_lambda_powertools.utilities.parser.models import SqsModel +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def lambda_handler(event: dict, context: LambdaContext) -> list: + parsed_event = parse(model=SqsModel, event=event) + + results = [] + for record in parsed_event.Records: + results.append( + { + "message_id": record.messageId, + "body": record.body, + }, + ) + return results diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/assert_transformation.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/assert_transformation.py new file mode 100644 index 0000000000000000000000000000000000000000..a982c7f2c33bbca256e7a9c2089c778560a82eca --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/assert_transformation.py @@ -0,0 +1,36 @@ +import io + +import boto3 +from assert_transformation_module import UpperTransform +from botocore import stub + +from aws_lambda_powertools.utilities.streaming import S3Object +from aws_lambda_powertools.utilities.streaming.compat import PowertoolsStreamingBody + + +def test_upper_transform(): + # GIVEN + data_stream = io.BytesIO(b"hello world") + # WHEN + data_stream = UpperTransform().transform(data_stream) + # THEN + assert data_stream.read() == b"HELLO WORLD" + + +def test_s3_object_with_upper_transform(): + # GIVEN + payload = b"hello world" + s3_client = boto3.client("s3") + s3_stub = stub.Stubber(s3_client) + s3_stub.add_response( + "get_object", + {"Body": PowertoolsStreamingBody(raw_stream=io.BytesIO(payload), content_length=len(payload))}, + ) + s3_stub.activate() + + # WHEN + data_stream = S3Object(bucket="bucket", key="key", boto3_client=s3_client) + data_stream.transform(UpperTransform(), in_place=True) + + # THEN + assert data_stream.read() == b"HELLO WORLD" diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_basic_stream.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_basic_stream.py new file mode 100644 index 0000000000000000000000000000000000000000..b8adb8ed6839c79f4be90feced6bea1ba413393d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_basic_stream.py @@ -0,0 +1,10 @@ +from typing import Dict + +from aws_lambda_powertools.utilities.streaming.s3_object import S3Object +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def lambda_handler(event: Dict[str, str], context: LambdaContext): + s3 = S3Object(bucket=event["bucket"], key=event["key"]) + for line in s3: + print(line) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_basic_stream_with_version.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_basic_stream_with_version.py new file mode 100644 index 0000000000000000000000000000000000000000..78a93e51c381e515fd3f314dd47f8be324e0d0ba --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_basic_stream_with_version.py @@ -0,0 +1,10 @@ +from typing import Dict + +from aws_lambda_powertools.utilities.streaming.s3_object import S3Object +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def lambda_handler(event: Dict[str, str], context: LambdaContext): + s3 = S3Object(bucket=event["bucket"], key=event["key"], version_id=event["version_id"]) + for line in s3: + print(line) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_csv_stream_seek.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_csv_stream_seek.py new file mode 100644 index 0000000000000000000000000000000000000000..6b48b9df13a1590f0413a32abee012940fc6238f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_csv_stream_seek.py @@ -0,0 +1,35 @@ +import io +from typing import Dict + +from aws_lambda_powertools.utilities.streaming.s3_object import S3Object +from aws_lambda_powertools.utilities.streaming.transformations import CsvTransform +from aws_lambda_powertools.utilities.typing import LambdaContext + +""" +Assuming the CSV files contains rows after the header always has 8 bytes + 1 byte newline: + +reading,position,type +21.3,5,+ +23.4,4,+ +21.3,0,- +... +""" + +CSV_HEADERS = ["reading", "position", "type"] +ROW_SIZE = 8 + 1 # 1 byte newline +HEADER_SIZE = 21 + 1 # 1 byte newline +LINES_TO_JUMP = 100 + + +def lambda_handler(event: Dict[str, str], context: LambdaContext): + sample_csv = S3Object(bucket=event["bucket"], key=event["key"]) + + # Skip the header line + sample_csv.seek(HEADER_SIZE, io.SEEK_SET) + + # Jump 100 lines of 9 bytes each (8 bytes of data + 1 byte newline) + sample_csv.seek(LINES_TO_JUMP * ROW_SIZE, io.SEEK_CUR) + + sample_csv.transform(CsvTransform(), in_place=True) + for row in sample_csv: + print(row["reading"]) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_json_transform.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_json_transform.py new file mode 100644 index 0000000000000000000000000000000000000000..30c31b0f32c7464f72f8f9135d9ff5f20c8432b4 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_json_transform.py @@ -0,0 +1,29 @@ +import io +from typing import IO, Optional + +import ijson + +from aws_lambda_powertools.utilities.streaming.transformations import BaseTransform + + +# Using io.RawIOBase gets us default implementations of many of the common IO methods +class JsonDeserializer(io.RawIOBase): + def __init__(self, input_stream: IO[bytes]): + self.input = ijson.items(input_stream, "", multiple_values=True) + + def read(self, size: int = -1) -> Optional[bytes]: + raise NotImplementedError(f"{__name__} does not implement read") + + def readline(self, size: Optional[int] = None) -> bytes: + raise NotImplementedError(f"{__name__} does not implement readline") + + def read_object(self) -> dict: + return self.input.__next__() + + def __next__(self): + return self.read_object() + + +class JsonTransform(BaseTransform): + def transform(self, input_stream: IO[bytes]) -> JsonDeserializer: + return JsonDeserializer(input_stream=input_stream) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_common.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_common.py new file mode 100644 index 0000000000000000000000000000000000000000..b7cc570f98fa9a07da61fd5034d9765df0e210fb --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_common.py @@ -0,0 +1,10 @@ +from typing import Dict + +from aws_lambda_powertools.utilities.streaming.s3_object import S3Object +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def lambda_handler(event: Dict[str, str], context: LambdaContext): + s3 = S3Object(bucket=event["bucket"], key=event["key"], is_gzip=True, is_csv=True) + for line in s3: + print(line) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_lzma.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_lzma.py new file mode 100644 index 0000000000000000000000000000000000000000..01cb3b221612b3cfc6a893bdf3b0316ca0ac5da3 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_lzma.py @@ -0,0 +1,15 @@ +import zipfile +from typing import Dict + +from aws_lambda_powertools.utilities.streaming.s3_object import S3Object +from aws_lambda_powertools.utilities.streaming.transformations import ZipTransform +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def lambda_handler(event: Dict[str, str], context: LambdaContext): + s3 = S3Object(bucket=event["bucket"], key=event["key"]) + + zf = s3.transform(ZipTransform(compression=zipfile.ZIP_LZMA)) + + print(zf.nameslist()) + zf.extract(zf.namelist()[0], "/tmp") diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_tsv.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_tsv.py new file mode 100644 index 0000000000000000000000000000000000000000..d76f751652a62bf5d2d0524c594a55667d7f3831 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_tsv.py @@ -0,0 +1,13 @@ +from typing import Dict + +from aws_lambda_powertools.utilities.streaming.s3_object import S3Object +from aws_lambda_powertools.utilities.streaming.transformations import CsvTransform +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def lambda_handler(event: Dict[str, str], context: LambdaContext): + s3 = S3Object(bucket=event["bucket"], key=event["key"]) + + tsv_stream = s3.transform(CsvTransform(delimiter="\t")) + for obj in tsv_stream: + print(obj) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_zipfile.py b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_zipfile.py new file mode 100644 index 0000000000000000000000000000000000000000..276be7333a36d671b6abd850d422ddfa525b546d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/s3_transform_zipfile.py @@ -0,0 +1,8 @@ +from aws_lambda_powertools.utilities.streaming import S3Object +from aws_lambda_powertools.utilities.streaming.transformations import ZipTransform + +s3object = S3Object(bucket="bucket", key="key") +zip_reader = s3object.transform(ZipTransform()) +with zip_reader.open("filename.txt") as f: + for line in f: + print(line) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/uniform_sample.csv b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/uniform_sample.csv new file mode 100644 index 0000000000000000000000000000000000000000..59fe4c990a51f62bcde3cc9c0a9274dd98f170d3 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/streaming/src/uniform_sample.csv @@ -0,0 +1,4 @@ +reading,position,type +21.3,5,+ +23.4,4,+ +21.3,0,- \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/sam/template.yaml b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/sam/template.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c41c6f7f57b6033ea7c5f4869c6b8959e3be9c96 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/sam/template.yaml @@ -0,0 +1,23 @@ +AWSTemplateFormatVersion: "2010-09-09" +Transform: AWS::Serverless-2016-10-31 +Description: Powertools for AWS Lambda (Python) version + +Globals: + Function: + Timeout: 5 + Runtime: python3.12 + Tracing: Active + Environment: + Variables: + POWERTOOLS_SERVICE_NAME: payment + Layers: + # Find the latest Layer version in the official documentation + # https://docs.powertools.aws.dev/lambda/python/latest/#lambda-layer + - !Sub arn:aws:lambda:${AWS::Region}:017000801446:layer:AWSLambdaPowertoolsPythonV3-python312-x86_64:4 + +Resources: + CaptureLambdaHandlerExample: + Type: AWS::Serverless::Function + Properties: + CodeUri: ../src + Handler: capture_lambda_handler.handler diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_lambda_handler.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_lambda_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..8ca2503076af8acc5e38b06e00bbf8b90bb9e718 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_lambda_handler.py @@ -0,0 +1,15 @@ +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() # Sets service via POWERTOOLS_SERVICE_NAME env var +# OR tracer = Tracer(service="example") + + +def collect_payment(charge_id: str) -> str: + return f"dummy payment collected for charge: {charge_id}" + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + return collect_payment(charge_id=charge_id) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method.py new file mode 100644 index 0000000000000000000000000000000000000000..da50356b56cfbaff72b9953f67bdc9cae3b67076 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method.py @@ -0,0 +1,16 @@ +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +@tracer.capture_method +def collect_payment(charge_id: str) -> str: + tracer.put_annotation(key="PaymentId", value=charge_id) + return f"dummy payment collected for charge: {charge_id}" + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + return collect_payment(charge_id=charge_id) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method_async_concurrency.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method_async_concurrency.py new file mode 100644 index 0000000000000000000000000000000000000000..0afd965d35e434914ddfee40cdf738a99d6bd2d2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method_async_concurrency.py @@ -0,0 +1,31 @@ +import asyncio + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +async def another_async_task(): + async with tracer.provider.in_subsegment_async("## another_async_task") as subsegment: + subsegment.put_annotation(key="key", value="value") + subsegment.put_metadata(key="key", value="value", namespace="namespace") + ... + + +async def another_async_task_2(): + async with tracer.provider.in_subsegment_async("## another_async_task_2") as subsegment: + subsegment.put_annotation(key="key", value="value") + subsegment.put_metadata(key="key", value="value", namespace="namespace") + ... + + +async def collect_payment(charge_id: str) -> str: + await asyncio.gather(another_async_task(), another_async_task_2()) + return f"dummy payment collected for charge: {charge_id}" + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + return asyncio.run(collect_payment(charge_id=charge_id)) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method_generators.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method_generators.py new file mode 100644 index 0000000000000000000000000000000000000000..7c02f810a2740e22b09113ba4c7c1d6d58861db6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/capture_method_generators.py @@ -0,0 +1,17 @@ +from collections.abc import Generator + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +@tracer.capture_method +def collect_payment(charge_id: str) -> Generator[str, None, None]: + yield f"dummy payment collected for charge: {charge_id}" + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + return next(collect_payment(charge_id=charge_id)) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_error.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_error.py new file mode 100644 index 0000000000000000000000000000000000000000..59fc2d2376ae13a6f222024b31ff2de043dfc985 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_error.py @@ -0,0 +1,31 @@ +import os + +import requests + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() +ENDPOINT = os.getenv("PAYMENT_API", "") + + +class PaymentError(Exception): + ... + + +@tracer.capture_method(capture_error=False) +def collect_payment(charge_id: str) -> dict: + try: + ret = requests.post(url=f"{ENDPOINT}/collect", data={"charge_id": charge_id}) + ret.raise_for_status() + return ret.json() + except requests.HTTPError as e: + raise PaymentError(f"Unable to collect payment for charge {charge_id}") from e + + +@tracer.capture_lambda_handler(capture_error=False) +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + ret = collect_payment(charge_id=charge_id) + + return ret.get("receipt_id", "") diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_response.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_response.py new file mode 100644 index 0000000000000000000000000000000000000000..7e3554c4d819ced94a1ac83b719218566f9ca1e1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_response.py @@ -0,0 +1,18 @@ +from aws_lambda_powertools import Logger, Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() +logger = Logger() + + +@tracer.capture_method(capture_response=False) +def collect_payment(charge_id: str) -> str: + tracer.put_annotation(key="PaymentId", value=charge_id) + logger.debug("Returning sensitive information....") + return f"dummy payment collected for charge: {charge_id}" + + +@tracer.capture_lambda_handler(capture_response=False) +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + return collect_payment(charge_id=charge_id) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_response_streaming_body.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_response_streaming_body.py new file mode 100644 index 0000000000000000000000000000000000000000..82f9e15c91258b2acc8f0ca6296783f3c5155492 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/disable_capture_response_streaming_body.py @@ -0,0 +1,30 @@ +import os + +import boto3 +from botocore.response import StreamingBody + +from aws_lambda_powertools import Logger, Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +BUCKET = os.getenv("BUCKET_NAME", "") +REPORT_KEY = os.getenv("REPORT_KEY", "") + +tracer = Tracer() +logger = Logger() + +session = boto3.session.Session() +s3 = session.client("s3") + + +@tracer.capture_method(capture_response=False) +def fetch_payment_report(payment_id: str) -> StreamingBody: + ret = s3.get_object(Bucket=BUCKET, Key=f"{REPORT_KEY}/{payment_id}") + logger.debug("Returning streaming body from S3 object....") + return ret["Body"] + + +@tracer.capture_lambda_handler(capture_response=False) +def lambda_handler(event: dict, context: LambdaContext) -> str: + payment_id = event.get("payment_id", "") + report = fetch_payment_report(payment_id=payment_id) + return report.read().decode() diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/ignore_endpoints.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/ignore_endpoints.py new file mode 100644 index 0000000000000000000000000000000000000000..0fe256aeee9ca3e7359e5f4a0cffaa3e5754003b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/ignore_endpoints.py @@ -0,0 +1,35 @@ +import os + +import requests + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +ENDPOINT = os.getenv("PAYMENT_API", "") +IGNORE_URLS = ["/collect", "/refund"] + +tracer = Tracer() +tracer.ignore_endpoint(hostname=ENDPOINT, urls=IGNORE_URLS) +tracer.ignore_endpoint(hostname=f"*.{ENDPOINT}", urls=IGNORE_URLS) # `.ENDPOINT` + + +class PaymentError(Exception): + ... + + +@tracer.capture_method(capture_error=False) +def collect_payment(charge_id: str) -> dict: + try: + ret = requests.post(url=f"{ENDPOINT}/collect", data={"charge_id": charge_id}) + ret.raise_for_status() + return ret.json() + except requests.HTTPError as e: + raise PaymentError(f"Unable to collect payment for charge {charge_id}") from e + + +@tracer.capture_lambda_handler(capture_error=False) +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + ret = collect_payment(charge_id=charge_id) + + return ret.get("receipt_id", "") diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/patch_modules.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/patch_modules.py new file mode 100644 index 0000000000000000000000000000000000000000..e547951d7468f3b5979af48288334ca6de781d6f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/patch_modules.py @@ -0,0 +1,16 @@ +import requests + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +MODULES = ["requests"] + +tracer = Tracer(patch_modules=MODULES) + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + ret = requests.get("https://httpbin.org/get") + ret.raise_for_status() + + return ret.json() diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/put_trace_annotations.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/put_trace_annotations.py new file mode 100644 index 0000000000000000000000000000000000000000..5c31b384e9da2c48d923b47ffa51047667e3a003 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/put_trace_annotations.py @@ -0,0 +1,15 @@ +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +def collect_payment(charge_id: str) -> str: + tracer.put_annotation(key="PaymentId", value=charge_id) + return f"dummy payment collected for charge: {charge_id}" + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + return collect_payment(charge_id=charge_id) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/put_trace_metadata.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/put_trace_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..cf53b867b3775091fa4fb5152ad69715884cc73d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/put_trace_metadata.py @@ -0,0 +1,21 @@ +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +def collect_payment(charge_id: str) -> str: + return f"dummy payment collected for charge: {charge_id}" + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + payment_context = { + "charge_id": event.get("charge_id", ""), + "merchant_id": event.get("merchant_id", ""), + "request_id": context.aws_request_id, + } + payment_context["receipt_id"] = collect_payment(charge_id=payment_context["charge_id"]) + tracer.put_metadata(key="payment_response", value=payment_context) + + return payment_context["receipt_id"] diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/sdk_escape_hatch.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/sdk_escape_hatch.py new file mode 100644 index 0000000000000000000000000000000000000000..e7024016697da8a8179adab8188451b6ac726c42 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/sdk_escape_hatch.py @@ -0,0 +1,19 @@ +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +def collect_payment(charge_id: str) -> str: + return f"dummy payment collected for charge: {charge_id}" + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + with tracer.provider.in_subsegment("## collect_payment") as subsegment: + subsegment.put_annotation(key="PaymentId", value=charge_id) + ret = collect_payment(charge_id=charge_id) + subsegment.put_metadata(key="payment_response", value=ret) + + return ret diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/tracer_reuse.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/tracer_reuse.py new file mode 100644 index 0000000000000000000000000000000000000000..d38f22f68719efbfe047ad6e08755edf75de130c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/tracer_reuse.py @@ -0,0 +1,12 @@ +from tracer_reuse_module import collect_payment + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext) -> str: + charge_id = event.get("charge_id", "") + return collect_payment(charge_id=charge_id) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/tracer_reuse_module.py b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/tracer_reuse_module.py new file mode 100644 index 0000000000000000000000000000000000000000..109d1cfbc53a060c69b9d6c53251281db869b4ca --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/tracer/src/tracer_reuse_module.py @@ -0,0 +1,8 @@ +from aws_lambda_powertools import Tracer + +tracer = Tracer() + + +@tracer.capture_method +def collect_payment(charge_id: str) -> str: + return f"dummy payment collected for charge: {charge_id}" diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/typing/src/getting_started_typing_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/typing/src/getting_started_typing_function.py new file mode 100644 index 0000000000000000000000000000000000000000..493f0c18b2e1cf559118e93318cc19ffbb4cf3c6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/typing/src/getting_started_typing_function.py @@ -0,0 +1,6 @@ +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def handler(event: dict, context: LambdaContext) -> dict: + # Insert business logic + return event diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/typing/src/working_with_context_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/typing/src/working_with_context_function.py new file mode 100644 index 0000000000000000000000000000000000000000..3175593a8de55dc6f22f232eb28ff81282f2849c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/typing/src/working_with_context_function.py @@ -0,0 +1,30 @@ +from time import sleep + +import requests + +from aws_lambda_powertools import Logger +from aws_lambda_powertools.utilities.typing import LambdaContext + +logger = Logger() + + +def lambda_handler(event, context: LambdaContext) -> dict: + limit_execution: int = 1000 # milliseconds + + # scrape website and exit before lambda timeout + while context.get_remaining_time_in_millis() > limit_execution: + comments: requests.Response = requests.get("https://jsonplaceholder.typicode.com/comments") + # add logic here and save the results of the request to an S3 bucket, for example. + + logger.info( + { + "operation": "scrape_website", + "request_id": context.aws_request_id, + "remaining_time": context.get_remaining_time_in_millis(), + "comments": comments.json()[:2], + }, + ) + + sleep(1) + + return {"message": "Success"} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_function.py new file mode 100644 index 0000000000000000000000000000000000000000..bf589018c5c6bb6021823729173e43f55ff24c9e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_function.py @@ -0,0 +1,34 @@ +import json +import re + +import boto3 +import custom_format_schema as schemas + +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate + +# awsaccountid must have 12 digits +custom_format = {"awsaccountid": lambda value: re.match(r"^(\d{12})$", value)} + + +def lambda_handler(event, context: LambdaContext) -> dict: + try: + # validate input using custom json format + validate(event=event, schema=schemas.INPUT, formats=custom_format) + + client_organization = boto3.client("organizations", region_name=event.get("region")) + account_data = client_organization.describe_account(AccountId=event.get("accountid")) + + return { + "account": json.dumps(account_data.get("Account"), default=str), + "message": "Success", + "statusCode": 200, + } + except SchemaValidationError as exception: + return return_error_message(str(exception)) + except Exception as exception: + return return_error_message(str(exception)) + + +def return_error_message(message: str) -> dict: + return {"account": None, "message": message, "statusCode": 400} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..8f0607f94b0fed5dfb488d8295297e1b6e9e62a6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_payload.json @@ -0,0 +1,4 @@ +{ + "accountid": "200984112386", + "region": "us-east-1" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..e06a4b35e2dd3e32eabde70dd8527b1bc281d460 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_format_schema.py @@ -0,0 +1,26 @@ +INPUT = { + "definitions": {}, + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://example.com/object1660245931.json", + "title": "Root", + "type": "object", + "required": ["accountid", "region"], + "properties": { + "accountid": { + "$id": "#root/accountid", + "title": "The accountid", + "type": "string", + "format": "awsaccountid", + "default": "", + "examples": ["123456789012"], + }, + "region": { + "$id": "#root/region", + "title": "The region", + "type": "string", + "default": "", + "examples": ["us-east-1"], + "pattern": "^.*$", + }, + }, +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_handlers.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_handlers.py new file mode 100644 index 0000000000000000000000000000000000000000..4cbc5d65b9395d69d5f2cb301cd972733d47f127 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_handlers.py @@ -0,0 +1,14 @@ +from custom_handlers_schema import CHILD_SCHEMA, PARENT_SCHEMA + +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import validator + + +# Function to return the child schema +def get_child_schema(uri: str): + return CHILD_SCHEMA + + +@validator(inbound_schema=PARENT_SCHEMA, inbound_handlers={"https": get_child_schema}) +def lambda_handler(event, context: LambdaContext) -> dict: + return event diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_handlers_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_handlers_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..ab911e3d63ff7b6dc403daa825f0029f1a43473a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/custom_handlers_schema.py @@ -0,0 +1,22 @@ +PARENT_SCHEMA = { + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://example.com/schemas/parent.json", + "type": "object", + "properties": { + "ParentSchema": { + "$ref": "https://SCHEMA", + }, + }, +} + +CHILD_SCHEMA = { + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://example.com/schemas/child.json", + "type": "object", + "properties": { + "project": { + "type": "string", + }, + }, + "required": ["project"], +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_function.py new file mode 100644 index 0000000000000000000000000000000000000000..1e9b1bd2a09cacee2270326ebfbb408373d87143 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_function.py @@ -0,0 +1,44 @@ +from dataclasses import dataclass, field +from uuid import uuid4 + +import getting_started_validator_decorator_schema as schemas + +from aws_lambda_powertools.utilities import parameters +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import validator + +# we can get list of allowed IPs from AWS Parameter Store using Parameters Utility +# See: https://docs.powertools.aws.dev/lambda/python/latest/utilities/parameters/ +ALLOWED_IPS = parameters.get_parameter("/lambda-powertools/allowed_ips") + + +class UserPermissionsError(Exception): + ... + + +@dataclass +class User: + ip: str + permissions: list + user_id: str = field(default_factory=lambda: f"{uuid4()}") + name: str = "Project Lambda Powertools" + + +# using a decorator to validate input and output data +@validator(inbound_schema=schemas.INPUT, outbound_schema=schemas.OUTPUT) +def lambda_handler(event, context: LambdaContext) -> dict: + try: + user_details: dict = {} + + # get permissions by user_id and project + if ( + event.get("user_id") == "0d44b083-8206-4a3a-aa95-5d392a99be4a" + and event.get("project") == "powertools" + and event.get("ip") in ALLOWED_IPS + ): + user_details = User(ip=event.get("ip"), permissions=["read", "write"]).__dict__ + + # the body must be an object because must match OUTPUT schema, otherwise it fails + return {"body": user_details or None, "statusCode": 200 if user_details else 204} + except Exception as e: + raise UserPermissionsError(str(e)) diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..0e8bb8b752b11d3f9c65be9d9dc420206156bb13 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_payload.json @@ -0,0 +1,6 @@ + +{ + "user_id": "0d44b083-8206-4a3a-aa95-5d392a99be4a", + "project": "powertools", + "ip": "192.168.0.1" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..1f74a2cc711591839ddcdc5fa920af3070134395 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_decorator_schema.py @@ -0,0 +1,60 @@ +INPUT = { + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "http://example.com/example.json", + "type": "object", + "title": "Sample schema", + "description": "The root schema comprises the entire JSON document.", + "examples": [{"user_id": "0d44b083-8206-4a3a-aa95-5d392a99be4a", "project": "powertools", "ip": "192.168.0.1"}], + "required": ["user_id", "project", "ip"], + "properties": { + "user_id": { + "$id": "#/properties/user_id", + "type": "string", + "title": "The user_id", + "examples": ["0d44b083-8206-4a3a-aa95-5d392a99be4a"], + "maxLength": 50, + }, + "project": { + "$id": "#/properties/project", + "type": "string", + "title": "The project", + "examples": ["powertools"], + "maxLength": 30, + }, + "ip": { + "$id": "#/properties/ip", + "type": "string", + "title": "The ip", + "format": "ipv4", + "examples": ["192.168.0.1"], + "maxLength": 30, + }, + }, +} + +OUTPUT = { + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "http://example.com/example.json", + "type": "object", + "title": "Sample outgoing schema", + "description": "The root schema comprises the entire JSON document.", + "examples": [{"statusCode": 200, "body": {}}], + "required": ["statusCode", "body"], + "properties": { + "statusCode": { + "$id": "#/properties/statusCode", + "type": "integer", + "title": "The statusCode", + "examples": [200], + "maxLength": 3, + }, + "body": { + "$id": "#/properties/body", + "type": "object", + "title": "The body", + "examples": [ + '{"ip": "192.168.0.1", "permissions": ["read", "write"], "user_id": "7576b683-295e-4f69-b558-70e789de1b18", "name": "Project Lambda Powertools"}' # noqa E501 + ], + }, + }, +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_function.py new file mode 100644 index 0000000000000000000000000000000000000000..95fc3ecdf5d192a5d0f5547f6e0b4b6e75aa381c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_function.py @@ -0,0 +1,30 @@ +import getting_started_validator_standalone_schema as schemas + +from aws_lambda_powertools.utilities import parameters +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate + +# we can get list of allowed IPs from AWS Parameter Store using Parameters Utility +# See: https://docs.powertools.aws.dev/lambda/python/latest/utilities/parameters/ +ALLOWED_IPS = parameters.get_parameter("/lambda-powertools/allowed_ips") + + +def lambda_handler(event, context: LambdaContext) -> dict: + try: + user_authenticated: str = "" + + # using standalone function to validate input data only + validate(event=event, schema=schemas.INPUT) + + if ( + event.get("user_id") == "0d44b083-8206-4a3a-aa95-5d392a99be4a" + and event.get("project") == "powertools" + and event.get("ip") in ALLOWED_IPS + ): + user_authenticated = "Allowed" + + # in this example the body can be of any type because we are not validating the OUTPUT + return {"body": user_authenticated, "statusCode": 200 if user_authenticated else 204} + except SchemaValidationError as exception: + # SchemaValidationError indicates where a data mismatch is + return {"body": str(exception), "statusCode": 400} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..0e8bb8b752b11d3f9c65be9d9dc420206156bb13 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_payload.json @@ -0,0 +1,6 @@ + +{ + "user_id": "0d44b083-8206-4a3a-aa95-5d392a99be4a", + "project": "powertools", + "ip": "192.168.0.1" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..2871115719641002eee428a04599de5d613b7859 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_standalone_schema.py @@ -0,0 +1,33 @@ +INPUT = { + "$schema": "http://json-schema.org/draft-07/schema", + "$id": "http://example.com/example.json", + "type": "object", + "title": "Sample schema", + "description": "The root schema comprises the entire JSON document.", + "examples": [{"user_id": "0d44b083-8206-4a3a-aa95-5d392a99be4a", "powertools": "lessa", "ip": "192.168.0.1"}], + "required": ["user_id", "project", "ip"], + "properties": { + "user_id": { + "$id": "#/properties/user_id", + "type": "string", + "title": "The user_id", + "examples": ["0d44b083-8206-4a3a-aa95-5d392a99be4a"], + "maxLength": 50, + }, + "project": { + "$id": "#/properties/project", + "type": "string", + "title": "The project", + "examples": ["powertools"], + "maxLength": 30, + }, + "ip": { + "$id": "#/properties/ip", + "type": "string", + "title": "The ip", + "format": "ipv4", + "examples": ["192.168.0.1"], + "maxLength": 30, + }, + }, +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_function.py new file mode 100644 index 0000000000000000000000000000000000000000..c1b48fd3a81a36bf6e83671adfdcbce9e884c21f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_function.py @@ -0,0 +1,38 @@ +import boto3 +import getting_started_validator_unwrapping_schema as schemas + +from aws_lambda_powertools.utilities.data_classes.event_bridge_event import ( + EventBridgeEvent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import validator + +s3_client = boto3.resource("s3") + + +# we use the 'envelope' parameter to extract the payload inside the 'detail' key before validating +@validator(inbound_schema=schemas.INPUT, envelope="detail") +def lambda_handler(event: dict, context: LambdaContext) -> dict: + my_event = EventBridgeEvent(event) + data = my_event.detail.get("data", {}) + s3_bucket, s3_key = data.get("s3_bucket"), data.get("s3_key") + + try: + s3_object = s3_client.Object(bucket_name=s3_bucket, key=s3_key) + payload = s3_object.get()["Body"] + content = payload.read().decode("utf-8") + + return {"message": process_data_object(content), "success": True} + except s3_client.meta.client.exceptions.NoSuchBucket as exception: + return return_error_message(str(exception)) + except s3_client.meta.client.exceptions.NoSuchKey as exception: + return return_error_message(str(exception)) + + +def return_error_message(message: str) -> dict: + return {"message": message, "success": False} + + +def process_data_object(content: str) -> str: + # insert logic here + return "Data OK" diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..7757085361b7db5fd6f1a1653f165ffa39138b14 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_payload.json @@ -0,0 +1,17 @@ +{ + "id": "cdc73f9d-aea9-11e3-9d5a-835b769c0d9c", + "detail-type": "CustomEvent", + "source": "mycompany.service", + "account": "123456789012", + "time": "1970-01-01T00:00:00Z", + "region": "us-east-1", + "resources": [], + "detail": { + "data": { + "s3_bucket": "aws-lambda-powertools", + "s3_key": "folder/event.txt", + "file_size": 200, + "file_type": "text/plain" + } + } +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..02b0128d9711eaded4a267f976db030711d95b52 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/getting_started_validator_unwrapping_schema.py @@ -0,0 +1,59 @@ +INPUT = { + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://example.com/object1660222326.json", + "type": "object", + "title": "Sample schema", + "description": "The root schema comprises the entire JSON document.", + "examples": [ + { + "data": { + "s3_bucket": "aws-lambda-powertools", + "s3_key": "event.txt", + "file_size": 200, + "file_type": "text/plain", + }, + }, + ], + "required": ["data"], + "properties": { + "data": { + "$id": "#root/data", + "title": "Root", + "type": "object", + "required": ["s3_bucket", "s3_key", "file_size", "file_type"], + "properties": { + "s3_bucket": { + "$id": "#root/data/s3_bucket", + "title": "The S3 Bucker", + "type": "string", + "default": "", + "examples": ["aws-lambda-powertools"], + "pattern": "^.*$", + }, + "s3_key": { + "$id": "#root/data/s3_key", + "title": "The S3 Key", + "type": "string", + "default": "", + "examples": ["folder/event.txt"], + "pattern": "^.*$", + }, + "file_size": { + "$id": "#root/data/file_size", + "title": "The file size", + "type": "integer", + "examples": [200], + "default": 0, + }, + "file_type": { + "$id": "#root/data/file_type", + "title": "The file type", + "type": "string", + "default": "", + "examples": ["text/plain"], + "pattern": "^.*$", + }, + }, + }, + }, +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_function.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_function.py new file mode 100644 index 0000000000000000000000000000000000000000..952e949647a00f6bb4d6120f3c2d74d7fb17a698 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_function.py @@ -0,0 +1,26 @@ +import boto3 +import unwrapping_popular_event_source_schema as schemas +from botocore.exceptions import ClientError + +from aws_lambda_powertools.utilities.data_classes.event_bridge_event import ( + EventBridgeEvent, +) +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import envelopes, validator + + +# extracting detail from EventBridge custom event +# see: https://docs.powertools.aws.dev/lambda/python/latest/utilities/jmespath_functions/#built-in-envelopes +@validator(inbound_schema=schemas.INPUT, envelope=envelopes.EVENTBRIDGE) +def lambda_handler(event: dict, context: LambdaContext) -> dict: + my_event = EventBridgeEvent(event) + ec2_client = boto3.resource("ec2", region_name=my_event.region) + + try: + instance_id = my_event.detail.get("instance_id") + instance = ec2_client.Instance(instance_id) + instance.stop() + + return {"message": f"Successfully stopped {instance_id}", "success": True} + except ClientError as exception: + return {"message": str(exception), "success": False} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_payload.json b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_payload.json new file mode 100644 index 0000000000000000000000000000000000000000..271e0be5b27e7e75f762dc52b233495982e4a427 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_payload.json @@ -0,0 +1,16 @@ + +{ + "id": "cdc73f9d-aea9-11e3-9d5a-835b769c0d9c", + "detail-type": "Scheduled Event", + "source": "aws.events", + "account": "123456789012", + "time": "1970-01-01T00:00:00Z", + "region": "us-east-1", + "resources": [ + "arn:aws:events:us-east-1:123456789012:rule/ExampleRule" + ], + "detail": { + "instance_id": "i-042dd005362091826", + "region": "us-east-2" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_schema.py b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_schema.py new file mode 100644 index 0000000000000000000000000000000000000000..0c5cc7462509bce90a93eb6e83ebbbfec9dd9bd5 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/examples/validation/src/unwrapping_popular_event_source_schema.py @@ -0,0 +1,26 @@ +INPUT = { + "definitions": {}, + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://example.com/object1660233148.json", + "title": "Root", + "type": "object", + "required": ["instance_id", "region"], + "properties": { + "instance_id": { + "$id": "#root/instance_id", + "title": "Instance_id", + "type": "string", + "default": "", + "examples": ["i-042dd005362091826"], + "pattern": "^.*$", + }, + "region": { + "$id": "#root/region", + "title": "Region", + "type": "string", + "default": "", + "examples": ["us-east-1"], + "pattern": "^.*$", + }, + }, +} diff --git a/testbed/aws-powertools__powertools-lambda-python/includes/abbreviations.md b/testbed/aws-powertools__powertools-lambda-python/includes/abbreviations.md new file mode 100644 index 0000000000000000000000000000000000000000..5e0db4dcb270008d0b009e4a958b482fc159da34 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/includes/abbreviations.md @@ -0,0 +1,2 @@ +*[observability provider]: An AWS Lambda Observability Partner +*[unhandled exception]: An exception that is not caught by any explicit try/except block diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/.gitignore b/testbed/aws-powertools__powertools-lambda-python/layer_v3/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..37833f8beb2a38d990931d38228e9481cac2c1f2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/.gitignore @@ -0,0 +1,10 @@ +*.swp +package-lock.json +__pycache__ +.pytest_cache +.venv +*.egg-info + +# CDK asset staging directory +.cdk.staging +cdk.out diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/README.md b/testbed/aws-powertools__powertools-lambda-python/layer_v3/README.md new file mode 100644 index 0000000000000000000000000000000000000000..281b05be948b852eb53c11446b06b3de29faa649 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/README.md @@ -0,0 +1,27 @@ + +# CDK Powertools for AWS Lambda (Python) layer + +This is a CDK project to build and deploy Powertools for AWS Lambda (Python) [Lambda layer](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-layer) to multiple commercial regions. + +## Build the layer + +To build the layer construct you need to provide the Powertools for AWS Lambda (Python) version that is [available in PyPi](https://pypi.org/project/aws-lambda-powertools/). +You can pass it as a context variable when running `synth` or `deploy`, + +```shell +cdk synth --context version=3.0.0 --pythonVersion=3.12 +``` + +## Canary stack + +We use a canary stack to verify that the deployment is successful and we can use the layer by adding it to a newly created Lambda function. +The canary is deployed after the layer construct. Because the layer ARN is created during the deploy we need to pass this information async via SSM parameter. +To achieve that we use SSM parameter store to pass the layer ARN to the canary. +The layer stack writes the layer ARN after the deployment as SSM parameter and the canary stacks reads this information and adds the layer to the function. + +## Version tracking + +AWS Lambda versions Lambda layers by incrementing a number at the end of the ARN. +This makes it challenging to know which Powertools for AWS Lambda (Python) version a layer contains. +For better tracking of the ARNs and the corresponding version we need to keep track which Powertools for AWS Lambda (Python) version was deployed to which layer. +To achieve that we created two components. First, we created a version tracking app which receives events via EventBridge. Second, after a successful canary deployment we send the layer ARN, Powertools for AWS Lambda (Python) version, and the region to this EventBridge. diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/__init__.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/app.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/app.py new file mode 100644 index 0000000000000000000000000000000000000000..25ed2b116ce9c18c600e7448a99ea50438dbe44e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/app.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 + +import aws_cdk as cdk + +from layer.canary_stack import CanaryStack +from layer.layer_stack import LayerStack + +app = cdk.App() + +POWERTOOLS_VERSION: str = app.node.try_get_context("version") +PYTHON_VERSION: str = app.node.try_get_context("pythonVersion") +PYTHON_VERSION_NORMALIZED = PYTHON_VERSION.replace(".", "") +SSM_PARAM_LAYER_ARN: str = f"/layers/powertools-layer-v3-{PYTHON_VERSION_NORMALIZED}-x86-arn" +SSM_PARAM_LAYER_ARM64_ARN: str = f"/layers/powertools-layer-v3-{PYTHON_VERSION_NORMALIZED}-arm64-arn" + +# Validate context variables +if not PYTHON_VERSION: + raise ValueError( + "Please set the version for Python by passing the '--context pythonVersion=' parameter to the CDK " + "synth step.", + ) + +if not POWERTOOLS_VERSION: + raise ValueError( + "Please set the version for Powertools by passing the '--context version=' parameter to the CDK " + "synth step.", + ) + +LayerStack( + app, + f"LayerV3Stack-{PYTHON_VERSION_NORMALIZED}", + powertools_version=POWERTOOLS_VERSION, + python_version=PYTHON_VERSION, + ssm_parameter_layer_arn=SSM_PARAM_LAYER_ARN, + ssm_parameter_layer_arm64_arn=SSM_PARAM_LAYER_ARM64_ARN, +) + +CanaryStack( + app, + f"CanaryV3Stack-{PYTHON_VERSION_NORMALIZED}", + powertools_version=POWERTOOLS_VERSION, + python_version=PYTHON_VERSION, + ssm_paramter_layer_arn=SSM_PARAM_LAYER_ARN, + ssm_parameter_layer_arm64_arn=SSM_PARAM_LAYER_ARM64_ARN, +) + +app.synth() diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/cdk.json b/testbed/aws-powertools__powertools-lambda-python/layer_v3/cdk.json new file mode 100644 index 0000000000000000000000000000000000000000..c120c5f4765a8a4f8109cd37e828c668db45640f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/cdk.json @@ -0,0 +1,35 @@ +{ + "app": "python3 app.py", + "watch": { + "include": [ + "**" + ], + "exclude": [ + "README.md", + "cdk*.json", + "requirements*.txt", + "source.bat", + "**/__init__.py", + "python/__pycache__", + "tests" + ] + }, + "context": { + "@aws-cdk/aws-apigateway:usagePlanKeyOrderInsensitiveId": true, + "@aws-cdk/core:stackRelativeExports": true, + "@aws-cdk/aws-rds:lowercaseDbIdentifier": true, + "@aws-cdk/aws-lambda:recognizeVersionProps": true, + "@aws-cdk/aws-lambda:recognizeLayerVersion": true, + "@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021": true, + "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true, + "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true, + "@aws-cdk/core:checkSecretUsage": true, + "@aws-cdk/aws-iam:minimizePolicies": true, + "@aws-cdk/core:validateSnapshotRemovalPolicy": true, + "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": true, + "@aws-cdk/core:target-partitions": [ + "aws", + "aws-cn" + ] + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/docker/Dockerfile b/testbed/aws-powertools__powertools-lambda-python/layer_v3/docker/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..b77ed7497c80cf341f62ac0f708129bfb41510df --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/docker/Dockerfile @@ -0,0 +1,45 @@ +# First stage: setting the base image +ARG PYTHON_VERSION="" + +FROM public.ecr.aws/lambda/python:${PYTHON_VERSION} AS base_build + +# Second stage: building the layer +FROM base_build + +ARG PYTHON_VERSION="" +ARG PACKAGE_SUFFIX="" + +USER root +WORKDIR /tmp + +# PACKAGE_SUFFIX = '[all]==3.0.0' +# PACKAGE_SUFFIX = '[all] @ git+https://github.com/awslabs/aws-lambda-powertools-python@develop' +# PACKAGE_SUFFIX = '[all]' +# PACKAGE_SUFFIX = '=='3.0.0' +# PACKAGE_SUFFIX = ' @ git+https://github.com/awslabs/aws-lambda-powertools-python@develop' +# PACKAGE_SUFFIX = '' + +# PYTHON_VERSION = 3.8, 3.9, 3.10, 3.11, 3.12, and 3.13 + +# Installing libs based on base image; We must use dnf for AL2023 (Python 3.12+) +COPY install_libraries.sh . +RUN chmod a+x /tmp/install_libraries.sh +RUN /bin/sh /tmp/install_libraries.sh + +# Install cython to generate native code +RUN pip install --upgrade pip wheel && pip install --upgrade cython +# Optimize binary size and strip debugging symbols for optimum size +RUN CFLAGS="-Os -g0 -s" pip install -t /asset/python "aws-lambda-powertools${PACKAGE_SUFFIX}" + +# Removing nonessential files +RUN cd /asset/python && \ + # remove boto3 and botocore (already available in Lambda Runtime) + rm -rf boto* && \ + # remove boto3 dependencies + rm -rf s3transfer* *dateutil* urllib3* six* jmespath* && \ + # remove debugging symbols + find . -name '*.so' -type f -exec strip "{}" \; && \ + # remove tests + find . -wholename "*/tests/*" -type f -delete && \ + # remove python bytecode + find . -regex '^.*\(__pycache__\|\.py[co]\)$' -delete diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/docker/install_libraries.sh b/testbed/aws-powertools__powertools-lambda-python/layer_v3/docker/install_libraries.sh new file mode 100644 index 0000000000000000000000000000000000000000..919a2b6f31642b684c668800c8a84ecbf06a9df7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/docker/install_libraries.sh @@ -0,0 +1,45 @@ +#!/bin/sh + +al2_versions=("3.8" "3.9" "3.10" "3.11") + +# Flag to indicate if the version is al2 or not +is_al2=0 + +for version in "${al2_versions[@]}"; do + if [ "$PYTHON_VERSION" = "$version" ]; then + is_al2=1 + break + fi +done + +if [ "$is_al2" -eq 1 ]; then + yum update -y && yum install -y zip unzip wget tar gzip binutils + yum install -y \ + boost-devel \ + jemalloc-devel \ + bison \ + make \ + gcc \ + gcc-c++ \ + flex \ + autoconf \ + zip \ + git \ + ninja-build + +else + dnf update -y && dnf install -y zip unzip wget tar gzip binutils + dnf install -y \ + boost-devel \ + jemalloc-devel \ + bison \ + make \ + gcc \ + gcc-c++ \ + flex \ + autoconf \ + zip \ + git \ + ninja-build + +fi diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/__init__.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/canary/app.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/canary/app.py new file mode 100644 index 0000000000000000000000000000000000000000..667d821563613d2865b6d43ded108eca8ace2643 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/canary/app.py @@ -0,0 +1,136 @@ +import datetime +import json +import os +import platform +from importlib.metadata import version + +import boto3 +from pydantic import HttpUrl + +from aws_lambda_powertools import Logger, Metrics, Tracer +from aws_lambda_powertools.event_handler import APIGatewayRestResolver +from aws_lambda_powertools.utilities.data_masking import DataMasking +from aws_lambda_powertools.utilities.parser import BaseModel, envelopes, event_parser +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.utilities.validation import validator + +logger = Logger(service="version-track") +tracer = Tracer() # this checks for aws-xray-sdk presence +metrics = Metrics(namespace="powertools-layer-canary", service="PowertoolsLayerCanary") +data_masker = DataMasking() +app = APIGatewayRestResolver() + +layer_arn = os.getenv("POWERTOOLS_LAYER_ARN") +powertools_version = os.getenv("POWERTOOLS_VERSION") +stage = os.getenv("LAYER_PIPELINE_STAGE") +event_bus_arn = os.getenv("VERSION_TRACKING_EVENT_BUS_ARN") + + +# Model to check parser imports correctly, tests for pydantic +class OrderItem(BaseModel): + order_id: int + quantity: int + description: str + url: HttpUrl + + +# Tests for jmespath presence +@event_parser(model=OrderItem, envelope=envelopes.EventBridgeEnvelope) +def envelope_handler(event: OrderItem, context: LambdaContext): + assert event.order_id != 1 + + +# Tests for fastjsonschema presence +@validator(inbound_schema={}, envelope="detail") +def validator_handler(event, context: LambdaContext): + pass + + +def handler(event): + logger.info("Running checks") + check_envs() + verify_powertools_version() + send_notification() + return True + + +@logger.inject_lambda_context(log_event=True) +def on_event(event, context): + request_type = event["RequestType"] + # we handle only create events, because we recreate the canary on each run + if request_type == "Create": + return on_create(event) + + return "Nothing to be processed" + + +def on_create(event): + props = event["ResourceProperties"] + logger.info("create new resource with properties %s" % props) + handler(event) + + +def check_envs(): + logger.info('Checking required envs ["POWERTOOLS_LAYER_ARN", "AWS_REGION", "STAGE"]') + if not layer_arn: + raise ValueError("POWERTOOLS_LAYER_ARN is not set. Aborting...") + if not powertools_version: + raise ValueError("POWERTOOLS_VERSION is not set. Aborting...") + if not stage: + raise ValueError("LAYER_PIPELINE_STAGE is not set. Aborting...") + if not event_bus_arn: + raise ValueError("VERSION_TRACKING_EVENT_BUS_ARN is not set. Aborting...") + logger.info("All envs configured, continue...") + + +def verify_powertools_version() -> None: + """ + fetches the version that we import from the Powertools for AWS Lambda (Python) layer and compares + it with expected version set in environment variable, which we pass during deployment. + :raise ValueError if the expected version is not the same as the version we get from the layer + """ + logger.info("Checking Powertools for AWS Lambda (Python) version in library...") + current_version = version("aws_lambda_powertools") + if powertools_version != current_version: + raise ValueError( + f'Expected Powertools version is "{powertools_version}", but layer contains version "{current_version}"', + ) + logger.info(f"Current Powertools version is: {current_version} [{_get_architecture()}]") + + +def send_notification(): + """ + sends an event to version tracking event bridge + """ + if stage != "PROD": + logger.info("Not sending notification to event bus, because this is not the PROD stage") + return + + event = { + "Time": datetime.datetime.now(), + "Source": "powertools.layer.canary", + "EventBusName": event_bus_arn, + "DetailType": "deployment", + "Detail": json.dumps( + { + "version": powertools_version, + "region": os.environ["AWS_REGION"], + "layerArn": layer_arn, + "architecture": _get_architecture(), + }, + ), + } + + logger.info(f"sending notification event: {event}") + + client = boto3.client("events", region_name="eu-central-1") + resp = client.put_events(Entries=[event]) + logger.info(resp) + if resp["FailedEntryCount"] != 0: + logger.error(resp) + raise ValueError("Failed to send deployment notification to version tracking") + + +def _get_architecture() -> str: + """Returns aarch64, x86_64""" + return platform.uname()[4] diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/canary_stack.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/canary_stack.py new file mode 100644 index 0000000000000000000000000000000000000000..5f1e87cb3c68bbdf0baa91eae12b5843b2e5078d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/canary_stack.py @@ -0,0 +1,189 @@ +import uuid + +import jsii +from aws_cdk import ( + Aspects, + CfnCondition, + CfnParameter, + CfnResource, + CustomResource, + Duration, + Fn, + IAspect, + Stack, +) +from aws_cdk.aws_iam import ( + Effect, + ManagedPolicy, + PolicyStatement, + Role, + ServicePrincipal, +) +from aws_cdk.aws_lambda import Architecture, Code, Function, LayerVersion, Runtime +from aws_cdk.aws_logs import RetentionDays +from aws_cdk.aws_ssm import StringParameter +from aws_cdk.custom_resources import Provider +from constructs import Construct + +VERSION_TRACKING_EVENT_BUS_ARN: str = "arn:aws:events:eu-central-1:027876851704:event-bus/VersionTrackingEventBus" + + +@jsii.implements(IAspect) +class ApplyCondition: + def __init__(self, condition: CfnCondition): + self.condition = condition + + def visit(self, node): + if isinstance(node, CfnResource): + node.cfn_options.condition = self.condition + + +class CanaryStack(Stack): + def __init__( + self, + scope: Construct, + construct_id: str, + powertools_version: str, + python_version: str, + ssm_paramter_layer_arn: str, + ssm_parameter_layer_arm64_arn: str, + **kwargs, + ) -> None: + super().__init__(scope, construct_id, **kwargs) + + deploy_stage = CfnParameter(self, "DeployStage", description="Deployment stage for canary").value_as_string + + has_arm64_support = CfnParameter( + self, + "HasARM64Support", + description="Has ARM64 Support Condition", + type="String", + allowed_values=["true", "false"], + ) + + has_arm64_condition = CfnCondition( + self, + "HasARM64SupportCondition", + expression=Fn.condition_equals(has_arm64_support, "true"), + ) + + layer_arn = StringParameter.from_string_parameter_attributes( + self, + "LayerVersionArnParam", + parameter_name=ssm_paramter_layer_arn, + ).string_value + Canary( + self, + "Canary-x86-64", + layer_arn=layer_arn, + powertools_version=powertools_version, + python_version=python_version, + architecture=Architecture.X86_64, + stage=deploy_stage, + ) + + layer_arm64_arn = StringParameter.from_string_parameter_attributes( + self, + "LayerArm64VersionArnParam", + parameter_name=ssm_parameter_layer_arm64_arn, + ).string_value + + arm64_canary = Canary( + self, + "Canary-arm64", + layer_arn=layer_arm64_arn, + powertools_version=powertools_version, + python_version=python_version, + architecture=Architecture.ARM_64, + stage=deploy_stage, + ) + Aspects.of(arm64_canary).add(ApplyCondition(has_arm64_condition)) + + +class Canary(Construct): + def __init__( + self, + scope: Construct, + construct_id: str, + layer_arn: str, + powertools_version: str, + python_version: str, + architecture: Architecture, + stage: str, + ): + super().__init__(scope, construct_id) + + python_version_normalized = python_version.replace(".", "") + + layer = LayerVersion.from_layer_version_arn(self, "PowertoolsLayer", layer_version_arn=layer_arn) + + execution_role = Role( + self, + "LambdaExecutionRole", + assumed_by=ServicePrincipal("lambda.amazonaws.com"), + ) + + execution_role.add_managed_policy( + ManagedPolicy.from_aws_managed_policy_name("service-role/AWSLambdaBasicExecutionRole"), + ) + + execution_role.add_to_policy( + PolicyStatement(effect=Effect.ALLOW, actions=["lambda:GetFunction"], resources=["*"]), + ) + + if python_version == "python3.8": + runtime = Runtime.PYTHON_3_8 + elif python_version == "python3.9": + runtime = Runtime.PYTHON_3_9 + elif python_version == "python3.10": + runtime = Runtime.PYTHON_3_10 + elif python_version == "python3.11": + runtime = Runtime.PYTHON_3_11 + elif python_version == "python3.12": + runtime = Runtime.PYTHON_3_12 + elif python_version == "python3.13": + runtime = Runtime.PYTHON_3_13 + else: + raise ValueError("Unsupported Python version") + + canary_lambda = Function( + self, + f"CanaryLambdaFunction-{python_version_normalized}", + code=Code.from_asset("layer/canary"), + handler="app.on_event", + layers=[layer], + memory_size=512, + timeout=Duration.seconds(10), + runtime=runtime, + architecture=architecture, + log_retention=RetentionDays.TEN_YEARS, + role=execution_role, + environment={ + "POWERTOOLS_VERSION": powertools_version, + "POWERTOOLS_LAYER_ARN": layer_arn, + "VERSION_TRACKING_EVENT_BUS_ARN": VERSION_TRACKING_EVENT_BUS_ARN, + "LAYER_PIPELINE_STAGE": stage, + }, + ) + + canary_lambda.add_to_role_policy( + PolicyStatement( + effect=Effect.ALLOW, + actions=["events:PutEvents"], + resources=[VERSION_TRACKING_EVENT_BUS_ARN], + ), + ) + + # custom resource provider configuration + provider = Provider( + self, + "CanaryCustomResource", + on_event_handler=canary_lambda, + log_retention=RetentionDays.TEN_YEARS, + ) + # force to recreate resource on each deployment with randomized name + CustomResource( + self, + f"CanaryTrigger-{str(uuid.uuid4())[0:7]}", + service_token=provider.service_token, + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/layer_stack.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/layer_stack.py new file mode 100644 index 0000000000000000000000000000000000000000..4d79507cbdf5469a7fb6e928453ec78612055c4a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer/layer_stack.py @@ -0,0 +1,198 @@ +from __future__ import annotations + +import jsii +from aws_cdk import ( + Aspects, + CfnCondition, + CfnOutput, + CfnParameter, + CfnResource, + Fn, + IAspect, + RemovalPolicy, + Stack, +) +from aws_cdk.aws_lambda import Architecture, CfnLayerVersionPermission, Runtime +from aws_cdk.aws_ssm import StringParameter +from constructs import Construct +from layer_constructors.layer_stack import LambdaPowertoolsLayerPythonV3 + + +@jsii.implements(IAspect) +class ApplyCondition: + def __init__(self, condition: CfnCondition): + self.condition = condition + + def visit(self, node): + if isinstance(node, CfnResource): + node.cfn_options.condition = self.condition + if isinstance(node, CfnOutput): + node.condition = self.condition + + +class Layer(Construct): + def __init__( + self, + scope: Construct, + construct_id: str, + layer_version_name: str, + powertools_version: str, + python_version: str, + architecture: Architecture | None = None, + **kwargs, + ) -> None: + super().__init__(scope, construct_id, **kwargs) + + layer = LambdaPowertoolsLayerPythonV3( + self, + "Layer", + layer_name=layer_version_name, + powertools_version=powertools_version, + python_version=python_version, + include_extras=True, + architecture=architecture or Architecture.X86_64, + ) + layer.apply_removal_policy(RemovalPolicy.RETAIN) + + self.layer_version_arn = layer.layer_version_arn + + layer_permission = CfnLayerVersionPermission( + self, + "PublicLayerAccess", + action="lambda:GetLayerVersion", + layer_version_arn=layer.layer_version_arn, + principal="*", + ) + layer_permission.apply_removal_policy(RemovalPolicy.RETAIN) + + +class LayerStack(Stack): + def __init__( + self, + scope: Construct, + construct_id: str, + powertools_version: str, + python_version: str, + ssm_parameter_layer_arn: str, + ssm_parameter_layer_arm64_arn: str, + **kwargs, + ) -> None: + super().__init__(scope, construct_id, **kwargs) + + python_version_normalized = python_version.replace(".", "") + layer_name_x86_64 = f"AWSLambdaPowertoolsPythonV3-{python_version_normalized}-x86_64" + layer_name_arm64 = f"AWSLambdaPowertoolsPythonV3-{python_version_normalized}-arm64" + + if python_version == "python3.8": + python_version = Runtime.PYTHON_3_8 + if python_version == "python3.9": + python_version = Runtime.PYTHON_3_9 + if python_version == "python3.10": + python_version = Runtime.PYTHON_3_10 + if python_version == "python3.11": + python_version = Runtime.PYTHON_3_11 + if python_version == "python3.12": + python_version = Runtime.PYTHON_3_12 + if python_version == "python3.13": + python_version = Runtime.PYTHON_3_13 + + has_arm64_support = CfnParameter( + self, + "HasARM64Support", + description="Has ARM64 Support Condition", + type="String", + allowed_values=["true", "false"], + ) + + has_arm64_condition = CfnCondition( + self, + "HasARM64SupportCondition", + expression=Fn.condition_equals(has_arm64_support, "true"), + ) + has_no_arm64_condition = CfnCondition( + self, + "HasNOArm64SupportCondition", + expression=Fn.condition_equals(has_arm64_support, "false"), + ) + + # The following code is used when the region does not support ARM64 Lambdas. We make sure to only create the + # X86_64 Layer without specifying any compatible architecture, which would result in a CloudFormation error. + + layer_single = Layer( + self, + f"LayerSingle-{python_version_normalized}", + layer_version_name=layer_name_x86_64, + python_version=python_version, + powertools_version=powertools_version, + ) + Aspects.of(layer_single).add(ApplyCondition(has_no_arm64_condition)) + + Aspects.of( + StringParameter( + self, + f"SingleVersionArn-{python_version_normalized}", + parameter_name=ssm_parameter_layer_arn, + string_value=layer_single.layer_version_arn, + ), + ).add(ApplyCondition(has_no_arm64_condition)) + + # The following code is used when the region has support for ARM64 Lambdas. In this case, we explicitly + # create a Layer for both X86_64 and ARM64, specifying the compatible architectures. + + # X86_64 layer + + layer = Layer( + self, + f"Layer-{python_version_normalized}", + layer_version_name=layer_name_x86_64, + powertools_version=powertools_version, + python_version=python_version, + architecture=Architecture.X86_64, + ) + Aspects.of(layer).add(ApplyCondition(has_arm64_condition)) + + Aspects.of( + StringParameter( + self, + f"VersionArn-{python_version_normalized}", + parameter_name=ssm_parameter_layer_arn, + string_value=layer.layer_version_arn, + ), + ).add(ApplyCondition(has_arm64_condition)) + + CfnOutput( + self, + "LatestLayerArn", + value=Fn.condition_if( + has_arm64_condition.logical_id, + layer.layer_version_arn, + layer_single.layer_version_arn, + ).to_string(), + ) + + # ARM64 layer + + layer_arm64 = Layer( + self, + f"Layer-ARM64-{python_version_normalized}", + layer_version_name=layer_name_arm64, + powertools_version=powertools_version, + python_version=python_version, + architecture=Architecture.ARM_64, + ) + Aspects.of(layer_arm64).add(ApplyCondition(has_arm64_condition)) + + StringParameter( + self, + f"Arm64VersionArn-{python_version_normalized}", + parameter_name=ssm_parameter_layer_arm64_arn, + string_value=Fn.condition_if( + has_arm64_condition.logical_id, + layer_arm64.layer_version_arn, + "none", + ).to_string(), + ) + + Aspects.of(CfnOutput(self, "LatestLayerArm64Arn", value=layer_arm64.layer_version_arn)).add( + ApplyCondition(has_arm64_condition), + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/__init__.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/helpers.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..ecc6d82647505fa18a5e947ffcae775febad4eca --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/helpers.py @@ -0,0 +1,45 @@ +from __future__ import annotations + + +def construct_build_args(include_extras: bool = True, version: str | None = None) -> str: + """ + This function creates a suffix string for the Powertools package based on + whether extra dependencies should be included and a specific version is required. + + Params + ------ + include_extras: bool | None: + If True, include all extra dependencies in Powertools package + version: str | None + The version of Powertools to install. Can be a version number or a git reference. + + Returns + ------- + str + A string suffix to be appended to the Powertools package name during installation. + Examples: + - "" (empty string) if no extras or version specified + - "[all]" if include_extras is True + - "==1.2.3" if version is "1.2.3" + - "[all]==1.2.3" if include_extras is True and version is "1.2.3" + - " @ git+https://github.com/..." if version starts with "git" + + Example + ------- + >>> construct_build_args(True, "1.2.3") + '[all]==1.2.3' + >>> construct_build_args(False, "git+https://github.com/...") + ' @ git+https://github.com/...' + """ + + suffix = "" + + if include_extras: + suffix = "[all]" + if version: + if version.startswith("git"): + suffix = f"{suffix} @ {version}" + else: + suffix = f"{suffix}=={version}" + + return suffix diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/layer_stack.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/layer_stack.py new file mode 100644 index 0000000000000000000000000000000000000000..2d4b97578540bf91aec46d4c86ca125c74cbee58 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/layer_stack.py @@ -0,0 +1,84 @@ +from __future__ import annotations + +from pathlib import Path +from typing import TYPE_CHECKING + +from aws_cdk import aws_lambda as lambda_ + +if TYPE_CHECKING: + from constructs import Construct + +from .helpers import construct_build_args + + +class LambdaPowertoolsLayerPythonV3(lambda_.LayerVersion): + """ + A CDK Stack that creates a Lambda Layer for Powertools for AWS Lambda (Python) V3. + + This stack creates a Lambda Layer containing the Powertools for AWS Lambda (Python) V3 library. + It allows customization of the Python runtime version, inclusion of extra dependencies, + architecture, Powertools version, and layer name. + + Attributes: + scope (Construct): The scope in which to define this construct. + construct_id (str): The scoped construct ID. Must be unique amongst siblings in the same scope. + python_version (lambda_.Runtime): The Python runtime version for the layer. Defaults to Python 3.13. + include_extras (bool): Whether to include extra dependencies. Defaults to True. + architecture (lambda_.Architecture): The compatible Lambda architecture. Defaults to x86_64. + powertools_version (str): The version of Powertools to use. If empty, uses the latest version. + layer_name (str): Custom name for the Lambda Layer. If empty, a default name will be used in the layer. + + + Example: + >>> app = cdk.App() + >>> LambdaPowertoolsLayerPythonV3(app, "PowertoolsLayer", + ... python_version=lambda_.Runtime.PYTHON_3_13, + ... include_extras=True, + ... architecture=lambda_.Architecture.ARM_64, + ... powertools_version="3.0.0", + ... layer_name="MyCustomPowertoolsLayer") + + """ + + def __init__( + self, + scope: Construct, + construct_id: str, + python_version: lambda_.Runtime = lambda_.Runtime.PYTHON_3_13, + include_extras: bool = True, + architecture: lambda_.Architecture = lambda_.Architecture.X86_64, + powertools_version: str = "", + layer_name: str = "", + ) -> None: + + docker_file_path = str(Path(__file__).parent.parent / "docker") + + python_normalized_version: str = python_version.to_string().replace("python", "") + + if architecture.to_string() == "x86_64": + docker_architecture: str = "linux/amd64" + else: + docker_architecture: str = "linux/arm64" + + super().__init__( + scope, + construct_id, + code=lambda_.Code.from_docker_build( + docker_file_path, + build_args={ + "PACKAGE_SUFFIX": construct_build_args( + include_extras, + powertools_version, + ), + "PYTHON_VERSION": python_normalized_version, + }, + platform=docker_architecture, + ), + layer_version_name=layer_name, + license="MIT-0", + compatible_runtimes=[python_version], + description=f"Powertools for AWS Lambda (Python) V3 [{architecture.to_string()} - Python {python_normalized_version}]" # noqa E501 + + (" with extra dependencies" if include_extras else "") + + (f" version {powertools_version}" if powertools_version else " latest version"), + compatible_architectures=[architecture] if architecture else None, + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/tests/__init__.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/tests/unit/__init__.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/tests/unit/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/tests/unit/test_new_cdk_constructor_stack.py b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/tests/unit/test_new_cdk_constructor_stack.py new file mode 100644 index 0000000000000000000000000000000000000000..df518ca87e0c8aee8e8a81796e402e41470efbc6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/layer_constructors/tests/unit/test_new_cdk_constructor_stack.py @@ -0,0 +1,190 @@ +import aws_cdk +import pytest +from aws_cdk import assertions +from aws_cdk import aws_lambda as lambda_ + +from layer_v3.layer_constructors.helpers import construct_build_args +from layer_v3.layer_constructors.layer_stack import LambdaPowertoolsLayerPythonV3 + +# Test suit + + +def test_with_no_configuration_constructor(): + + app = aws_cdk.App() + stack = aws_cdk.Stack(app, "TestStack") + LambdaPowertoolsLayerPythonV3(stack, "LambdaPowertoolsLayerPythonV3") + + template = assertions.Template.from_stack(stack) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"LicenseInfo": "MIT-0"}) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"CompatibleRuntimes": ["python3.13"]}) + + +@pytest.mark.parametrize( + "python_version", + [ + lambda_.Runtime.PYTHON_3_8, + lambda_.Runtime.PYTHON_3_9, + lambda_.Runtime.PYTHON_3_10, + lambda_.Runtime.PYTHON_3_11, + lambda_.Runtime.PYTHON_3_12, + lambda_.Runtime.PYTHON_3_13, + ], +) +def test_with_different_python_version_x86_64(python_version): + + inner_python_version: lambda_.Runtime = python_version + + app = aws_cdk.App() + stack = aws_cdk.Stack(app, "TestStack") + + LambdaPowertoolsLayerPythonV3( + stack, + "LambdaPowertoolsLayerPythonV3", + python_version=inner_python_version, + powertools_version="3.0.0", + layer_name="Powertools", + ) + template = assertions.Template.from_stack(stack) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"LicenseInfo": "MIT-0"}) + + template.has_resource_properties( + "AWS::Lambda::LayerVersion", + {"CompatibleRuntimes": [inner_python_version.to_string()]}, + ) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"CompatibleArchitectures": ["x86_64"]}) + + +@pytest.mark.parametrize( + "python_version", + [ + lambda_.Runtime.PYTHON_3_8, + lambda_.Runtime.PYTHON_3_9, + lambda_.Runtime.PYTHON_3_10, + lambda_.Runtime.PYTHON_3_11, + lambda_.Runtime.PYTHON_3_12, + lambda_.Runtime.PYTHON_3_13, + ], +) +def test_with_different_python_version_arm64(python_version): + + inner_python_version: lambda_.Runtime = python_version + + app = aws_cdk.App() + stack = aws_cdk.Stack(app, "TestStack") + LambdaPowertoolsLayerPythonV3( + stack, + "LambdaPowertoolsLayerPythonV3", + python_version=inner_python_version, + architecture=lambda_.Architecture.ARM_64, + powertools_version="3.0.0", + layer_name="Powertools", + ) + template = assertions.Template.from_stack(stack) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"LicenseInfo": "MIT-0"}) + + template.has_resource_properties( + "AWS::Lambda::LayerVersion", + {"CompatibleRuntimes": [inner_python_version.to_string()]}, + ) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"CompatibleArchitectures": ["arm64"]}) + + +def test_with_custom_name(): + + app = aws_cdk.App() + stack = aws_cdk.Stack(app, "TestStack") + LambdaPowertoolsLayerPythonV3(stack, "LambdaPowertoolsLayerPythonV3", layer_name="custom_name_layer") + template = assertions.Template.from_stack(stack) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"LayerName": "custom_name_layer"}) + + template.has_resource_properties( + "AWS::Lambda::LayerVersion", + { + "Description": "Powertools for AWS Lambda (Python) V3 [x86_64 - Python 3.13] with extra dependencies latest version", # noqa E501 + }, + ) + + +def test_with_extras(): + + app = aws_cdk.App() + stack = aws_cdk.Stack(app, "TestStack") + LambdaPowertoolsLayerPythonV3( + stack, + "LambdaPowertoolsLayerPythonV3", + layer_name="custom_name_layer", + include_extras=True, + powertools_version="3.0.0", + ) + template = assertions.Template.from_stack(stack) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"LayerName": "custom_name_layer"}) + + template.has_resource_properties( + "AWS::Lambda::LayerVersion", + { + "Description": "Powertools for AWS Lambda (Python) V3 [x86_64 - Python 3.13] with extra dependencies version 3.0.0", # noqa E501 + }, + ) + + +def test_with_extras_arm64(): + + app = aws_cdk.App() + stack = aws_cdk.Stack(app, "TestStack") + LambdaPowertoolsLayerPythonV3( + stack, + "LambdaPowertoolsLayerPythonV3", + layer_name="custom_name_layer", + include_extras=True, + powertools_version="3.0.0", + architecture=lambda_.Architecture.ARM_64, + ) + template = assertions.Template.from_stack(stack) + + template.has_resource_properties("AWS::Lambda::LayerVersion", {"LayerName": "custom_name_layer"}) + + template.has_resource_properties( + "AWS::Lambda::LayerVersion", + { + "Description": "Powertools for AWS Lambda (Python) V3 [arm64 - Python 3.13] with extra dependencies version 3.0.0", # noqa E501 + }, + ) + + +def test_build_args_with_version(): + + build_args = construct_build_args(include_extras=True, version="3.0.0") + + assert build_args == "[all]==3.0.0" + + +def test_build_args_without_version(): + + build_args = construct_build_args(include_extras=True) + + assert build_args == "[all]" + + +def test_build_args_with_github_tag(): + + version = "git+https://github.com/awslabs/aws-lambda-powertools-python@v2" + + build_args = construct_build_args(include_extras=True, version=version) + + assert build_args == f"[all] @ {version}" + + +def test_build_args_with_no_version_and_no_extra(): + + build_args = construct_build_args(include_extras=False) + + assert build_args == "" diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/poetry.lock b/testbed/aws-powertools__powertools-lambda-python/layer_v3/poetry.lock new file mode 100644 index 0000000000000000000000000000000000000000..d54fb164c051c22e9120f5b2987490a622099ba6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/poetry.lock @@ -0,0 +1,472 @@ +# This file is automatically @generated by Poetry 1.8.4 and should not be changed by hand. + +[[package]] +name = "attrs" +version = "24.2.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2"}, + {file = "attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346"}, +] + +[package.extras] +benchmark = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +cov = ["cloudpickle", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +dev = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pre-commit", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier (<24.7)"] +tests = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] +tests-mypy = ["mypy (>=1.11.1)", "pytest-mypy-plugins"] + +[[package]] +name = "aws-cdk-asset-awscli-v1" +version = "2.2.211" +description = "A library that contains the AWS CLI for use in Lambda Layers" +optional = false +python-versions = "~=3.8" +files = [ + {file = "aws_cdk.asset_awscli_v1-2.2.211-py3-none-any.whl", hash = "sha256:8237a2a2a1d38cb5982d6ec0dbf1d5c7a4b62c2071d1d058b03440b3af401076"}, + {file = "aws_cdk_asset_awscli_v1-2.2.211.tar.gz", hash = "sha256:d3fc198b4673b6c2b5978192f4b4764352bb14b5b4b85a96dedc0f47c768c2f3"}, +] + +[package.dependencies] +jsii = ">=1.104.0,<2.0.0" +publication = ">=0.0.3" +typeguard = ">=2.13.3,<4.3.0" + +[[package]] +name = "aws-cdk-asset-kubectl-v20" +version = "2.1.3" +description = "A Lambda Layer that contains kubectl v1.20" +optional = false +python-versions = "~=3.8" +files = [ + {file = "aws_cdk.asset_kubectl_v20-2.1.3-py3-none-any.whl", hash = "sha256:d5612e5bd03c215a28ce53193b1144ecf4e93b3b6779563c046a8a74d83a3979"}, + {file = "aws_cdk_asset_kubectl_v20-2.1.3.tar.gz", hash = "sha256:237cd8530d9e8be0bbc7159af927dbb6b7f91bf3f4099c8ef4d9a213b34264be"}, +] + +[package.dependencies] +jsii = ">=1.103.1,<2.0.0" +publication = ">=0.0.3" +typeguard = ">=2.13.3,<5.0.0" + +[[package]] +name = "aws-cdk-asset-node-proxy-agent-v6" +version = "2.1.0" +description = "@aws-cdk/asset-node-proxy-agent-v6" +optional = false +python-versions = "~=3.8" +files = [ + {file = "aws_cdk.asset_node_proxy_agent_v6-2.1.0-py3-none-any.whl", hash = "sha256:24a388b69a44d03bae6dbf864c4e25ba650d4b61c008b4568b94ffbb9a69e40e"}, + {file = "aws_cdk_asset_node_proxy_agent_v6-2.1.0.tar.gz", hash = "sha256:1f292c0631f86708ba4ee328b3a2b229f7e46ea1c79fbde567ee9eb119c2b0e2"}, +] + +[package.dependencies] +jsii = ">=1.103.1,<2.0.0" +publication = ">=0.0.3" +typeguard = ">=2.13.3,<5.0.0" + +[[package]] +name = "aws-cdk-cloud-assembly-schema" +version = "38.0.1" +description = "Cloud Assembly Schema" +optional = false +python-versions = "~=3.8" +files = [ + {file = "aws_cdk.cloud_assembly_schema-38.0.1-py3-none-any.whl", hash = "sha256:92613b46213b460681e9424f09b77f06ff059eb1c773092540364ef82fcecf55"}, + {file = "aws_cdk_cloud_assembly_schema-38.0.1.tar.gz", hash = "sha256:7c75861adc41f7b959910d4b3b191ea242815402e599dbfa31934892838ae25e"}, +] + +[package.dependencies] +jsii = ">=1.103.1,<2.0.0" +publication = ">=0.0.3" +typeguard = ">=2.13.3,<5.0.0" + +[[package]] +name = "aws-cdk-lib" +version = "2.167.0" +description = "Version 2 of the AWS Cloud Development Kit library" +optional = false +python-versions = "~=3.8" +files = [ + {file = "aws_cdk_lib-2.167.0-py3-none-any.whl", hash = "sha256:0af251de961332ab0a54c0c1b31d1cc26677ddd6be7b5f94ee38477a0b541cc4"}, + {file = "aws_cdk_lib-2.167.0.tar.gz", hash = "sha256:2873d1285ce6ceae810783db16d1a9f6533604b995237da05bdc5ba69b9af5f5"}, +] + +[package.dependencies] +"aws-cdk.asset-awscli-v1" = ">=2.2.208,<3.0.0" +"aws-cdk.asset-kubectl-v20" = ">=2.1.3,<3.0.0" +"aws-cdk.asset-node-proxy-agent-v6" = ">=2.1.0,<3.0.0" +"aws-cdk.cloud-assembly-schema" = ">=38.0.1,<39.0.0" +constructs = ">=10.0.0,<11.0.0" +jsii = ">=1.104.0,<2.0.0" +publication = ">=0.0.3" +typeguard = ">=2.13.3,<4.3.0" + +[[package]] +name = "boto3" +version = "1.35.60" +description = "The AWS SDK for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "boto3-1.35.60-py3-none-any.whl", hash = "sha256:a34d28de1a1f6ca6ec3edd05c26db16e422293d8f9dcd94f308059a434596753"}, + {file = "boto3-1.35.60.tar.gz", hash = "sha256:e573504c67c3e438fd4b0222119ed1a73b644c78eb3b6dee0b36a6c70ecf7677"}, +] + +[package.dependencies] +botocore = ">=1.35.60,<1.36.0" +jmespath = ">=0.7.1,<2.0.0" +s3transfer = ">=0.10.0,<0.11.0" + +[package.extras] +crt = ["botocore[crt] (>=1.21.0,<2.0a0)"] + +[[package]] +name = "botocore" +version = "1.35.60" +description = "Low-level, data-driven core of boto 3." +optional = false +python-versions = ">=3.8" +files = [ + {file = "botocore-1.35.60-py3-none-any.whl", hash = "sha256:ddccfc39a0a55ac0321191a36d29c2ea9be2c96ceefb3928dd3c91c79c494d50"}, + {file = "botocore-1.35.60.tar.gz", hash = "sha256:378f53037d817bed2c04a006b7319745e664030182211429c924647273b29bc9"}, +] + +[package.dependencies] +jmespath = ">=0.7.1,<2.0.0" +python-dateutil = ">=2.1,<3.0.0" +urllib3 = [ + {version = ">=1.25.4,<1.27", markers = "python_version < \"3.10\""}, + {version = ">=1.25.4,<2.2.0 || >2.2.0,<3", markers = "python_version >= \"3.10\""}, +] + +[package.extras] +crt = ["awscrt (==0.22.0)"] + +[[package]] +name = "cattrs" +version = "24.1.2" +description = "Composable complex class support for attrs and dataclasses." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cattrs-24.1.2-py3-none-any.whl", hash = "sha256:67c7495b760168d931a10233f979b28dc04daf853b30752246f4f8471c6d68d0"}, + {file = "cattrs-24.1.2.tar.gz", hash = "sha256:8028cfe1ff5382df59dd36474a86e02d817b06eaf8af84555441bac915d2ef85"}, +] + +[package.dependencies] +attrs = ">=23.1.0" +exceptiongroup = {version = ">=1.1.1", markers = "python_version < \"3.11\""} +typing-extensions = {version = ">=4.1.0,<4.6.3 || >4.6.3", markers = "python_version < \"3.11\""} + +[package.extras] +bson = ["pymongo (>=4.4.0)"] +cbor2 = ["cbor2 (>=5.4.6)"] +msgpack = ["msgpack (>=1.0.5)"] +msgspec = ["msgspec (>=0.18.5)"] +orjson = ["orjson (>=3.9.2)"] +pyyaml = ["pyyaml (>=6.0)"] +tomlkit = ["tomlkit (>=0.11.8)"] +ujson = ["ujson (>=5.7.0)"] + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "constructs" +version = "10.4.2" +description = "A programming model for software-defined state" +optional = false +python-versions = "~=3.8" +files = [ + {file = "constructs-10.4.2-py3-none-any.whl", hash = "sha256:1f0f59b004edebfde0f826340698b8c34611f57848139b7954904c61645f13c1"}, + {file = "constructs-10.4.2.tar.gz", hash = "sha256:ce54724360fffe10bab27d8a081844eb81f5ace7d7c62c84b719c49f164d5307"}, +] + +[package.dependencies] +jsii = ">=1.102.0,<2.0.0" +publication = ">=0.0.3" +typeguard = ">=2.13.3,<2.14.0" + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "importlib-resources" +version = "6.4.5" +description = "Read resources from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, +] + +[package.dependencies] +zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} + +[package.extras] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"] +cover = ["pytest-cov"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +enabler = ["pytest-enabler (>=2.2)"] +test = ["jaraco.test (>=5.4)", "pytest (>=6,!=8.1.*)", "zipp (>=3.17)"] +type = ["pytest-mypy"] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "jmespath" +version = "1.0.1" +description = "JSON Matching Expressions" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980"}, + {file = "jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe"}, +] + +[[package]] +name = "jsii" +version = "1.104.0" +description = "Python client for jsii runtime" +optional = false +python-versions = "~=3.8" +files = [ + {file = "jsii-1.104.0-py3-none-any.whl", hash = "sha256:c1da4d21be208db7dd341bc8fd9c4cdbaa5ff1a3cec7ce4f5f4e3ce89bc949cc"}, + {file = "jsii-1.104.0.tar.gz", hash = "sha256:1e9b3e49797450258d473c16052258f2291bde4dd410d30c21e325c000c10a0c"}, +] + +[package.dependencies] +attrs = ">=21.2,<25.0" +cattrs = ">=1.8,<24.2" +importlib-resources = ">=5.2.0" +publication = ">=0.0.3" +python-dateutil = "*" +typeguard = ">=2.13.3,<4.3.0" +typing-extensions = ">=3.8,<5.0" + +[[package]] +name = "packaging" +version = "24.2" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "publication" +version = "0.0.3" +description = "Publication helps you maintain public-api-friendly modules by preventing unintentional access to private implementation details via introspection." +optional = false +python-versions = "*" +files = [ + {file = "publication-0.0.3-py2.py3-none-any.whl", hash = "sha256:0248885351febc11d8a1098d5c8e3ab2dabcf3e8c0c96db1e17ecd12b53afbe6"}, + {file = "publication-0.0.3.tar.gz", hash = "sha256:68416a0de76dddcdd2930d1c8ef853a743cc96c82416c4e4d3b5d901c6276dc4"}, +] + +[[package]] +name = "pytest" +version = "7.4.4" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8"}, + {file = "pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=0.12,<2.0" +tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""} + +[package.extras] +testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +description = "Extensions to the standard Python datetime module" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "s3transfer" +version = "0.10.3" +description = "An Amazon S3 Transfer Manager" +optional = false +python-versions = ">=3.8" +files = [ + {file = "s3transfer-0.10.3-py3-none-any.whl", hash = "sha256:263ed587a5803c6c708d3ce44dc4dfedaab4c1a32e8329bab818933d79ddcf5d"}, + {file = "s3transfer-0.10.3.tar.gz", hash = "sha256:4f50ed74ab84d474ce614475e0b8d5047ff080810aac5d01ea25231cfc944b0c"}, +] + +[package.dependencies] +botocore = ">=1.33.2,<2.0a.0" + +[package.extras] +crt = ["botocore[crt] (>=1.33.2,<2.0a.0)"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "tomli" +version = "2.1.0" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391"}, + {file = "tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8"}, +] + +[[package]] +name = "typeguard" +version = "2.13.3" +description = "Run-time type checker for Python" +optional = false +python-versions = ">=3.5.3" +files = [ + {file = "typeguard-2.13.3-py3-none-any.whl", hash = "sha256:5e3e3be01e887e7eafae5af63d1f36c849aaa94e3a0112097312aabfa16284f1"}, + {file = "typeguard-2.13.3.tar.gz", hash = "sha256:00edaa8da3a133674796cf5ea87d9f4b4c367d77476e185e80251cc13dfbb8c4"}, +] + +[package.extras] +doc = ["sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] +test = ["mypy", "pytest", "typing-extensions"] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "urllib3" +version = "1.26.20" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "urllib3-1.26.20-py2.py3-none-any.whl", hash = "sha256:0ed14ccfbf1c30a9072c7ca157e4319b70d65f623e91e7b32fadb2853431016e"}, + {file = "urllib3-1.26.20.tar.gz", hash = "sha256:40c2dc0c681e47eb8f90e7e27bf6ff7df2e677421fd46756da1161c39ca70d32"}, +] + +[package.extras] +brotli = ["brotli (==1.0.9)", "brotli (>=1.0.9)", "brotlicffi (>=0.8.0)", "brotlipy (>=0.6.0)"] +secure = ["certifi", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "ipaddress", "pyOpenSSL (>=0.14)", "urllib3-secure-extra"] +socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"] + +[[package]] +name = "urllib3" +version = "2.2.3" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.8" +files = [ + {file = "urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac"}, + {file = "urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[[package]] +name = "zipp" +version = "3.20.2" +description = "Backport of pathlib-compatible object wrapper for zip files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350"}, + {file = "zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29"}, +] + +[package.extras] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"] +cover = ["pytest-cov"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +enabler = ["pytest-enabler (>=2.2)"] +test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"] +type = ["pytest-mypy"] + +[metadata] +lock-version = "2.0" +python-versions = "^3.8" +content-hash = "464e9008c513dc7aabd5e5285358b4447f791c62668f713c2fc7a5e71b494fd5" diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/pyproject.toml b/testbed/aws-powertools__powertools-lambda-python/layer_v3/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..30a148bc76e53b8321e890c40d95744f1db1b793 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/pyproject.toml @@ -0,0 +1,18 @@ +[tool.poetry] +name = "aws-lambda-powertools-python-layer" +version = "3.0.0" +description = "Powertools for AWS Lambda (Python) Lambda Layers" +authors = ["Powertools for AWS Maintainers "] + +license = "MIT" +[tool.poetry.dependencies] +python = "^3.8" +aws-cdk-lib = "^2.167.0" + +[tool.poetry.dev-dependencies] +pytest = "^7.1.2" +boto3 = "^1.24.46" + +[build-system] +requires = ["poetry-core>=1.0.0"] +build-backend = "poetry.core.masonry.api" diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/sar/template.txt b/testbed/aws-powertools__powertools-lambda-python/layer_v3/sar/template.txt new file mode 100644 index 0000000000000000000000000000000000000000..08e859bebde2cea5e25c8ece269644fc7be4a052 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/sar/template.txt @@ -0,0 +1,38 @@ +AWSTemplateFormatVersion: '2010-09-09' + +Metadata: + AWS::ServerlessRepo::Application: + Name: + Description: "AWS Lambda Layer for Powertools for AWS Lambda V3 [] with python " + Author: AWS + SpdxLicenseId: Apache-2.0 + LicenseUrl: /LICENSE + ReadmeUrl: /README.md + Labels: ['layer','lambda','powertools','python', 'aws', ''] + HomePageUrl: https://github.com/aws-powertools/powertools-lambda-python + SemanticVersion: + SourceCodeUrl: https://github.com/aws-powertools/powertools-lambda-python + +Transform: AWS::Serverless-2016-10-31 +Description: AWS Lambda Layer for Powertools for AWS Lambda V3 [] with python + +Resources: + LambdaLayer: + Type: AWS::Serverless::LayerVersion + Properties: + Description: "AWS Lambda Layer for Powertools for AWS Lambda V3 [] - python - version " + LayerName: + ContentUri: + CompatibleArchitectures: + - + CompatibleRuntimes: + - python + LicenseInfo: 'Available under the Apache-2.0 license.' + RetentionPolicy: Retain + +Outputs: + LayerVersionArn: + Description: ARN for the published Layer version + Value: !Ref LambdaLayer + Export: + Name: !Sub 'LayerVersionArn-${AWS::StackName}' diff --git a/testbed/aws-powertools__powertools-lambda-python/layer_v3/scripts/update_layer_arn.sh b/testbed/aws-powertools__powertools-lambda-python/layer_v3/scripts/update_layer_arn.sh new file mode 100644 index 0000000000000000000000000000000000000000..484448c7a89087fcacf2ea428d96d42d023abed0 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/layer_v3/scripts/update_layer_arn.sh @@ -0,0 +1,78 @@ +#!/bin/bash + +# This script is run during the publish_v3_layer.yml CI job, +# and it is responsible for replacing the layer ARN in our documentation, +# based on the output files generated by CDK when deploying to each pseudo_region. +# +# see .github/workflows/reusable_deploy_v3_layer_stack.yml + +set -eo pipefail +set -x + +if [[ $# -ne 1 ]]; then + cat < line + # sed doesn't support \d+ in a portable way, so we cheat with (:digit: :digit: *) + sed -i -e "s/$prefix:[[:digit:]][[:digit:]]*/$line/g" docs/index.md + + # We use the eu-central-1 layer as the version for all the frameworks (SAM, CDK, SLS, etc) + # We could have used any other region. What's important is the version at the end. + + # Examples of strings found in the documentation with pseudo regions: + # arn:aws:lambda:{region}:017000801446:layer:AWSLambdaPowertoolsPython:39 + # arn:aws:lambda:${AWS::Region}:017000801446:layer:AWSLambdaPowertoolsPython:39 + # arn:aws:lambda:${aws:region}:017000801446:layer:AWSLambdaPowertoolsPython:39 + # arn:aws:lambda:{env.region}:017000801446:layer:AWSLambdaPowertoolsPython:39 + if [[ "$line" == *"eu-central-1"* ]]; then + # These are all the framework pseudo parameters currently found in the docs + for pseudo_region in '{region}' '${AWS::Region}' '${aws:region}' '{env.region}'; do + prefix_pseudo_region=$(echo "$prefix" | sed "s/eu-central-1/${pseudo_region}/") + # prefix_pseudo_region = arn:aws:lambda:${AWS::Region}:017000801446:layer:AWSLambdaPowertoolsPython + + line_pseudo_region=$(echo "$line" | sed "s/eu-central-1/${pseudo_region}/") + # line_pseudo_region = arn:aws:lambda:${AWS::Region}:017000801446:layer:AWSLambdaPowertoolsPython:49 + + # Replace all the "prefix_pseudo_region"'s in the file + # prefix_pseudo_region:\d+ ==> line_pseudo_region + sed -i -e "s/$prefix_pseudo_region:[[:digit:]][[:digit:]]*/$line_pseudo_region/g" docs/index.md + + # The same strings can also be found in examples on Logger, Tracer and Metrics + sed -i -e "s/$prefix_pseudo_region:[[:digit:]][[:digit:]]*/$line_pseudo_region/g" examples/logger/sam/template.yaml + sed -i -e "s/$prefix_pseudo_region:[[:digit:]][[:digit:]]*/$line_pseudo_region/g" examples/metrics/sam/template.yaml + sed -i -e "s/$prefix_pseudo_region:[[:digit:]][[:digit:]]*/$line_pseudo_region/g" examples/tracer/sam/template.yaml + done + fi + done +done diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..9df3e23929bdb4f609934e357db6448edbec1ed0 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.39.2a0-py3-none-any.whl","digest":{"sha256":"9adf40747a134d4a611f9f9a8b7ccf7d026e51c9b17921bab847536ec4874349"}},{"name":"./aws_lambda_powertools-2.39.2a0.tar.gz","digest":{"sha256":"cf9b2759d1783e95c840974eb0bce70cb0fea21a5d2690589095b64211ee081e"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"6782b6c1a0c5db7e7833569f411bf3c331e873bf"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{"event_inputs":{"skip_code_quality":"false","skip_pypi":"false"}},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"workflow_dispatch","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"inputs":{"skip_code_quality":"false","skip_pypi":"false"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"ref":"refs/heads/develop","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":373,"forks_count":373,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":93,"open_issues_count":93,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-06-20T15:34:49Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":45863,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2705,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-06-20T15:33:42Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2705,"watchers_count":2705,"web_commit_signoff_required":true},"sender":{"avatar_url":"https://avatars.githubusercontent.com/u/4295173?v=4","events_url":"https://api.github.com/users/leandrodamascena/events{/privacy}","followers_url":"https://api.github.com/users/leandrodamascena/followers","following_url":"https://api.github.com/users/leandrodamascena/following{/other_user}","gists_url":"https://api.github.com/users/leandrodamascena/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/leandrodamascena","id":4295173,"login":"leandrodamascena","node_id":"MDQ6VXNlcjQyOTUxNzM=","organizations_url":"https://api.github.com/users/leandrodamascena/orgs","received_events_url":"https://api.github.com/users/leandrodamascena/received_events","repos_url":"https://api.github.com/users/leandrodamascena/repos","site_admin":false,"starred_url":"https://api.github.com/users/leandrodamascena/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/leandrodamascena/subscriptions","type":"User","url":"https://api.github.com/users/leandrodamascena"},"workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9600365695","github_run_number":"1","github_sha1":"6782b6c1a0c5db7e7833569f411bf3c331e873bf"}},"metadata":{"buildInvocationID":"9600365695-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"6782b6c1a0c5db7e7833569f411bf3c331e873bf"}}]}}","signatures":[{"keyid":"","sig":"MEUCIF5jIdfPaXdXkrWip0720tiRwn4j1Eom0G2OvnxJwVkKAiEA8satyMfu+l9oE0ZhkNwojxyOaO1qytj5zSn2XdN9WbE=","cert":"-----BEGIN CERTIFICATE-----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\njTK1lCTqcL37pZNu0gcDlIfTZ6+FMdTK1Gtks+H93WksCyruINl/Q7SghTw=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..5e9498782035836ffd240bb969c8e32edd9cf875 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.39.2a1-py3-none-any.whl","digest":{"sha256":"cb5855090d08798be92aaa8dc937ff641c69752ffaf5b63a2d0cec742c71fabb"}},{"name":"./aws_lambda_powertools-2.39.2a1.tar.gz","digest":{"sha256":"ba7f909aab6112ed1efe1d97ae0486ea905481e3eaa214a93c4524d5997ab6bd"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"de9bfcc4b978aba7b0bbc7cac0fe3ddff2eaec75"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":373,"forks_count":373,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":95,"open_issues_count":95,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-06-20T22:25:58Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":46501,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2707,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-06-21T07:44:02Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2707,"watchers_count":2707,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9610320193","github_run_number":"2","github_sha1":"de9bfcc4b978aba7b0bbc7cac0fe3ddff2eaec75"}},"metadata":{"buildInvocationID":"9610320193-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"de9bfcc4b978aba7b0bbc7cac0fe3ddff2eaec75"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCcBjysUNglIkqajbxhzI/SYnzvIrJeXO1pwvxZ+Kjm2wIgM6gWXHt0rqZ6IELqz/UbaSyCwep5do8GwfOt8k/uwFA=","cert":"-----BEGIN CERTIFICATE-----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\nQRq0dmZWKmsU/GjCy4sbK2W3jtoS0sGv9g==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..9c06657ffddf1b662c8573117c0692dddd7a38a5 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.39.2a2-py3-none-any.whl","digest":{"sha256":"7fbc605855a5d2bfef41f602ad100c48d050dcf750a0ab975ef5930c8a9427dc"}},{"name":"./aws_lambda_powertools-2.39.2a2.tar.gz","digest":{"sha256":"802a3a7825e9c2bad13d8c12089fde078593a3ee5fc164af0b34f9e3af0f41e5"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"bd80cf4626d99d7f067ccb9aa81e967e6443c11d"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":375,"forks_count":375,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":97,"open_issues_count":97,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-06-23T10:03:51Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":46315,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2709,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-06-24T07:11:21Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2709,"watchers_count":2709,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9641740057","github_run_number":"3","github_sha1":"bd80cf4626d99d7f067ccb9aa81e967e6443c11d"}},"metadata":{"buildInvocationID":"9641740057-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"bd80cf4626d99d7f067ccb9aa81e967e6443c11d"}}]}}","signatures":[{"keyid":"","sig":"MEUCIBn5AhbydV+cFbI1gZGslqr46YyNsrUYSl0Qii4/PY1UAiEA/K+B9N73QdH0KQiZEKC8h/6VMcqTRYCCYtXZG/AxmwY=","cert":"-----BEGIN CERTIFICATE-----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\nTMj1MEQrjTJHMlY21StiEwJ0UPCdyiyWdw==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a3/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a3/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..75e63d441b7974fcbd7dfdf4bcc1dae6959e06b1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a3/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.39.2a3-py3-none-any.whl","digest":{"sha256":"392d5a6c3d0f27a2470a3463ec0778230832e41c507af5282c36dea0c4270d93"}},{"name":"./aws_lambda_powertools-2.39.2a3.tar.gz","digest":{"sha256":"2c8380de3a27a023501b9118503623af8a3c994303c66a2c4af8a304f6778706"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"63f5b5cc44c5ccae6651397c2dee4532dcb346ce"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":98,"open_issues_count":98,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-06-25T07:17:30Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":47028,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2711,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-06-24T23:46:21Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2711,"watchers_count":2711,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9658673731","github_run_number":"4","github_sha1":"63f5b5cc44c5ccae6651397c2dee4532dcb346ce"}},"metadata":{"buildInvocationID":"9658673731-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"63f5b5cc44c5ccae6651397c2dee4532dcb346ce"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQD3YMttaa5pEA1Qc8T7/MpIOCwV3Ejt3YAVNqXePDzSUwIhAOnwcGPmD8cDN8wUHgyV0NS0A+H5xzKtUhdr9Id2bwLj","cert":"-----BEGIN CERTIFICATE-----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\nJ5Zah0EwyutDQ+kVJeMUZZSZEgFayR4fxtQ=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a4/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a4/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..fe41d297f4323aa5ff9f533fc05af384ca0d3d17 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a4/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.39.2a4-py3-none-any.whl","digest":{"sha256":"24c37a77965012ab80968ad5828783d28a6fd68a378647430f43424164d26c49"}},{"name":"./aws_lambda_powertools-2.39.2a4.tar.gz","digest":{"sha256":"f4872f6f0a36455cafc956334bcafb69176b8ac7fb5b668e5381d7c0e50662d9"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d14e0bd7aa85fe775d7b9419c3a9d2aac9b95cfb"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":100,"open_issues_count":100,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-06-26T07:52:10Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":42794,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2712,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-06-26T08:01:39Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2712,"watchers_count":2712,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9675814801","github_run_number":"5","github_sha1":"d14e0bd7aa85fe775d7b9419c3a9d2aac9b95cfb"}},"metadata":{"buildInvocationID":"9675814801-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d14e0bd7aa85fe775d7b9419c3a9d2aac9b95cfb"}}]}}","signatures":[{"keyid":"","sig":"MEQCICwmcOzobfi/tmLVa8XA9bznXQg7UFpD/vRwIRz0kMO6AiASDJ7ROXqOpbrfW/776osg8I4xJZkIJA1+heEUyrE+4A==","cert":"-----BEGIN CERTIFICATE-----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\n3CpsbDC3AqU0J01SoipEBafZuFTlB9E=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a5/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a5/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..6a13ed17f4e76e79ec10dbc95937b68f16d83037 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.39.2a5/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.39.2a5-py3-none-any.whl","digest":{"sha256":"a2f1795c90b12fe33ed9d45c7374e8b0aac75607413d496bf991292bcb801cdb"}},{"name":"./aws_lambda_powertools-2.39.2a5.tar.gz","digest":{"sha256":"17a36b67e48d4ec71fc3280827e21e763cb9295725bc5eddc5c17993944d7415"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"84698f252e898a3e392e6a1268ce89ddad30dd31"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":95,"open_issues_count":95,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-06-27T00:31:20Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":43290,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2713,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-06-26T23:48:53Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2713,"watchers_count":2713,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9692872138","github_run_number":"6","github_sha1":"84698f252e898a3e392e6a1268ce89ddad30dd31"}},"metadata":{"buildInvocationID":"9692872138-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"84698f252e898a3e392e6a1268ce89ddad30dd31"}}]}}","signatures":[{"keyid":"","sig":"MEUCIEyoVJUjmhvxjI8hApH62a+he8gs91BWS/09mm5Zw9qjAiEAlXw7CYCQfdYPrRHYpxIZnEXpDxQAS5FvK/gVlsU1XIU=","cert":"-----BEGIN CERTIFICATE-----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\nJ+BJJqQBIfVmZHpScglFDED9Z5Sde24N\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.1a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.1a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..8d7c0db9c1f109f8826ca1a16dc512b7c3953aa9 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.1a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.1a0-py3-none-any.whl","digest":{"sha256":"1935ba308d0fdad3def7e0dbf237bf87c8e3009d9451fd2ad48a5bf5c3d90f7f"}},{"name":"./aws_lambda_powertools-2.40.1a0.tar.gz","digest":{"sha256":"60e37255c05d6d0df02ca1b74a7be472a20d4ddbd1b0f50a56fa5482f5d147ad"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"893331260681cb153e0b1819871761dfd5947d2f"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":97,"open_issues_count":97,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-06-27T22:51:12Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":44130,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2714,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-06-27T22:49:44Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2714,"watchers_count":2714,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9709486196","github_run_number":"7","github_sha1":"893331260681cb153e0b1819871761dfd5947d2f"}},"metadata":{"buildInvocationID":"9709486196-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"893331260681cb153e0b1819871761dfd5947d2f"}}]}}","signatures":[{"keyid":"","sig":"MEUCIFNylUqxsgVD4K1NHVJm4R4ALGKzVLEulBGLfTSjWvI6AiEAvYq8B2XAm/aJUHIl+sl/VmF5d9lj8xVyiHRYk6IEEno=","cert":"-----BEGIN CERTIFICATE-----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\nxiNHKnQr78ipVEcYmetF++GzqJzGKFLaBQ==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.1a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.1a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..3201e0f432e0ccc68151cb9bfba8458205681403 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.1a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.1a1-py3-none-any.whl","digest":{"sha256":"f3a1956acbf9a770c4a90243e8bff0f10b89d94bbad22df2cc86aa699a50b0e5"}},{"name":"./aws_lambda_powertools-2.40.1a1.tar.gz","digest":{"sha256":"bff56ab132e4e59ddc53d8e06637746d324d28fa32860d6d6a17ff862b6cbacf"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"0c3b48f93a4791d40af046283114156e5a3fdc0a"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{"event_inputs":{"skip_code_quality":"false","skip_pypi":"false"}},"environment":{"github_actor":"heitorlessa","github_actor_id":"3340292","github_base_ref":"","github_event_name":"workflow_dispatch","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"inputs":{"skip_code_quality":"false","skip_pypi":"false"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"ref":"refs/heads/develop","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":98,"open_issues_count":98,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-06-28T11:25:17Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":44015,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2714,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-06-28T11:25:20Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2714,"watchers_count":2714,"web_commit_signoff_required":true},"sender":{"avatar_url":"https://avatars.githubusercontent.com/u/3340292?v=4","events_url":"https://api.github.com/users/heitorlessa/events{/privacy}","followers_url":"https://api.github.com/users/heitorlessa/followers","following_url":"https://api.github.com/users/heitorlessa/following{/other_user}","gists_url":"https://api.github.com/users/heitorlessa/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/heitorlessa","id":3340292,"login":"heitorlessa","node_id":"MDQ6VXNlcjMzNDAyOTI=","organizations_url":"https://api.github.com/users/heitorlessa/orgs","received_events_url":"https://api.github.com/users/heitorlessa/received_events","repos_url":"https://api.github.com/users/heitorlessa/repos","site_admin":false,"starred_url":"https://api.github.com/users/heitorlessa/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/heitorlessa/subscriptions","type":"User","url":"https://api.github.com/users/heitorlessa"},"workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9712027684","github_run_number":"8","github_sha1":"0c3b48f93a4791d40af046283114156e5a3fdc0a"}},"metadata":{"buildInvocationID":"9712027684-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"0c3b48f93a4791d40af046283114156e5a3fdc0a"}}]}}","signatures":[{"keyid":"","sig":"MEQCIEOdz3JsgCN+/8Mr+mlKXO3GW2kJJ+x/flop03jf2O09AiB+2SrEWV17mdrCWE4+/PkeXI0tDV5GqmxwSJayUinntg==","cert":"-----BEGIN CERTIFICATE-----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\nHqqYfZOBL21ipffqKlaDvCVbbN2WNsMxAwlWtCuo9rh/aMdNVrG5SJlP\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..3fb5ce2adaf725aab7f42d5753c2303543537118 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a0-py3-none-any.whl","digest":{"sha256":"09e4d8bb0d29cd4c88fe2548b9c048261984d85ce0871307d7ae39b4cf91fcb3"}},{"name":"./aws_lambda_powertools-2.40.2a0.tar.gz","digest":{"sha256":"dda741f43aeb65e8844d979d168dba9ac80cb9b6b1aa2a7ed1f4c92aba6d0206"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"be7a4cc653e0893815cc50cf8d82f855702c33a5"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-01T07:58:17Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":43644,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2714,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-01T06:40:41Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2714,"watchers_count":2714,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9740431388","github_run_number":"9","github_sha1":"be7a4cc653e0893815cc50cf8d82f855702c33a5"}},"metadata":{"buildInvocationID":"9740431388-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"be7a4cc653e0893815cc50cf8d82f855702c33a5"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCW77goQ6EL2H1FNSueNUlXLoa/7hT8sK/8O1jIjy1G3AIgONYb0goF94tMZCuVN8+pctIVTNHpx157vSNLKl2lCW0=","cert":"-----BEGIN CERTIFICATE-----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\nvxWoHdp7VIG0xwRBu/Pg6d542I7slww9uw==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..709f2df236a0b54da815e6873f53247b915efa33 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a1-py3-none-any.whl","digest":{"sha256":"93de620465394ec9efa71b2b2fa2ddd18b36a55cf0c6da95a6ec17af53da7a44"}},{"name":"./aws_lambda_powertools-2.40.2a1.tar.gz","digest":{"sha256":"71132643967d7e284739a5dc9f1ea5cfc6ccd10784de16b1d3d095acd02835ce"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"21b98208fc658fde109e3739b38679ef16594848"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":98,"open_issues_count":98,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-01T22:41:36Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":43912,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2714,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-01T22:40:34Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2714,"watchers_count":2714,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9757172173","github_run_number":"10","github_sha1":"21b98208fc658fde109e3739b38679ef16594848"}},"metadata":{"buildInvocationID":"9757172173-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"21b98208fc658fde109e3739b38679ef16594848"}}]}}","signatures":[{"keyid":"","sig":"MEUCIDe8B9okXtwYUot5NPAEdfxmAtVg07dl1oJer7598NE4AiEA7UVm2pOUDuzNN7y8VBL/LSfV8zqfTLE8gHflsrlaUPQ=","cert":"-----BEGIN CERTIFICATE-----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\n9gpPHzLrjnywt92qKigKY+EB3g/qnI3FIY8=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..71dee61c363a2cdbcdc7f700d6a61a57264c750d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a2-py3-none-any.whl","digest":{"sha256":"93170daaa4012b9b1ab65911bfffce33f860bbc93e4f3acecfc00796f1b291de"}},{"name":"./aws_lambda_powertools-2.40.2a2.tar.gz","digest":{"sha256":"9c3320dee74a78f5797a16b2497d171b9e4b8a15c0abc2b1adef5119e2747602"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"155401953f022f758250ba455d80f10c0f6c06b0"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-03T07:38:23Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":44638,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2719,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-03T07:33:02Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2719,"watchers_count":2719,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9774074318","github_run_number":"11","github_sha1":"155401953f022f758250ba455d80f10c0f6c06b0"}},"metadata":{"buildInvocationID":"9774074318-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"155401953f022f758250ba455d80f10c0f6c06b0"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQDg5MSWX5G5du6NJjFy9bQjuNsY9hhduhBKKRY/IH4gKwIgMkdSreC8uvSjgRMFFVptdSbVXDt8yOe8GXsUOhoAeyw=","cert":"-----BEGIN CERTIFICATE-----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\n59Ondk1c4h4EeGuYnx/FqBlScgCWqOqr\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a3/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a3/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..611a78e9833777e0e3aa01f59a7ec74493cb4104 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a3/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a3-py3-none-any.whl","digest":{"sha256":"56e272cedf306f9150fad9a23ced6ae8ab1ab06861776f39dd9c1bfa922f113d"}},{"name":"./aws_lambda_powertools-2.40.2a3.tar.gz","digest":{"sha256":"992cb4f878efbb682a88ac6ae483c30863fd81e98c02d69a9db669ed2b12356c"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"7503cf4ec3091fa6a72496ed9f752c02c70ec68d"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":376,"forks_count":376,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":102,"open_issues_count":102,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-03T20:55:28Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":45425,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2722,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-04T01:25:46Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2722,"watchers_count":2722,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9790643148","github_run_number":"12","github_sha1":"7503cf4ec3091fa6a72496ed9f752c02c70ec68d"}},"metadata":{"buildInvocationID":"9790643148-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"7503cf4ec3091fa6a72496ed9f752c02c70ec68d"}}]}}","signatures":[{"keyid":"","sig":"MEUCICairwvRlR5Be3uVZWlH6vGdLF/CDhsuAzdqlgBeovFEAiEAxehgcP7EsJCSPpjvDcqeZQf7vfEjdSJ4BuRZMmiHT4Q=","cert":"-----BEGIN CERTIFICATE-----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\nU2zlCTOcfYdsJHFge0Aqhq2CRYZalfAglrAE\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a4/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a4/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..95ccccdc9a343c5baf8aa09872ff49ad2e625397 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a4/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a4-py3-none-any.whl","digest":{"sha256":"9310cf2987d6c3490c0674f6036dd86114d419b6d3cee75b41f5f310ad4c117f"}},{"name":"./aws_lambda_powertools-2.40.2a4.tar.gz","digest":{"sha256":"02ebedc2572698735cade25c927c4d37ec6ed719c807dd262faade8073c5d0ef"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"74232ddd00871967809b0d394e28866395a3b12f"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":377,"forks_count":377,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-04T21:56:36Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":44623,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2722,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-04T21:56:39Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2722,"watchers_count":2722,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9805067689","github_run_number":"13","github_sha1":"74232ddd00871967809b0d394e28866395a3b12f"}},"metadata":{"buildInvocationID":"9805067689-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"74232ddd00871967809b0d394e28866395a3b12f"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQD7M5y5b3LuOxj2kdOhZdFf57G1yPmtmC3jZY3UdcCRjAIhAMNISFYhBcy2zPSPFmR7+TpkBq4mx9+AaHImHXo482Dj","cert":"-----BEGIN CERTIFICATE-----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\ncS/ow+kXLbwJxBkSOYEfWHPmkF93Vs1jha8=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a5/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a5/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..4e0af4ad6db3ee0d3bd6711ac1f4e9384e72468d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a5/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a5-py3-none-any.whl","digest":{"sha256":"47333356860e173d6faae516142f0adba780a824a676acfecfa7cb82932f5850"}},{"name":"./aws_lambda_powertools-2.40.2a5.tar.gz","digest":{"sha256":"250ad274fdca398336bec9f9b6560d1ebf7415d9371ef41ce5622044f3bd4d8b"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"abcb350a16f28b96fe6db5a636eec948ee35517e"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":101,"open_issues_count":101,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-08T07:50:57Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":45145,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2724,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-06T12:51:26Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2724,"watchers_count":2724,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9835766424","github_run_number":"14","github_sha1":"abcb350a16f28b96fe6db5a636eec948ee35517e"}},"metadata":{"buildInvocationID":"9835766424-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"abcb350a16f28b96fe6db5a636eec948ee35517e"}}]}}","signatures":[{"keyid":"","sig":"MEQCICL4LxUlHvrhTANSxZSjkwBVtoku3sEZg1iSNgCv5rtZAiBfFguZ/UgQ17uAm6o3yN2jxo9Yu83/H9s4+MMn/GeVUQ==","cert":"-----BEGIN CERTIFICATE-----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\n/WPsifr9zefkwGfR+KEJ0YPulvKGk6kKfYs=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a6/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a6/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..24f6d1ad602e64b003cd0a7dc37434cfc7a00010 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a6/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a6-py3-none-any.whl","digest":{"sha256":"831157f479792893f199adf81d20f171ac365e5982b511a7db33aaaf4392947f"}},{"name":"./aws_lambda_powertools-2.40.2a6.tar.gz","digest":{"sha256":"d4308216f6cbddfc52d12b649bd9949674d636b0e55016f7aaa517daa3cd357f"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"dff05ccab019efbe1b5a0ffdacdd59c90d94d77f"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-08T22:08:35Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":45701,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2724,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-08T22:07:34Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2724,"watchers_count":2724,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9853235674","github_run_number":"15","github_sha1":"dff05ccab019efbe1b5a0ffdacdd59c90d94d77f"}},"metadata":{"buildInvocationID":"9853235674-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"dff05ccab019efbe1b5a0ffdacdd59c90d94d77f"}}]}}","signatures":[{"keyid":"","sig":"MEUCIEF8RlomkeiDXn1WOL3Reo8jBI/cnFJzO10YccROiyBqAiEAhIRaXTzzTCZd9alrs94lwQRqKec2j8txZYbfcxoKMZM=","cert":"-----BEGIN CERTIFICATE-----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\nivAJdijBgC3+sDhbHr+/IYUi2uBUDCpO5A==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a7/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a7/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..26ee243012816aab16993266ec6c927900f6fcdc --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a7/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a7-py3-none-any.whl","digest":{"sha256":"23a2dc0ed661bbd4ee5251ecc4bb16c380b7afc298a6c53c53b07bc1f135a934"}},{"name":"./aws_lambda_powertools-2.40.2a7.tar.gz","digest":{"sha256":"eac162a9769fba7db27f9c182db87e8680d50c1e05c8cbf8e380acaa0a77d9f8"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d37d192d904a0f985c131def4109dd304d398d89"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-10T06:23:54Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":45292,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2727,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-10T06:22:18Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2727,"watchers_count":2727,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9870416029","github_run_number":"16","github_sha1":"d37d192d904a0f985c131def4109dd304d398d89"}},"metadata":{"buildInvocationID":"9870416029-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d37d192d904a0f985c131def4109dd304d398d89"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCuBJHkh6U+orCC5FWHgeJohRJ0Q7zIDxN6AD+3dyTjswIgPOjfj7NTj8CuOIDfBFHNvbJpOjRPsZS3jo7unZKWDIo=","cert":"-----BEGIN CERTIFICATE-----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\nK/WH6+y1Umhh3qm/EmsPxYMA8C5Quf3qIg==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a8/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a8/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..2d4ec27b2a47fb0a550fb26c5b3b6b84b8a6e4f3 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.40.2a8/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.40.2a8-py3-none-any.whl","digest":{"sha256":"129b90ddff6d3f050c1a1a4267305c96b67be3f31a8787d2828e3de50d1d7466"}},{"name":"./aws_lambda_powertools-2.40.2a8.tar.gz","digest":{"sha256":"155aee9ee16fa36171e37bf7d7394a1d9506a1382580be6add3764990187f26c"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"3ae2eecb399564409daae6776605306239605db0"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":97,"open_issues_count":97,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-11T07:33:48Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":45895,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2729,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-11T07:33:52Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2729,"watchers_count":2729,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9887702416","github_run_number":"17","github_sha1":"3ae2eecb399564409daae6776605306239605db0"}},"metadata":{"buildInvocationID":"9887702416-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"3ae2eecb399564409daae6776605306239605db0"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCIOB70Kq4BcXVBtBBC0/yJ1auF0nIzXZ5jb0+27mwL/AIgdyHnkxPJslmKOlGAA66SOhoOR/nGzDSSUyNdgKCT/q4=","cert":"-----BEGIN CERTIFICATE-----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\nKrqPdJN6GlktL2uUf6FNpua//hRDQrml\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..d4e436166a849abf248b3ca4b4824ece3f00457c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a0-py3-none-any.whl","digest":{"sha256":"434e9f5a12f4f4afebeab1b3ad766420af97dccecf26bd86e7d51c449665061a"}},{"name":"./aws_lambda_powertools-2.41.1a0.tar.gz","digest":{"sha256":"1b33961e5439f2ce38ea7067be3eef9d887b674966269625386c93587661bbcc"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"125186d8a940ee836d8238e26cba13a163463b4f"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":97,"open_issues_count":97,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-12T07:09:14Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":47145,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2727,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-12T07:09:17Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2727,"watchers_count":2727,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9904508447","github_run_number":"18","github_sha1":"125186d8a940ee836d8238e26cba13a163463b4f"}},"metadata":{"buildInvocationID":"9904508447-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"125186d8a940ee836d8238e26cba13a163463b4f"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQDFqVGDhF90hADdjNahViXXqcSDRWXm+m5oSK2oB+LdEwIgPj7T9+uBvpxFiFdzvkQUSkkfCLkpLGUs5++uVxOZlFY=","cert":"-----BEGIN CERTIFICATE-----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\nQX8gP3YfRMSzC9eNvD2/R2huXEf9IMqBmRov\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..a943222f129cb9b55f924d17af30202dc2be1b55 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a1-py3-none-any.whl","digest":{"sha256":"ac8cb59ad4c1689d322f8206ffcb212ceae705fa2f88ed004655ae1afee5f877"}},{"name":"./aws_lambda_powertools-2.41.1a1.tar.gz","digest":{"sha256":"937b70b632f23ef63a0eb4d60f565758239cf4d0fae74530b83f5cb9a9bee7be"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"43d1376f3a99a62e9471d134462e9b73f964e27d"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":100,"open_issues_count":100,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-14T10:04:07Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":47499,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2728,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-13T02:07:18Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2728,"watchers_count":2728,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9935777649","github_run_number":"19","github_sha1":"43d1376f3a99a62e9471d134462e9b73f964e27d"}},"metadata":{"buildInvocationID":"9935777649-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"43d1376f3a99a62e9471d134462e9b73f964e27d"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCLODxam0Wezso8YplbO3+61xRxrKS3CHaIIFdrTH41sQIgM47+dX4nyouYrGUDQRuVBWR7LZ94hKZN+Y2HrJVeTKg=","cert":"-----BEGIN CERTIFICATE-----\nMIIHZTCCBuqgAwIBAgIUDUH5ey2xI7OWaz6A/C+zusVj1ggwCgYIKoZIzj0EAwMw\nNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRl\ncm1lZGlhdGUwHhcNMjQwNzE1MDgwNzQ3WhcNMjQwNzE1MDgxNzQ3WjAAMFkwEwYH\nKoZIzj0CAQYIKoZIzj0DAQcDQgAE42xmecC8PeHBbWcs62w6GvfKN6l4DOb2OK6l\ndRJkumaLhoRBCeUr2Vepg0Ctb6F4IlUseEbs73Ok5jjFsPP2d6OCBgkwggYFMA4G\nA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAdBgNVHQ4EFgQUtGqb\nUSYMw5H3UeHGQ9Ok7OpzPLowHwYDVR0jBBgwFoAU39Ppz1YkEZb5qNjpKFWixi4Y\nZD8wgYQGA1UdEQEB/wR6MHiGdmh0dHBzOi8vZ2l0aHViLmNvbS9zbHNhLWZyYW1l\nd29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3IvLmdpdGh1Yi93b3JrZmxvd3MvZ2Vu\nZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJlZnMvdGFncy92Mi4wLjAwOQYKKwYB\nBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50\nLmNvbTAWBgorBgEEAYO/MAECBAhzY2hlZHVsZTA2BgorBgEEAYO/MAEDBCg0M2Qx\nMzc2ZjNhOTlhNjJlOTQ3MWQxMzQ0NjJlOWI3M2Y5NjRlMjdkMBkGCisGAQQBg78w\nAQQEC1ByZS1SZWxlYXNlMDUGCisGAQQBg78wAQUEJ2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbjAgBgorBgEEAYO/MAEGBBJyZWZzL2hlYWRz\nL2RldmVsb3AwOwYKKwYBBAGDvzABCAQtDCtodHRwczovL3Rva2VuLmFjdGlvbnMu\nZ2l0aHVidXNlcmNvbnRlbnQuY29tMIGGBgorBgEEAYO/MAEJBHgMdmh0dHBzOi8v\nZ2l0aHViLmNvbS9zbHNhLWZyYW1ld29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3Iv\nLmdpdGh1Yi93b3JrZmxvd3MvZ2VuZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJl\nZnMvdGFncy92Mi4wLjAwOAYKKwYBBAGDvzABCgQqDCg1YTc3NWIzNjdhNTZkNWJk\nMTE4YTIyNGE4MTFiYmEyODgxNTBhNTYzMB0GCisGAQQBg78wAQsEDwwNZ2l0aHVi\nLWhvc3RlZDBKBgorBgEEAYO/MAEMBDwMOmh0dHBzOi8vZ2l0aHViLmNvbS9hd3Mt\ncG93ZXJ0b29scy9wb3dlcnRvb2xzLWxhbWJkYS1weXRob24wOAYKKwYBBAGDvzAB\nDQQqDCg0M2QxMzc2ZjNhOTlhNjJlOTQ3MWQxMzQ0NjJlOWI3M2Y5NjRlMjdkMCIG\nCisGAQQBg78wAQ4EFAwScmVmcy9oZWFkcy9kZXZlbG9wMBkGCisGAQQBg78wAQ8E\nCwwJMjIxOTE5Mzc5MDEGCisGAQQBg78wARAEIwwhaHR0cHM6Ly9naXRodWIuY29t\nL2F3cy1wb3dlcnRvb2xzMBkGCisGAQQBg78wAREECwwJMTI5MTI3NjM4MH8GCisG\nAQQBg78wARIEcQxvaHR0cHM6Ly9naXRodWIuY29tL2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbi8uZ2l0aHViL3dvcmtmbG93cy9wcmUtcmVs\nZWFzZS55bWxAcmVmcy9oZWFkcy9kZXZlbG9wMDgGCisGAQQBg78wARMEKgwoNDNk\nMTM3NmYzYTk5YTYyZTk0NzFkMTM0NDYyZTliNzNmOTY0ZTI3ZDAYBgorBgEEAYO/\nMAEUBAoMCHNjaGVkdWxlMG0GCisGAQQBg78wARUEXwxdaHR0cHM6Ly9naXRodWIu\nY29tL2F3cy1wb3dlcnRvb2xzL3Bvd2VydG9vbHMtbGFtYmRhLXB5dGhvbi9hY3Rp\nb25zL3J1bnMvOTkzNTc3NzY0OS9hdHRlbXB0cy8xMBYGCisGAQQBg78wARYECAwG\ncHVibGljMIGJBgorBgEEAdZ5AgQCBHsEeQB3AHUA3T0wasbHETJjGR4cmWc3AqJK\nXrjePK3/h4pygC8p7o4AAAGQtW77kwAABAMARjBEAiASKE9P5H/xw2HBqzRG3GEk\nwMD/9id2R1+QetSJVBQcCwIgV2F0enzjQAW0xOtrV/vLUytPKnZjLTFft6HyxUTa\nUwMwCgYIKoZIzj0EAwMDaQAwZgIxAJcETokJIlBhFdiyaP1qMIt40Z16zjUHD4Ov\nXi22zBHRVyMRqR8V3kJODYdYEmgU4AIxAP2q8B7gl7dWbYGl6KZ5P/2nPyop1b0Q\nnIZQTrPVamJlzB3wpvwP78qLF8rpDwsHPQ==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..a79fd50204c8dbaf37f529e91cb5f4f45223d34a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a2-py3-none-any.whl","digest":{"sha256":"21c1f62e8ee7afc85393d573ae85cd924678561bb2f1ea239ccfe5320f5578a6"}},{"name":"./aws_lambda_powertools-2.41.1a2.tar.gz","digest":{"sha256":"b1dbde5206ee1168fc1f07b592a900030e01c0cf86a52cd2277f213da896445e"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b8b4632f7dcff1b45abd76b61120213dc27d1cea"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{"event_inputs":{"skip_code_quality":"false","skip_pypi":"false"}},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"workflow_dispatch","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"inputs":{"skip_code_quality":"false","skip_pypi":"false"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"ref":"refs/heads/develop","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":96,"open_issues_count":96,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-15T10:14:47Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":47504,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2729,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-15T10:23:46Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2729,"watchers_count":2729,"web_commit_signoff_required":true},"sender":{"avatar_url":"https://avatars.githubusercontent.com/u/4295173?v=4","events_url":"https://api.github.com/users/leandrodamascena/events{/privacy}","followers_url":"https://api.github.com/users/leandrodamascena/followers","following_url":"https://api.github.com/users/leandrodamascena/following{/other_user}","gists_url":"https://api.github.com/users/leandrodamascena/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/leandrodamascena","id":4295173,"login":"leandrodamascena","node_id":"MDQ6VXNlcjQyOTUxNzM=","organizations_url":"https://api.github.com/users/leandrodamascena/orgs","received_events_url":"https://api.github.com/users/leandrodamascena/received_events","repos_url":"https://api.github.com/users/leandrodamascena/repos","site_admin":false,"starred_url":"https://api.github.com/users/leandrodamascena/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/leandrodamascena/subscriptions","type":"User","url":"https://api.github.com/users/leandrodamascena"},"workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9937909135","github_run_number":"20","github_sha1":"b8b4632f7dcff1b45abd76b61120213dc27d1cea"}},"metadata":{"buildInvocationID":"9937909135-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b8b4632f7dcff1b45abd76b61120213dc27d1cea"}}]}}","signatures":[{"keyid":"","sig":"MEQCIBFVwZdrOE9QFT5dMWMiDgT9ZjgkMjeDFdWT4S2nPhMdAiAweZ+59wXIJeHUoVFmgRrgnGFhOsOtTHsyazRBVfymHg==","cert":"-----BEGIN CERTIFICATE-----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\neyLy0T2TK8t7kJSg/EO74ExPx6cSZXnwBfei753/qAaPiYE7Vs7API4=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a3/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a3/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..33c2bbe12b9676b1e06ec722ce9547912bdfca49 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a3/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a3-py3-none-any.whl","digest":{"sha256":"cee680518bdd30bab22767c91eac36cf6e9455feadfd323c4f524be4c1a85d13"}},{"name":"./aws_lambda_powertools-2.41.1a3.tar.gz","digest":{"sha256":"e1098e732ada97ce2f726e7d4765e079f33b566c23c67eb31df634076914ebd4"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"fe6ad7ec5749c2b1275b286246d06f93443ba4aa"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":102,"open_issues_count":102,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-15T21:04:37Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":48338,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2729,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-15T10:50:36Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2729,"watchers_count":2729,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9953006490","github_run_number":"21","github_sha1":"fe6ad7ec5749c2b1275b286246d06f93443ba4aa"}},"metadata":{"buildInvocationID":"9953006490-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"fe6ad7ec5749c2b1275b286246d06f93443ba4aa"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQDzHN06yW8bfdmPwhVEGxXOGcOmhfwvRayySk9ZZ19vhwIgZt10HSqjMp0Fyre2jnUyLZsYouxG98ryzA9E4vL0ZK8=","cert":"-----BEGIN CERTIFICATE-----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\nILdivivfIn4ulF6iAnT8w652Zlv95W/FqX9M\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a4/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a4/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..6dda521e86c12d346e720ad7b91074fea69c2571 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a4/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a4-py3-none-any.whl","digest":{"sha256":"f79144162ce3316ab18635913973e8ef81884443d8c2cdbc6aeb618a0b5998f0"}},{"name":"./aws_lambda_powertools-2.41.1a4.tar.gz","digest":{"sha256":"a5f0f92e69a383543dc5b16fc186ed2f4090e630da8b3b4caf310b3bad19febb"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5f41e440d660e4755dadbea7fa59657da3ab9f61"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":98,"open_issues_count":98,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-16T20:19:05Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":48635,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2731,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-16T13:03:28Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2731,"watchers_count":2731,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9970425488","github_run_number":"22","github_sha1":"5f41e440d660e4755dadbea7fa59657da3ab9f61"}},"metadata":{"buildInvocationID":"9970425488-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5f41e440d660e4755dadbea7fa59657da3ab9f61"}}]}}","signatures":[{"keyid":"","sig":"MEQCIAFIDcdh4GhzMbLV6cgDRv1wXaUdEMcI5ETfjlEk9SYnAiBQnB11RGaXyBqIcvDBG+cGb+Wmtwx5DgVU84ra0NvJ9w==","cert":"-----BEGIN CERTIFICATE-----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\nqzw4ZYc5vcV2H5pXbZxZNjw2GQ/5rmeM\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a5/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a5/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..d0e101a27533b27e46a07124eedc3de72dab28b9 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a5/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a5-py3-none-any.whl","digest":{"sha256":"96a00fda0a363fd4dcafd0fe1f97a55b7dc780bd5ab2b6df5824d0a6af6c913b"}},{"name":"./aws_lambda_powertools-2.41.1a5.tar.gz","digest":{"sha256":"1eb061c1821e29348769c8a15c7fd4b7722199d849f7a4b0f8c88f68582b4d21"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b1c05329183ceb393e4bfc605a3b33f7ca902fd6"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-17T20:11:48Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":48736,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2732,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-17T19:10:46Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2732,"watchers_count":2732,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"9987764987","github_run_number":"23","github_sha1":"b1c05329183ceb393e4bfc605a3b33f7ca902fd6"}},"metadata":{"buildInvocationID":"9987764987-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b1c05329183ceb393e4bfc605a3b33f7ca902fd6"}}]}}","signatures":[{"keyid":"","sig":"MEUCIDosHjjV87HKRWLTo51oyLCf4I2buLvbujMm7k6dkcIsAiEAvT6ofcaC0BGBH0S0fTW16wQODz50ZD/PVSf2wWcPRPM=","cert":"-----BEGIN CERTIFICATE-----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\nRSJ6hPSe3csXLVkeK0Vf6PkDFVXwTC8bkw==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a6/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a6/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..1137c4f869ca252785eac7c45eb29d55928002ab --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a6/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a6-py3-none-any.whl","digest":{"sha256":"7b9d75126e1a335578a191e19dbce84a3ae9165af8043a00e4ec5bfc53760dcb"}},{"name":"./aws_lambda_powertools-2.41.1a6.tar.gz","digest":{"sha256":"b93ae20c3e3bc6fcb6368288213719dfd19ded7cd7706bbed32072212abd6f9d"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"e53b5214dde2487616a20394ceae0cde9f389a2e"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":100,"open_issues_count":100,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-18T23:46:57Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":48838,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2732,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-18T23:44:18Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2732,"watchers_count":2732,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10004672320","github_run_number":"24","github_sha1":"e53b5214dde2487616a20394ceae0cde9f389a2e"}},"metadata":{"buildInvocationID":"10004672320-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"e53b5214dde2487616a20394ceae0cde9f389a2e"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQD7L87da4qT7zGnAIe+HZZudVD7VPcOKwPggsgTi7C1CAIhALchyUV51O46Bu5mZG8spiqgzDQvOtz0awXs4V+7B5KH","cert":"-----BEGIN CERTIFICATE-----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\nIvjAdLrRVzcbLnXUYA1N18eq9tWUJfd5ATI=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a7/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a7/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..44f83fad0b1fa51e662f0ff854e64b67f239030b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a7/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a7-py3-none-any.whl","digest":{"sha256":"285f36ad9a444c279e9584af1f52163b639aeb60a2038eecd4d9c40356ce1013"}},{"name":"./aws_lambda_powertools-2.41.1a7.tar.gz","digest":{"sha256":"832264d66fdfdfaf072baa46db1a99911896f6adf1dcc2ec7de9c9984b7ace67"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"a8ae46ec7b851c218209e423c822ff9b5c80b38e"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":96,"open_issues_count":96,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-22T05:52:17Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":48714,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2734,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-22T00:22:54Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2734,"watchers_count":2734,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10036962942","github_run_number":"25","github_sha1":"a8ae46ec7b851c218209e423c822ff9b5c80b38e"}},"metadata":{"buildInvocationID":"10036962942-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"a8ae46ec7b851c218209e423c822ff9b5c80b38e"}}]}}","signatures":[{"keyid":"","sig":"MEQCIQC1xEJ9jp+bEUK6mP4Lr25rPOqeHOdOfVfa4lBc/8ck/QIfbOyIE/lisE9LPUdhGeYftvZ5MmNdH2QvRXvXkTbUdg==","cert":"-----BEGIN CERTIFICATE-----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\nNaFHlvjVfdbHA5l1j4jQ49WBfxYEnaNj5JU=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a8/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a8/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..a52d67d4d20d87532ffbfa2c916cbfbd0b9516dc --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a8/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a8-py3-none-any.whl","digest":{"sha256":"f04f44cb69055d96aefc53523b70613c24398634bff5ba83662665ce4f50234a"}},{"name":"./aws_lambda_powertools-2.41.1a8.tar.gz","digest":{"sha256":"2e13d34b136b2ce941c5d87192682886ff9551da2244dfa8da02bb5386083549"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"c77869a89c1ebb87718b78b2027a2f0978512142"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":378,"forks_count":378,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":96,"open_issues_count":96,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-23T07:45:43Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":49254,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2735,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-22T20:59:52Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2735,"watchers_count":2735,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10055062605","github_run_number":"26","github_sha1":"c77869a89c1ebb87718b78b2027a2f0978512142"}},"metadata":{"buildInvocationID":"10055062605-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"c77869a89c1ebb87718b78b2027a2f0978512142"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQD5Me632vX0g1kYiy4F1Xu4mghZxwYVbnR3e8mOvRfAQQIhANp4UgjdqWYFW4nXMsSn0aM3z4hw6pyTGmwUYzSVHSeu","cert":"-----BEGIN CERTIFICATE-----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\nKdUByNr/AauFsxVvEQQ03fjCtDQZldLJwHI=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a9/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a9/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..c2290f60aef3e360457c5c7e8fdced8ca6fdb0b1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.41.1a9/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.41.1a9-py3-none-any.whl","digest":{"sha256":"95f9265599de62d1e2c1526fff7fda769699299b8d933f136ddd01bd7b0ef58e"}},{"name":"./aws_lambda_powertools-2.41.1a9.tar.gz","digest":{"sha256":"d311a51fdd36251e3992d21a7765985bb2b22fa9bde757e5e1ab3f885b610590"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"9b76fede34352887f534efcc68bd1d65ae154c06"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":380,"forks_count":380,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":101,"open_issues_count":101,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-23T21:06:16Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":49443,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2736,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-24T00:42:33Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2736,"watchers_count":2736,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10072811348","github_run_number":"27","github_sha1":"9b76fede34352887f534efcc68bd1d65ae154c06"}},"metadata":{"buildInvocationID":"10072811348-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"9b76fede34352887f534efcc68bd1d65ae154c06"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQC3pUm6z/ADjXpcnBIS07QDDo5NhKbIxAKOm3QwsQHE1QIgJx8H3r/JBTM9wUP9jeHSFw5ADZyBQggeQbuaiSkcpsU=","cert":"-----BEGIN CERTIFICATE-----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\nEvxAsq7REKj7Jzgw1MphfHbEP0oPiGKX9cw=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..ca5af0876f3e1faacbce8f2b3b416c587ff9389d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a0-py3-none-any.whl","digest":{"sha256":"50d20e71aa3fd6ce3215d280589e721aff8e4a62bf6b47738a32680ff61e0f4e"}},{"name":"./aws_lambda_powertools-2.42.1a0.tar.gz","digest":{"sha256":"1bb489560b205030539c780c89c4a27f9a8239ad59ef5509945d8529c9e4a4b5"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d45dd4857086422e78b789039568cebf2d535f77"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":380,"forks_count":380,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":101,"open_issues_count":101,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-26T00:11:21Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":50602,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2741,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-26T01:15:25Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2741,"watchers_count":2741,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10107854512","github_run_number":"29","github_sha1":"d45dd4857086422e78b789039568cebf2d535f77"}},"metadata":{"buildInvocationID":"10107854512-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d45dd4857086422e78b789039568cebf2d535f77"}}]}}","signatures":[{"keyid":"","sig":"MEUCICzfw0Cvmm0sJUdOqYGfFMe7J+whHqSkFe0v0F8iEiAQAiEA0prrFGx/EieME6nZHcLZ5cOWgthOCd2n2qOMNxl/T6o=","cert":"-----BEGIN CERTIFICATE-----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\nS6Gm5UxvfKESyZkdhbW23ji8SVF30aWGHdw=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..98371cd35bdf35dece789894cb4c7aa6aff6c20c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a1-py3-none-any.whl","digest":{"sha256":"104af4fd41c252b0ff02b46099ccae5ae031e853af050e35e791bf4b9a8921fe"}},{"name":"./aws_lambda_powertools-2.42.1a1.tar.gz","digest":{"sha256":"6aedc88c73ec8447f49e460ca5c35fd9ea27f0f06f5933624b0fb46e9ca41761"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"ed0b5925793d5b7f04aec54a31d4b1ec1a425d3a"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":381,"forks_count":381,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-28T22:19:24Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":50173,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2745,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-28T22:19:15Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2745,"watchers_count":2745,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10140406154","github_run_number":"30","github_sha1":"ed0b5925793d5b7f04aec54a31d4b1ec1a425d3a"}},"metadata":{"buildInvocationID":"10140406154-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"ed0b5925793d5b7f04aec54a31d4b1ec1a425d3a"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQD05foHI1Z4ypeB6InFvRDmUCyuOIf9zq50KRihQy6zVQIhAN7Buv2ZRHSMaPa/UN6Cel+ODs5aU7BjPnxouLGqtdfr","cert":"-----BEGIN CERTIFICATE-----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\n3vfwQIVT8B198PLV/4kqpawleaE+JxqpKSlKsQ==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..0b95d108af42566468652df0481b67b9a8d3f1b9 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a2-py3-none-any.whl","digest":{"sha256":"5d2986757d55b3b3fba4eff3e37f5d3a5ad05bb8f9c0c996766056c05cdeb06d"}},{"name":"./aws_lambda_powertools-2.42.1a2.tar.gz","digest":{"sha256":"07cac2887c1673675a2f1b9432da4393ee218a7d2236b9b5368a3b99d94af00f"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"2b532c764494ede1c115c829d484b876418002cb"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":381,"forks_count":381,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":101,"open_issues_count":101,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-29T21:18:28Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":50742,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2745,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-30T06:28:18Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2745,"watchers_count":2745,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10158471519","github_run_number":"31","github_sha1":"2b532c764494ede1c115c829d484b876418002cb"}},"metadata":{"buildInvocationID":"10158471519-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"2b532c764494ede1c115c829d484b876418002cb"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCmefHT0XLplvkeQBx/DjOI9yRl4U6Mg7en8pMPctpArQIgZ8qrcMsb5H7VwD9Ik9o6GFX9WmhiTvAaq6DMcy6Cxrg=","cert":"-----BEGIN CERTIFICATE-----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\n5vMRN/QbG5yB83m6CQXuGgYZwib7dh+/Jw==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a3/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a3/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..26b6661e0ee45dce03e1684853e7469bf4f1a05c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a3/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a3-py3-none-any.whl","digest":{"sha256":"d6ca1d8b6a1004c257fabf7a7e10099af264b237111a71d1818234dcc91daa3b"}},{"name":"./aws_lambda_powertools-2.42.1a3.tar.gz","digest":{"sha256":"e1983b9395cde145c405c9cf88c7cd0904a181cd4847c909f21e0228469a513f"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"22af2ad4647d11559358576452e06638ba590d78"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":381,"forks_count":381,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-30T20:21:43Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51276,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2748,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-07-31T06:45:46Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2748,"watchers_count":2748,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10176377109","github_run_number":"32","github_sha1":"22af2ad4647d11559358576452e06638ba590d78"}},"metadata":{"buildInvocationID":"10176377109-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"22af2ad4647d11559358576452e06638ba590d78"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCeO/3sNUc44w6/IZVJ8griSKLG/UuteWjs0TQnsaEQswIhAPwyoE88jB4ispM+INYkEogUhabSGxF/Kgg2eFI1ve8L","cert":"-----BEGIN CERTIFICATE-----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\n4M1ZtNLffyuWWKIvANbEoJASqKUBJRMx\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a4/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a4/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..4e7b4667fbd807ccc967bf138fa9e777c970f8ca --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a4/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a4-py3-none-any.whl","digest":{"sha256":"4ea70a5e9415a956b2da7f8457d34a81a333509a11ac6b198a4f1a4d90271e5e"}},{"name":"./aws_lambda_powertools-2.42.1a4.tar.gz","digest":{"sha256":"d7228c1086c98883deb2afa8591edda0e6d5a8333b8f9da1c24217ef20d739c7"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"62ec234ed29555772c5ac365a600dd5d7c062a8d"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":382,"forks_count":382,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":101,"open_issues_count":101,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-07-31T21:02:12Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51221,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2753,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-01T00:22:53Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2753,"watchers_count":2753,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10194405359","github_run_number":"33","github_sha1":"62ec234ed29555772c5ac365a600dd5d7c062a8d"}},"metadata":{"buildInvocationID":"10194405359-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"62ec234ed29555772c5ac365a600dd5d7c062a8d"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCcZO+Y39w1Rekb9P91NlEkYBsVEax2bThwN8fO12MhKAIhAOTwLMr/YR+OZEuiN34MDuqccFqP2/14RmSqWo5m3GOl","cert":"-----BEGIN CERTIFICATE-----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\nmx88JGQ6NFwXxH1N3fc5CZ6i0eU0cWfEEsp/\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a5/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a5/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..08aaf8a3cf984f8927a15b55a47d3ec8c64f4396 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a5/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a5-py3-none-any.whl","digest":{"sha256":"360fc80140688256f3ece9e271175f2870aedf97dfc47b0530b6ec574fac8c93"}},{"name":"./aws_lambda_powertools-2.42.1a5.tar.gz","digest":{"sha256":"53793b562c523a5271743dbcf282c14301520ff87e12796edc8133079fbd920c"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"134b1088ce720586d067d0b53052cfd385348e35"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":382,"forks_count":382,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":95,"open_issues_count":95,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-02T07:42:48Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51420,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2754,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-02T07:41:57Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2754,"watchers_count":2754,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10212128723","github_run_number":"34","github_sha1":"134b1088ce720586d067d0b53052cfd385348e35"}},"metadata":{"buildInvocationID":"10212128723-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"134b1088ce720586d067d0b53052cfd385348e35"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQD82RRfu1ncddW9icUXVZOgJ/Yu+bxFDHmCIQV2DTbg9QIgTRpEMu7IYeDKYl9fMIVC+5lEEb3ZmcUnY13n+QdcLpU=","cert":"-----BEGIN CERTIFICATE-----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\nGMItMJWwH7dLLRB98PryTIbLYIvtCUTVsg==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a6/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a6/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..210f60a035665f82708959bb2884a4febbd8658c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a6/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a6-py3-none-any.whl","digest":{"sha256":"4d14d1034d34658a40b3f0a34b6f583e8ce1ed58a25f2d941264122f01359a12"}},{"name":"./aws_lambda_powertools-2.42.1a6.tar.gz","digest":{"sha256":"68d16a2cd22f7234cf8659fec2441fe7d949440269e0f3786f17048201fde294"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"048156f96b54245bbec6fc35e71dd65687154b9c"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":383,"forks_count":383,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":98,"open_issues_count":98,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-04T21:00:53Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51791,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2756,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-03T22:04:47Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2756,"watchers_count":2756,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10244944559","github_run_number":"35","github_sha1":"048156f96b54245bbec6fc35e71dd65687154b9c"}},"metadata":{"buildInvocationID":"10244944559-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"048156f96b54245bbec6fc35e71dd65687154b9c"}}]}}","signatures":[{"keyid":"","sig":"MEQCIGSxqNOXWA+T+RSws4lcxe39MYpaGkD+8V4uEzxx2gwiAiBViqT1sH9iQND7AhJJEzwlEEjcgeWkiOmk3LW6sUClWg==","cert":"-----BEGIN CERTIFICATE-----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\npOO03QxVoy/LgLRt8fOmwV41i7mEXBnwtmg=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a7/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a7/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..7d2e41ed24ed2de8006bcdfee379e6a15de10e01 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a7/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a7-py3-none-any.whl","digest":{"sha256":"ec35cdaf1e1897953503f5dc5179b27f8baad50a79e077d648220c143093f80d"}},{"name":"./aws_lambda_powertools-2.42.1a7.tar.gz","digest":{"sha256":"5bd309ae90dedd445c17c35ff9dad09020bfea227b314497146d3a29db81f3a6"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b5c13efc5b60c9a6cc45eefe3b2dc783573f4868"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":383,"forks_count":383,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":94,"open_issues_count":94,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-06T00:20:04Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51176,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2759,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-05T22:26:51Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2759,"watchers_count":2759,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10262629186","github_run_number":"36","github_sha1":"b5c13efc5b60c9a6cc45eefe3b2dc783573f4868"}},"metadata":{"buildInvocationID":"10262629186-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b5c13efc5b60c9a6cc45eefe3b2dc783573f4868"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQD9XnvAtl5T7kbQVPmLFxPwpqAEjnDjn/X5WZt8tsEwPwIhAJJAbrQaO4niWY7quWsXdcasVlgO6ZYOdXva6Bez2JoE","cert":"-----BEGIN CERTIFICATE-----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\n8Uq6ojPCZp0aafYGvG2VIb3hFcmYLZYQ2fo=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a8/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a8/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..614f9770b286fa4890a0aa760f6484bf5beb26aa --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a8/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a8-py3-none-any.whl","digest":{"sha256":"140a813f8007223e4a12d8932b4926419d0ffcfdb1d786d9d932e4b862d36bca"}},{"name":"./aws_lambda_powertools-2.42.1a8.tar.gz","digest":{"sha256":"7d0822fe4c7449a8a75d0c2a7bbbaa78217394f2bab816b0454f0f315d0864fb"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5f80e461f03b42dd0a1da29ad29c6adb67f9e935"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":383,"forks_count":383,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":86,"open_issues_count":86,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-06T23:21:34Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51751,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2761,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-06T21:59:02Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2761,"watchers_count":2761,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10280442920","github_run_number":"37","github_sha1":"5f80e461f03b42dd0a1da29ad29c6adb67f9e935"}},"metadata":{"buildInvocationID":"10280442920-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5f80e461f03b42dd0a1da29ad29c6adb67f9e935"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQC766gwWExJaQCo8wQdiF85bbCxBZGk1Kxw2WKvJbxRXgIhAJfsqnJo6rbAYh8L0c8uTLdqqbQchCQYsIj3Kinp9bwb","cert":"-----BEGIN CERTIFICATE-----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\nRoNVUg1ne5rwmRZ89AZyHVI088n7utW3xg==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a9/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a9/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..38eca90f8c34cb3fb7808854c355210e8aeab761 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.42.1a9/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.42.1a9-py3-none-any.whl","digest":{"sha256":"a8b9ef1bd5922169413f8a105ac9dd34ecd5f91e7f231577a56b682a26551880"}},{"name":"./aws_lambda_powertools-2.42.1a9.tar.gz","digest":{"sha256":"f26f1d85a2fb8491aaef24bd54ae0b33ea1383729f857561bd8363d63a6bdd52"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"1950fe02aa84633a753e61ce4941014b5e94aec4"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":383,"forks_count":383,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":84,"open_issues_count":84,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-07T21:50:43Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":52353,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2761,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-07T21:34:13Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2761,"watchers_count":2761,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10298252561","github_run_number":"38","github_sha1":"1950fe02aa84633a753e61ce4941014b5e94aec4"}},"metadata":{"buildInvocationID":"10298252561-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"1950fe02aa84633a753e61ce4941014b5e94aec4"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQD0fPjQiDq5yUM9uxc9z2MRXB34632lkqK7JoXAJiX0TwIhAOaVN0NxUJFWzpiOvO3Eb4jP3B35xB89h1zARqsX2JHb","cert":"-----BEGIN CERTIFICATE-----\nMIIHaDCCBu2gAwIBAgIUfoJaiOhuvZ2hZtH0Ul9KrKM4E54wCgYIKoZIzj0EAwMw\nNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRl\ncm1lZGlhdGUwHhcNMjQwODA4MDgwNzAzWhcNMjQwODA4MDgxNzAzWjAAMFkwEwYH\nKoZIzj0CAQYIKoZIzj0DAQcDQgAEpuDWG+fyjtbcHRsgv6f9qmihwMQ284FoboCy\nG/sao5WgELxxaO7gdZm0aTsM6Ax1qYC+xXLKESf7evuxAXdlRqOCBgwwggYIMA4G\nA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAdBgNVHQ4EFgQUoAbc\nQt0oQ/sZiurLTZ3hgonI8XAwHwYDVR0jBBgwFoAU39Ppz1YkEZb5qNjpKFWixi4Y\nZD8wgYQGA1UdEQEB/wR6MHiGdmh0dHBzOi8vZ2l0aHViLmNvbS9zbHNhLWZyYW1l\nd29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3IvLmdpdGh1Yi93b3JrZmxvd3MvZ2Vu\nZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJlZnMvdGFncy92Mi4wLjAwOQYKKwYB\nBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50\nLmNvbTAWBgorBgEEAYO/MAECBAhzY2hlZHVsZTA2BgorBgEEAYO/MAEDBCgxOTUw\nZmUwMmFhODQ2MzNhNzUzZTYxY2U0OTQxMDE0YjVlOTRhZWM0MBkGCisGAQQBg78w\nAQQEC1ByZS1SZWxlYXNlMDUGCisGAQQBg78wAQUEJ2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbjAgBgorBgEEAYO/MAEGBBJyZWZzL2hlYWRz\nL2RldmVsb3AwOwYKKwYBBAGDvzABCAQtDCtodHRwczovL3Rva2VuLmFjdGlvbnMu\nZ2l0aHVidXNlcmNvbnRlbnQuY29tMIGGBgorBgEEAYO/MAEJBHgMdmh0dHBzOi8v\nZ2l0aHViLmNvbS9zbHNhLWZyYW1ld29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3Iv\nLmdpdGh1Yi93b3JrZmxvd3MvZ2VuZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJl\nZnMvdGFncy92Mi4wLjAwOAYKKwYBBAGDvzABCgQqDCg1YTc3NWIzNjdhNTZkNWJk\nMTE4YTIyNGE4MTFiYmEyODgxNTBhNTYzMB0GCisGAQQBg78wAQsEDwwNZ2l0aHVi\nLWhvc3RlZDBKBgorBgEEAYO/MAEMBDwMOmh0dHBzOi8vZ2l0aHViLmNvbS9hd3Mt\ncG93ZXJ0b29scy9wb3dlcnRvb2xzLWxhbWJkYS1weXRob24wOAYKKwYBBAGDvzAB\nDQQqDCgxOTUwZmUwMmFhODQ2MzNhNzUzZTYxY2U0OTQxMDE0YjVlOTRhZWM0MCIG\nCisGAQQBg78wAQ4EFAwScmVmcy9oZWFkcy9kZXZlbG9wMBkGCisGAQQBg78wAQ8E\nCwwJMjIxOTE5Mzc5MDEGCisGAQQBg78wARAEIwwhaHR0cHM6Ly9naXRodWIuY29t\nL2F3cy1wb3dlcnRvb2xzMBkGCisGAQQBg78wAREECwwJMTI5MTI3NjM4MH8GCisG\nAQQBg78wARIEcQxvaHR0cHM6Ly9naXRodWIuY29tL2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbi8uZ2l0aHViL3dvcmtmbG93cy9wcmUtcmVs\nZWFzZS55bWxAcmVmcy9oZWFkcy9kZXZlbG9wMDgGCisGAQQBg78wARMEKgwoMTk1\nMGZlMDJhYTg0NjMzYTc1M2U2MWNlNDk0MTAxNGI1ZTk0YWVjNDAYBgorBgEEAYO/\nMAEUBAoMCHNjaGVkdWxlMG4GCisGAQQBg78wARUEYAxeaHR0cHM6Ly9naXRodWIu\nY29tL2F3cy1wb3dlcnRvb2xzL3Bvd2VydG9vbHMtbGFtYmRhLXB5dGhvbi9hY3Rp\nb25zL3J1bnMvMTAyOTgyNTI1NjEvYXR0ZW1wdHMvMTAWBgorBgEEAYO/MAEWBAgM\nBnB1YmxpYzCBiwYKKwYBBAHWeQIEAgR9BHsAeQB3AN09MGrGxxEyYxkeHJlnNwKi\nSl643jyt/4eKcoAvKe6OAAABkTEG7JUAAAQDAEgwRgIhAOszQUtYfgc+Zx6Jq2Au\nRHsWrNxwYvYvwKCVoEXGrxs5AiEA61RmMYj/tZ1dE39xGAnW6lU4PGwZ4H6ZG5BK\nTrhyivkwCgYIKoZIzj0EAwMDaQAwZgIxAMGy3LcQdVQaEXPfkZ1JZC4LPfR+Nz8u\naA/1LBPe9E7Sx8x+mzRGPZ9TUPLJdcad7wIxALY/q06Vl2K1eLTxviCXpRWu069G\nQ8+T4UXpJFrBzJRXPMZWpbH8sOVEwSZHNYzqSA==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..315b3d38ca706560af5341e5f143d3456b90a976 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.1a0-py3-none-any.whl","digest":{"sha256":"49422a8d5a1e22f1ba585d0d23ffd0143c36cd48f6e661e52c34dda0a1c6014d"}},{"name":"./aws_lambda_powertools-2.43.1a0.tar.gz","digest":{"sha256":"ae7281e58b20dad31608ae8c017025267adc1af3c5e98c554408075dc0c4241b"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d86cce1a62210a299f6fd3994e3ad0a2b6a3af7c"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":383,"forks_count":383,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":85,"open_issues_count":85,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-08T20:44:12Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":53186,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2763,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-08T16:39:24Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2763,"watchers_count":2763,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10315789946","github_run_number":"39","github_sha1":"d86cce1a62210a299f6fd3994e3ad0a2b6a3af7c"}},"metadata":{"buildInvocationID":"10315789946-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d86cce1a62210a299f6fd3994e3ad0a2b6a3af7c"}}]}}","signatures":[{"keyid":"","sig":"MEUCIEN7qJXYlUTP3udFEK1knncKVmNwkYld/naJta4TAnCgAiEA4sv+H2ADdNHlHkQz2FxkntflkiocA0+axjgLMu0d77k=","cert":"-----BEGIN CERTIFICATE-----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\niHFXYmgsIJMMmFOXoJ1WPLytYpCP3hYsdAwL\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..faaab16b7eb352f51bd38fa61ec3c17af4d419ba --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.1a1-py3-none-any.whl","digest":{"sha256":"c77a1a6cd18c8b211e8598149ab041160706ee257e6f33f5058ec1bc0f2dd0ee"}},{"name":"./aws_lambda_powertools-2.43.1a1.tar.gz","digest":{"sha256":"03ff6a7f6b909b19d1a4650f81fb7130fe4913640af884a9bee5e4b1342e2e32"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"f40ad68ab769f061f23ba2f5b321be9c16461f9a"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":383,"forks_count":383,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":79,"open_issues_count":79,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-11T21:22:20Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51942,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2766,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-11T22:26:58Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2766,"watchers_count":2766,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10348090924","github_run_number":"40","github_sha1":"f40ad68ab769f061f23ba2f5b321be9c16461f9a"}},"metadata":{"buildInvocationID":"10348090924-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"f40ad68ab769f061f23ba2f5b321be9c16461f9a"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCeTOKGLR8tm7otDO4wW3EnBoM71FS5KukRd4Hwiyr+5gIhAJk4R1Z6Yz8+Vg3svgM0AYXJADzx6reh4Q3K0CsWu/lX","cert":"-----BEGIN CERTIFICATE-----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\n/LNmbqfB8BVqPt0K0hs0plTpfICW9oKB1FE=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..b0ffc80cc46629ec84222d3e21599678c5364f86 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.1a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.1a2-py3-none-any.whl","digest":{"sha256":"2466b8c2ebbc5deebc2928506ef163be4380f949609dbd872a9c921cc58bf000"}},{"name":"./aws_lambda_powertools-2.43.1a2.tar.gz","digest":{"sha256":"12a19d46a2fe75f4642f783534e9a63a9fa65922f2facf125a09eb59ca9253fd"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"2b6f6051ecfc53ebf16ad37c7ae640a6408aaa0b"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{"event_inputs":{"skip_code_quality":"false","skip_pypi":"false"}},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"workflow_dispatch","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"inputs":{"skip_code_quality":"false","skip_pypi":"false"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"ref":"refs/heads/develop","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":385,"forks_count":385,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":82,"open_issues_count":82,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-12T19:01:43Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51950,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2766,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-12T19:01:47Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2766,"watchers_count":2766,"web_commit_signoff_required":true},"sender":{"avatar_url":"https://avatars.githubusercontent.com/u/4295173?v=4","events_url":"https://api.github.com/users/leandrodamascena/events{/privacy}","followers_url":"https://api.github.com/users/leandrodamascena/followers","following_url":"https://api.github.com/users/leandrodamascena/following{/other_user}","gists_url":"https://api.github.com/users/leandrodamascena/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/leandrodamascena","id":4295173,"login":"leandrodamascena","node_id":"MDQ6VXNlcjQyOTUxNzM=","organizations_url":"https://api.github.com/users/leandrodamascena/orgs","received_events_url":"https://api.github.com/users/leandrodamascena/received_events","repos_url":"https://api.github.com/users/leandrodamascena/repos","site_admin":false,"starred_url":"https://api.github.com/users/leandrodamascena/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/leandrodamascena/subscriptions","type":"User","url":"https://api.github.com/users/leandrodamascena"},"workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10358045832","github_run_number":"41","github_sha1":"2b6f6051ecfc53ebf16ad37c7ae640a6408aaa0b"}},"metadata":{"buildInvocationID":"10358045832-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"2b6f6051ecfc53ebf16ad37c7ae640a6408aaa0b"}}]}}","signatures":[{"keyid":"","sig":"MEQCIHxIUCSefsQp/cdaA4UeUdSxssdQIAUQY2i11FmZ6T1/AiAP1U8xY+xP+0tp1P8JQ0Noe+874yJatyibmGC8oiQMiw==","cert":"-----BEGIN CERTIFICATE-----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\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..3db0190a5ecab85b32892488b04f0e2ec01f18a4 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.2a0-py3-none-any.whl","digest":{"sha256":"fd387ecb8fa76d8d72e2902825a9279ff9a5a7fb3bad9b228fe175c3f5c611f0"}},{"name":"./aws_lambda_powertools-2.43.2a0.tar.gz","digest":{"sha256":"dce275e5af86f0acc5aa31037ae0477a6766e6b9051c1198d93905b6ea0bd8ac"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"0c86a00fe1c4789bea5a2af0567dc24844c3306b"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":385,"forks_count":385,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":91,"open_issues_count":91,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-13T01:53:15Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":52763,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2766,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-12T23:18:54Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2766,"watchers_count":2766,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10365902824","github_run_number":"42","github_sha1":"0c86a00fe1c4789bea5a2af0567dc24844c3306b"}},"metadata":{"buildInvocationID":"10365902824-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"0c86a00fe1c4789bea5a2af0567dc24844c3306b"}}]}}","signatures":[{"keyid":"","sig":"MEUCIHcvYxDPyREMyxa+7WTSjRr0pJEcZTE4AWLYnctTLJfoAiEA5Ob6kCJkTf5ndwk1pVKOq5lCRIxDGIwv1MXDHNHOr9E=","cert":"-----BEGIN CERTIFICATE-----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\n50jGwFwiIFXoU13iZJb7FNBhIboJ12RWRmpj\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..f80bf6c9ed1bc6d768ead5507ebf1a89fe7634a2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.2a1-py3-none-any.whl","digest":{"sha256":"d6d5f234b5925c58ccf9d8719334dcbb3c9c4524c229c6d759ddef1e76a3592c"}},{"name":"./aws_lambda_powertools-2.43.2a1.tar.gz","digest":{"sha256":"7c8b076d3c365a4751dd84384aeced8f7905055f2cd6c884642a5621c7fd28c1"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"251a9a38b21b9383a17bfb08a5a550f5c1cdb9c2"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":385,"forks_count":385,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":104,"open_issues_count":104,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-13T21:18:52Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51877,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2766,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-13T21:17:00Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2766,"watchers_count":2766,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10383731600","github_run_number":"43","github_sha1":"251a9a38b21b9383a17bfb08a5a550f5c1cdb9c2"}},"metadata":{"buildInvocationID":"10383731600-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"251a9a38b21b9383a17bfb08a5a550f5c1cdb9c2"}}]}}","signatures":[{"keyid":"","sig":"MEUCICP/HZfOUmUZoqURcvUao9K1X+Gj/yzjEM9yFQxjoDq4AiEArRnyBrF+ZzIzyh3iBGtBK8tdXy87lC48zUZxEi1Vl+Y=","cert":"-----BEGIN CERTIFICATE-----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\nFF/3PMQxlbwkn0Q5RvAvm3snosfrPsfJl0OC\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..11d944a81c08f42a73daab21c61842c0f909f60c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.2a2-py3-none-any.whl","digest":{"sha256":"4cd56651d9b8b84a459ad636ce0edeba3193e4f0d9d5293bbe0bbd1d5b06cb9c"}},{"name":"./aws_lambda_powertools-2.43.2a2.tar.gz","digest":{"sha256":"f11d62494a3a48fc8007d04c7b7624e40dba07783ba50646c09fab5773c5bc53"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"33d9c91dbeb8f71a0d69a3400ca12de204ac72c3"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":385,"forks_count":385,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":105,"open_issues_count":105,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-15T07:56:16Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":51720,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2769,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-15T06:14:58Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2769,"watchers_count":2769,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10400728696","github_run_number":"44","github_sha1":"33d9c91dbeb8f71a0d69a3400ca12de204ac72c3"}},"metadata":{"buildInvocationID":"10400728696-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"33d9c91dbeb8f71a0d69a3400ca12de204ac72c3"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQC6eW1ul44Gbblgvty804L51RPxE9HJMLCtGl/TXE2OigIhAOKxt7XBgft6B7ptbXSIn/dC5TpUjzAUcvNb0N3U6AXk","cert":"-----BEGIN CERTIFICATE-----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\nZUc/5nEPw6NNoF/G1ipkf9V8I5mlROiW2g==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a3/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a3/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..f15975d2ef9042d99fd424022af564a1ef487117 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a3/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.2a3-py3-none-any.whl","digest":{"sha256":"80b8b496e71080519f32284174094258e5845997c4ba60e78a22293f94dfab83"}},{"name":"./aws_lambda_powertools-2.43.2a3.tar.gz","digest":{"sha256":"0472bd588ffefd1b5f955d790ce5be0dddf4c10d8873d85c8cbbbba358feaccb"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"ebc0eb8b435bbc5c4441808c8436d360a3b66bfc"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":385,"forks_count":385,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":91,"open_issues_count":91,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-16T06:31:39Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":52130,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2772,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-16T06:29:34Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2772,"watchers_count":2772,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10416704784","github_run_number":"45","github_sha1":"ebc0eb8b435bbc5c4441808c8436d360a3b66bfc"}},"metadata":{"buildInvocationID":"10416704784-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"ebc0eb8b435bbc5c4441808c8436d360a3b66bfc"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQD+NcUIQZu2HjZNaNKWdyE96LdBhpF1dQehrX6vlhpsJwIhAITnzl3+wXFdO98QNcXpOegmoxLNeFhSSJWzWJO0kl7I","cert":"-----BEGIN CERTIFICATE-----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\naPTS8MkFjY3Zat1sxZOqqtC2qPiO1VsJfLRSfg==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a4/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a4/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..8418273516d0709c7804fe70959f66599651ff81 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a4/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.2a4-py3-none-any.whl","digest":{"sha256":"7d666cdb8251799bcc22b73cc6907984fe94c38efff3a75127cdc86ec01628b9"}},{"name":"./aws_lambda_powertools-2.43.2a4.tar.gz","digest":{"sha256":"8fd4f29118fa88eea23cf4e7644bead09bb8ee45d8778eb144d0131d1d435998"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"7085dc301e63b79550beb961f4b7c4b2c3500642"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":385,"forks_count":385,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":83,"open_issues_count":83,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-18T21:40:29Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":52329,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2774,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-19T04:51:34Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2774,"watchers_count":2774,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10449492007","github_run_number":"46","github_sha1":"7085dc301e63b79550beb961f4b7c4b2c3500642"}},"metadata":{"buildInvocationID":"10449492007-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"7085dc301e63b79550beb961f4b7c4b2c3500642"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCU4YOo0N5Zt8ktma8eTRtY3taMNGj74NluVYNMKcaWuQIgD1mcjBikMq2mc2IhAt6TZNlhDTdZtLP2pJ1Cra5echE=","cert":"-----BEGIN CERTIFICATE-----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\n4lqtjAboeUy+q1Q0NwhAnHZ8HnSrXZCgeCRl\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a5/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a5/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..46163472250b2f5e834ed3a5a641f53583e623bd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a5/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.2a5-py3-none-any.whl","digest":{"sha256":"a8a02b69fc7008920723c0e21fb8415d96a78d5541c97015e0121ca9dfc0577a"}},{"name":"./aws_lambda_powertools-2.43.2a5.tar.gz","digest":{"sha256":"53adfddc23f9ee444b6b06f7a69ca5a04a8d1f56b6ea952dd0f622c4d4c789e1"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"046479198dd33498e719c2693f60abae85cd4fb4"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":385,"forks_count":385,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":79,"open_issues_count":79,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-19T21:38:17Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":52769,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2774,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-19T21:38:19Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2774,"watchers_count":2774,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10467648891","github_run_number":"47","github_sha1":"046479198dd33498e719c2693f60abae85cd4fb4"}},"metadata":{"buildInvocationID":"10467648891-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"046479198dd33498e719c2693f60abae85cd4fb4"}}]}}","signatures":[{"keyid":"","sig":"MEQCIAbn1lobTagQ24tWgWI2LC4wUVYmnox/hFc8UVviZHHNAiAO7RXoanZYi6ag2+LJ8rqh65vqMAZghtOQt3b/Z+AlYg==","cert":"-----BEGIN CERTIFICATE-----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\n+o1RXHYW2lrwkZGUbx+b8X0S/Jl6uNJqxPs=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a6/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a6/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..84a41e03dd3c0ad6b509ed88a82af670182e94f6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/2.43.2a6/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-2.43.2a6-py3-none-any.whl","digest":{"sha256":"25b418bc0d0f60699cef4224442e4db0f8e044f89c78bfd72aa67ebbdd727de4"}},{"name":"./aws_lambda_powertools-2.43.2a6.tar.gz","digest":{"sha256":"718b819f19fb55c63a52cc09f5c85c0930ca5bfd72b77fd7c86d15a649ab342a"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"8251bb09b3c95401faafd45d09cfe9072aed8765"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":385,"forks_count":385,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":88,"open_issues_count":88,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-08-20T20:12:25Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":53370,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2775,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-08-20T13:31:42Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2775,"watchers_count":2775,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"10485912771","github_run_number":"48","github_sha1":"8251bb09b3c95401faafd45d09cfe9072aed8765"}},"metadata":{"buildInvocationID":"10485912771-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"8251bb09b3c95401faafd45d09cfe9072aed8765"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCRJJwR/0P+3as7jifzGlWmssANRtkjodp7VpvzRxNm0gIgdHqSoYxX7W38cMXDBoMKxfCj87KqVqoHi7iRG5zNouo=","cert":"-----BEGIN CERTIFICATE-----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\nzQWnQJycP5TjQMdIWI1B7ihJJ8fZF3izT18g\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..2b1ee7cafcc2380399ffbc9a7f773cbec8f5edad --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a0-py3-none-any.whl","digest":{"sha256":"796004ab8dc0aa213b804b2e744331c2cab3c682791ce0f1aeceed4cea1cba12"}},{"name":"./aws_lambda_powertools-3.0.1a0.tar.gz","digest":{"sha256":"1e8e8c4933adb03facd7ce605462a2625fabd2f120b24a17e25e28326bdda410"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b482152d6a7db0e103d5dc12acf9f0450f0d26f4"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":391,"forks_count":391,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":86,"open_issues_count":86,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-09-23T21:48:49Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":55037,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2818,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-09-24T01:34:11Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2818,"watchers_count":2818,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11009545324","github_run_number":"72","github_sha1":"b482152d6a7db0e103d5dc12acf9f0450f0d26f4"}},"metadata":{"buildInvocationID":"11009545324-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b482152d6a7db0e103d5dc12acf9f0450f0d26f4"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQDyGZblCaDBzZhrLorp6gISQbYQui5DcUG/5a1Y25UwWAIhAJLwPnO8dPL+eVSFN1D6SCLkI8x4piP0fOP/IdQH2WGi","cert":"-----BEGIN CERTIFICATE-----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\nQQdgQzdkQJPvaLwGYyHEG1vgpmR8qwVDOCc=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..1a2805d33dfd93b09f71c7024731d761864a0dc4 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a1-py3-none-any.whl","digest":{"sha256":"7dd7a3498b5a0e6a4af7c5f13c98bc882c803905dfc4ad205d4ab0a78e491b75"}},{"name":"./aws_lambda_powertools-3.0.1a1.tar.gz","digest":{"sha256":"4923a10e106b6894ba7aa32d3407d053f71f4be9e563e05a10de8e77c6278b7e"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b5e93442c18347e114220bbd6f202751f7cb83cb"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":391,"forks_count":391,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":92,"open_issues_count":92,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-09-25T21:45:52Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":57961,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2822,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-09-25T21:09:35Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2822,"watchers_count":2822,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11048072772","github_run_number":"74","github_sha1":"b5e93442c18347e114220bbd6f202751f7cb83cb"}},"metadata":{"buildInvocationID":"11048072772-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"b5e93442c18347e114220bbd6f202751f7cb83cb"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCv5EV0fUJrgBIqTGBKXsFv0oxJMYG2282b/CO9X82xWAIhAJB7kK163segAOX02rgSJ14y17Mzjc6OzgBlNNfwTkeO","cert":"-----BEGIN CERTIFICATE-----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\nSy6hyiGn1qp2KAWZySSnWVkxllNW5F7uUGg=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..ab024560a2689b67b58dc2f16bc983d1d1733640 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a2-py3-none-any.whl","digest":{"sha256":"33f7b866530b233a520e0003df16d32f79bbb78ea99147fb2aa76ed1cb178047"}},{"name":"./aws_lambda_powertools-3.0.1a2.tar.gz","digest":{"sha256":"246ec18dd4e9785f479d516cabe269216b70f582d1d61ae6a92d3cb1540f1a00"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"764b1da8dc616f583c536eea6f4b10af5ef6d229"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":391,"forks_count":391,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":93,"open_issues_count":93,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-09-27T07:56:51Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":56706,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2822,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-09-27T07:50:54Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2822,"watchers_count":2822,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11066847108","github_run_number":"75","github_sha1":"764b1da8dc616f583c536eea6f4b10af5ef6d229"}},"metadata":{"buildInvocationID":"11066847108-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"764b1da8dc616f583c536eea6f4b10af5ef6d229"}}]}}","signatures":[{"keyid":"","sig":"MEUCIGle/Endv7KConOaQLvnYh2wx2TXJvxp9WIIP05xx1kbAiEAnv5vk7Df8KNV9CYt8BeeWGMjo4p2W9DJcp+bNIBkvh8=","cert":"-----BEGIN CERTIFICATE-----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\nxF+d2LBMZwKzIfnTzmLTRYPbtOX2esPmy9j6\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a3/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a3/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..ea7a40fbcd027f350c4fc59eefbc00d38a52ba03 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a3/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a3-py3-none-any.whl","digest":{"sha256":"f7c2d4b420b4fa75a28fb7a8ad48e4e810f040ec6c95786d4a80c3eeccdcc454"}},{"name":"./aws_lambda_powertools-3.0.1a3.tar.gz","digest":{"sha256":"dd7c2526b0816f8ac0cf0d22fadf6e82004749893e21159879ab84fd3bf9b76e"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5665d4393348c1f4c9a5d71d58b4fc570f19a563"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2023-01-27T14:56:10Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":391,"forks_count":391,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":93,"open_issues_count":93,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-09-29T10:03:45Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":57740,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2827,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-09-29T01:51:54Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2827,"watchers_count":2827,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11101904792","github_run_number":"76","github_sha1":"5665d4393348c1f4c9a5d71d58b4fc570f19a563"}},"metadata":{"buildInvocationID":"11101904792-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5665d4393348c1f4c9a5d71d58b4fc570f19a563"}}]}}","signatures":[{"keyid":"","sig":"MEUCIB0rNXEZRclWV8cYP4lHmSuSRCjWlSjpLdXUjhweI9yUAiEA5oQJ0QJkUJJDuJycU1EogG1t97S0trflGg93eKs9q1U=","cert":"-----BEGIN CERTIFICATE-----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\ny3b8ukeUS98hCqYknac1ZuMHEEBWV1VScC8n\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a4/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a4/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..79733f4cd4e30bb6a0ca0ac2dd9154ba61765ca1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a4/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a4-py3-none-any.whl","digest":{"sha256":"6894d613b9cce9f5bc46c445c2f4bd7b59f9847e4a14687447537c19dbe92019"}},{"name":"./aws_lambda_powertools-3.0.1a4.tar.gz","digest":{"sha256":"a2366d200056728bf932d3982c3fea561be11db1618c1d59bca00f55c6670504"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"26ac473943aaf5c5931d60345b40911118f09c55"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":392,"forks_count":392,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":92,"open_issues_count":92,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-09-30T21:45:03Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":56621,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2826,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-09-30T21:05:40Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2826,"watchers_count":2826,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11121132445","github_run_number":"77","github_sha1":"26ac473943aaf5c5931d60345b40911118f09c55"}},"metadata":{"buildInvocationID":"11121132445-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"26ac473943aaf5c5931d60345b40911118f09c55"}}]}}","signatures":[{"keyid":"","sig":"MEQCIH94+ucJMaQs8qMfeG+Oucos8yHkvZhXxlj2o/QBmnJyAiAkpjtra+idrNjyC11NRfGa5RvPmsL6mZbyKax995dl5Q==","cert":"-----BEGIN CERTIFICATE-----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\n6iIS5pWJJgyk6r/tqqpjR/tcql+moXqbleoo\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a5/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a5/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..47e0754f7745a1bf2be74d942252e27d6af6cb5d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a5/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a5-py3-none-any.whl","digest":{"sha256":"fd77de31c1da0edf5515a1cb37256d1d7583871d6dc87f19437f87d18426740b"}},{"name":"./aws_lambda_powertools-3.0.1a5.tar.gz","digest":{"sha256":"446b44d55ba8e512aa56efaae4bdfc6b3f023a4ea765e24f6716df9326d8bc0c"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d9ec7ce1fcd782446cc29fdc8ceb20fba8278bed"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":391,"forks_count":391,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":92,"open_issues_count":92,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-02T07:39:33Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":57971,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2827,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-02T07:39:36Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2827,"watchers_count":2827,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11140037126","github_run_number":"78","github_sha1":"d9ec7ce1fcd782446cc29fdc8ceb20fba8278bed"}},"metadata":{"buildInvocationID":"11140037126-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d9ec7ce1fcd782446cc29fdc8ceb20fba8278bed"}}]}}","signatures":[{"keyid":"","sig":"MEUCICy8ya7uSucM+8rn8Nf1v8P30Shq8FZQ+HTTp2Wht6gKAiEAya+74IktbohH4GHWOUMMxfcvh/GADRVEhOHzJszcVWM=","cert":"-----BEGIN CERTIFICATE-----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\nXArBPT0NTSX2sdVgovQkEx4bGtSLcDdxBY4=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a6/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a6/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..94782f249f18db17649b68c1eae2a371accc487e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a6/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a6-py3-none-any.whl","digest":{"sha256":"b4609859a015015f25271c551edfad5e7e3574617e45085260ce645dda4eafe6"}},{"name":"./aws_lambda_powertools-3.0.1a6.tar.gz","digest":{"sha256":"9ef189aca52fabe6db036a8f85ca9074b9844a4fe4f3b491be2deccb92cd7326"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"a275be0868d02c79c82fe6d0e22b1e178d86a5dd"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":391,"forks_count":391,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":92,"open_issues_count":92,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-02T21:20:06Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":58090,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2827,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-02T21:20:09Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2827,"watchers_count":2827,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11158160899","github_run_number":"79","github_sha1":"a275be0868d02c79c82fe6d0e22b1e178d86a5dd"}},"metadata":{"buildInvocationID":"11158160899-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"a275be0868d02c79c82fe6d0e22b1e178d86a5dd"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCCfqAeo5l2fr+g7zVpV+ZtjJRXjBLMyQX+ac7mEcfCcwIhAJn/SVueDLYh5ZjafmKhgT+h7jizsIcWJK17rQPfsqRc","cert":"-----BEGIN CERTIFICATE-----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\nfN1gcqaF31L+jOl0hmBZzTsl7mCiIjxQ3c+3\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a7/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a7/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..d0fe6dee6616beb4145500b8813dca344d19d024 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a7/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a7-py3-none-any.whl","digest":{"sha256":"710e00464178def838671cdd3d15b78bedbed407847e0fa999237289ed3bf31c"}},{"name":"./aws_lambda_powertools-3.0.1a7.tar.gz","digest":{"sha256":"c7813d9077be3e7a0ff4ff617caac20c8d3e99feeefe7fbee27395b35ee0e9fe"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"dcc8d5c337db89f8c7f9cd9d9162354ff4f1f428"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":390,"forks_count":390,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":92,"open_issues_count":92,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-03T20:34:46Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":58567,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2831,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-04T06:15:36Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2831,"watchers_count":2831,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11176258090","github_run_number":"80","github_sha1":"dcc8d5c337db89f8c7f9cd9d9162354ff4f1f428"}},"metadata":{"buildInvocationID":"11176258090-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"dcc8d5c337db89f8c7f9cd9d9162354ff4f1f428"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCb8VawaLmI5F9Bsyu1NLxK+EQMCk8Kf1/mYSrTofIvigIhAIje1SC6xA+4bqxsYfDFxgQT4xM7Ae6F6vxkOhsqeyrM","cert":"-----BEGIN CERTIFICATE-----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\nZKChc3VpTj3lFLoFy90OESTEImTnN8Xs\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a8/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a8/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..5af4978668a4d83b559508e399395abbaab747da --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a8/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a8-py3-none-any.whl","digest":{"sha256":"9c78d27bdfe0a937e11e91e867b7713ca0bfcd6244d06ee4d4bbedd4d66d158b"}},{"name":"./aws_lambda_powertools-3.0.1a8.tar.gz","digest":{"sha256":"ac33f488358313db81f6e8ad072e1ca6f7e451d2935061cdcd318bc2c40208c2"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"3173021356dfb98c083d8b76e7908797b00abe69"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":389,"forks_count":389,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":103,"open_issues_count":103,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-06T22:57:28Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":58807,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2833,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-06T13:37:57Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2833,"watchers_count":2833,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11211192494","github_run_number":"81","github_sha1":"3173021356dfb98c083d8b76e7908797b00abe69"}},"metadata":{"buildInvocationID":"11211192494-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"3173021356dfb98c083d8b76e7908797b00abe69"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCJRChl7vdl2vCdTI2f1AVk3isZeqMcm7S2KdcUeB/mlwIhAO7WzE4Kl2HTqztcm29+lFwExhhvmxrMm2RErpWrAcjK","cert":"-----BEGIN CERTIFICATE-----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\nbqOKlDBxG97uBH4AGD86TpDoLjTrmwr/LuU=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a9/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a9/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..0a45ed722ffdc20a9ef93a6d9ff0353abb818b10 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.0.1a9/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.0.1a9-py3-none-any.whl","digest":{"sha256":"610c05e4b604624b0a0443bced1c2c7d0f32e62442d1617f223a1f61497ef7ac"}},{"name":"./aws_lambda_powertools-3.0.1a9.tar.gz","digest":{"sha256":"6bb2984b9f54ced6218106ee9f9a3a49dd1441cc6462310764d59253e6c9ebfe"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"54ee168fa09c2e01931ebd16b31ad95fe9926569"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":389,"forks_count":389,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":94,"open_issues_count":94,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-07T21:16:26Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":58686,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2835,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-07T21:16:28Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2835,"watchers_count":2835,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11231126337","github_run_number":"82","github_sha1":"54ee168fa09c2e01931ebd16b31ad95fe9926569"}},"metadata":{"buildInvocationID":"11231126337-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"54ee168fa09c2e01931ebd16b31ad95fe9926569"}}]}}","signatures":[{"keyid":"","sig":"MEUCIE5b+e5SFA04lwqzsIWxFUoV8YYNqjxnkOwWqI/pqcOyAiEAuriyNanYciikEKbuv1chSIX5MazGje1sajuKH4e4zBE=","cert":"-----BEGIN CERTIFICATE-----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\n0O6S9wCsrMVV7HfFq08MYrkmq5n+dZ4O01U=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.1.1a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.1.1a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..42bff3a61503af86a3f83e5b36022584bc307468 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.1.1a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.1.1a0-py3-none-any.whl","digest":{"sha256":"b15366c83752baec2dfe816861e5e2619adb93967abdc7c767fdc9bd62aca3d8"}},{"name":"./aws_lambda_powertools-3.1.1a0.tar.gz","digest":{"sha256":"e4642c51325ba37247e1b887d38f70361f1d5a2124be832d70e7e2d1078a84e2"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"45c251e8e12c7f8078345adea593c5f0e6ede701"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":389,"forks_count":389,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":94,"open_issues_count":94,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-08T21:11:14Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":59012,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2836,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-08T21:06:57Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2836,"watchers_count":2836,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11250719546","github_run_number":"83","github_sha1":"45c251e8e12c7f8078345adea593c5f0e6ede701"}},"metadata":{"buildInvocationID":"11250719546-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"45c251e8e12c7f8078345adea593c5f0e6ede701"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQDmQRDWNUyf3zcuYEtHsojc7DHwXrL35e1feQNq4KkR4wIhANWJx9oU9Y4gwllQdF8ubIeM1FWCSFCtCvSTiUO7xefp","cert":"-----BEGIN CERTIFICATE-----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\nm4vqurCopaqxcNf1ljHz9UlDqHlxHpyoACg=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..e0851163e6d27346d0956e58f89215988f1805d8 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a0-py3-none-any.whl","digest":{"sha256":"c3f4ccca2e55df90ba4f1590e10de0544eb96a26f97d552061affdcd92d5bfbf"}},{"name":"./aws_lambda_powertools-3.2.1a0.tar.gz","digest":{"sha256":"d792d80dc0f192adc8dda7dc2cc8537570940de3216cca5e50534496e49fef2f"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"43936ae757f5f6e42c2d98745c457231742bd6a6"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":392,"forks_count":392,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":93,"open_issues_count":93,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-23T07:57:36Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":59775,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2850,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-23T07:54:12Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2850,"watchers_count":2850,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11475615901","github_run_number":"93","github_sha1":"43936ae757f5f6e42c2d98745c457231742bd6a6"}},"metadata":{"buildInvocationID":"11475615901-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"43936ae757f5f6e42c2d98745c457231742bd6a6"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCbx3RZD/rrqPa4wS7bdl1pSLhUt5qdgsPFnI/4eRCAnAIhAIZmn0h7nMJnECCEoL/OxjgrcYJAPfpeS7EJRBQiYOV8","cert":"-----BEGIN CERTIFICATE-----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\nkMXALXFXXJhDBmHKiIXVj7cGi9kRw+vz\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..155b6a34a46e0868492eeccb158abdf8bd09bd32 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a1-py3-none-any.whl","digest":{"sha256":"6f949a28e280d6a554ca272e2a2e32c00db28f8112c89b3307e4a1efff3bdad8"}},{"name":"./aws_lambda_powertools-3.2.1a1.tar.gz","digest":{"sha256":"da30af24ee7823acdd7f54a3e10979315dd819722db27c495e563fedd32b2696"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"954834c4869f0f03eebb08a08c08ec76a1afc3a3"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":392,"forks_count":392,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":94,"open_issues_count":94,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-24T07:59:44Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":59946,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2852,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-24T07:59:47Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2852,"watchers_count":2852,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11495101856","github_run_number":"94","github_sha1":"954834c4869f0f03eebb08a08c08ec76a1afc3a3"}},"metadata":{"buildInvocationID":"11495101856-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"954834c4869f0f03eebb08a08c08ec76a1afc3a3"}}]}}","signatures":[{"keyid":"","sig":"MEUCIBOPC3gwos6Ymsp8D3dPQC+oXeij/mz6PXll+WI8kEPeAiEA+MGzsUn6o2w58oxRZcDW1O9QsT+YujPqGPi6qFuNB1w=","cert":"-----BEGIN CERTIFICATE-----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\nFQg631BCP2Io0WqbOFM4G83vzffcGtufJdA=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a10/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a10/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..fdb5cff7fdde36454b288a11e65c815fbf6a2c38 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a10/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a10-py3-none-any.whl","digest":{"sha256":"6bc85251959333eae59ba5a193e04aba8e56a71818490c918b344e6c7fa9c73e"}},{"name":"./aws_lambda_powertools-3.2.1a10.tar.gz","digest":{"sha256":"cb5ad5a4562e68350044b0c5dd59751c65f0aedef0ef21279e20b606a4efc11b"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"398846965414ca7ee5c7ad89bc09dda72083e359"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":395,"forks_count":395,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":102,"open_issues_count":102,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-05T20:45:44Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":62024,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2876,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-06T03:09:34Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2876,"watchers_count":2876,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11699447604","github_run_number":"103","github_sha1":"398846965414ca7ee5c7ad89bc09dda72083e359"}},"metadata":{"buildInvocationID":"11699447604-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"398846965414ca7ee5c7ad89bc09dda72083e359"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQDFmUpBBEaDdwjn6n/QSXR6Dmq+LYud4fuA1Uu0WNErlQIgaWf87pOyekZBvFeBCQUtIxHbPR494Kfj07npybHJEzs=","cert":"-----BEGIN CERTIFICATE-----\nMIIHZTCCBuygAwIBAgIUQFjNwXRYfkWwgTTyRt7CiJGXbjQwCgYIKoZIzj0EAwMw\nNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRl\ncm1lZGlhdGUwHhcNMjQxMTA2MDgwNzM0WhcNMjQxMTA2MDgxNzM0WjAAMFkwEwYH\nKoZIzj0CAQYIKoZIzj0DAQcDQgAERTSag+c6OHiOre7PebdHJvBCr7n6IuHNwGbe\nPxKIKsKpYu7PnTTUVy122yfKlJ8NX+7xK5/Aox5KOKe77jKE76OCBgswggYHMA4G\nA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAdBgNVHQ4EFgQU0JRg\n/NiUH/GLzcsbtpvBPTS5iyUwHwYDVR0jBBgwFoAU39Ppz1YkEZb5qNjpKFWixi4Y\nZD8wgYQGA1UdEQEB/wR6MHiGdmh0dHBzOi8vZ2l0aHViLmNvbS9zbHNhLWZyYW1l\nd29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3IvLmdpdGh1Yi93b3JrZmxvd3MvZ2Vu\nZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJlZnMvdGFncy92Mi4wLjAwOQYKKwYB\nBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50\nLmNvbTAWBgorBgEEAYO/MAECBAhzY2hlZHVsZTA2BgorBgEEAYO/MAEDBCgzOTg4\nNDY5NjU0MTRjYTdlZTVjN2FkODliYzA5ZGRhNzIwODNlMzU5MBkGCisGAQQBg78w\nAQQEC1ByZS1SZWxlYXNlMDUGCisGAQQBg78wAQUEJ2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbjAgBgorBgEEAYO/MAEGBBJyZWZzL2hlYWRz\nL2RldmVsb3AwOwYKKwYBBAGDvzABCAQtDCtodHRwczovL3Rva2VuLmFjdGlvbnMu\nZ2l0aHVidXNlcmNvbnRlbnQuY29tMIGGBgorBgEEAYO/MAEJBHgMdmh0dHBzOi8v\nZ2l0aHViLmNvbS9zbHNhLWZyYW1ld29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3Iv\nLmdpdGh1Yi93b3JrZmxvd3MvZ2VuZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJl\nZnMvdGFncy92Mi4wLjAwOAYKKwYBBAGDvzABCgQqDCg1YTc3NWIzNjdhNTZkNWJk\nMTE4YTIyNGE4MTFiYmEyODgxNTBhNTYzMB0GCisGAQQBg78wAQsEDwwNZ2l0aHVi\nLWhvc3RlZDBKBgorBgEEAYO/MAEMBDwMOmh0dHBzOi8vZ2l0aHViLmNvbS9hd3Mt\ncG93ZXJ0b29scy9wb3dlcnRvb2xzLWxhbWJkYS1weXRob24wOAYKKwYBBAGDvzAB\nDQQqDCgzOTg4NDY5NjU0MTRjYTdlZTVjN2FkODliYzA5ZGRhNzIwODNlMzU5MCIG\nCisGAQQBg78wAQ4EFAwScmVmcy9oZWFkcy9kZXZlbG9wMBkGCisGAQQBg78wAQ8E\nCwwJMjIxOTE5Mzc5MDEGCisGAQQBg78wARAEIwwhaHR0cHM6Ly9naXRodWIuY29t\nL2F3cy1wb3dlcnRvb2xzMBkGCisGAQQBg78wAREECwwJMTI5MTI3NjM4MH8GCisG\nAQQBg78wARIEcQxvaHR0cHM6Ly9naXRodWIuY29tL2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbi8uZ2l0aHViL3dvcmtmbG93cy9wcmUtcmVs\nZWFzZS55bWxAcmVmcy9oZWFkcy9kZXZlbG9wMDgGCisGAQQBg78wARMEKgwoMzk4\nODQ2OTY1NDE0Y2E3ZWU1YzdhZDg5YmMwOWRkYTcyMDgzZTM1OTAYBgorBgEEAYO/\nMAEUBAoMCHNjaGVkdWxlMG4GCisGAQQBg78wARUEYAxeaHR0cHM6Ly9naXRodWIu\nY29tL2F3cy1wb3dlcnRvb2xzL3Bvd2VydG9vbHMtbGFtYmRhLXB5dGhvbi9hY3Rp\nb25zL3J1bnMvMTE2OTk0NDc2MDQvYXR0ZW1wdHMvMTAWBgorBgEEAYO/MAEWBAgM\nBnB1YmxpYzCBigYKKwYBBAHWeQIEAgR8BHoAeAB2AN09MGrGxxEyYxkeHJlnNwKi\nSl643jyt/4eKcoAvKe6OAAABkwCDvecAAAQDAEcwRQIgbKG/2xnSRD3+0I+Qpjyp\nj2lp/wUCNdQE+Z+02rgrSoICIQCUJKUw2UPqH0mlHgEIS/A1X1IDhKMWRYHXR0Xa\ngWc/ljAKBggqhkjOPQQDAwNnADBkAjAp4jFGZ39Jr20cIGWL99gHxJOdAgnnNwo1\nCN+v4HYt/q0FXvJ2YYB4yOv7SESfozkCMGsvw+lptkHu+Lrd7ACo7nYfGamzy22S\nddyUqTy9doU4O5Mnby8LjWegkVkEv2AkTw==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a11/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a11/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..94d04501f99ab77453fcd8ca8130b74401a6c7a7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a11/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a11-py3-none-any.whl","digest":{"sha256":"f2d2ec2a42bfc4a2e7eba84074f7d0b875001585bce203498fcebf4735391179"}},{"name":"./aws_lambda_powertools-3.2.1a11.tar.gz","digest":{"sha256":"0199fd3cfbf35259b38830274c2cd886cd8ab5848f4e17a0fbf355df863385fd"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"625d13d01a3666bf2700a426efa900393354f6cb"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":396,"forks_count":396,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":102,"open_issues_count":102,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-06T22:49:37Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":62447,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2878,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-06T19:11:15Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2878,"watchers_count":2878,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11718875399","github_run_number":"104","github_sha1":"625d13d01a3666bf2700a426efa900393354f6cb"}},"metadata":{"buildInvocationID":"11718875399-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"625d13d01a3666bf2700a426efa900393354f6cb"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQDLQntQ4dE3thahFOh93AuwIuvL/28etT4mjoXeiEZaLgIhANxCaNavnZiyo+9ApTqeLg3DDg4IDj/5eUdO625rWQn6","cert":"-----BEGIN CERTIFICATE-----\nMIIHZTCCBuugAwIBAgIUHDCG2+oRKBFqFDK1h7HQZ7JxZSMwCgYIKoZIzj0EAwMw\nNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRl\ncm1lZGlhdGUwHhcNMjQxMTA3MDgwNzMxWhcNMjQxMTA3MDgxNzMxWjAAMFkwEwYH\nKoZIzj0CAQYIKoZIzj0DAQcDQgAEAq+qERL5XHodtEI29uzfhYv7PY4R4TCDM0Vh\nSEtr36jyH4cngtDwUVeFNCLUhgMXmEjUPNFOPpdCWbyeRyCW6aOCBgowggYGMA4G\nA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAdBgNVHQ4EFgQUQz4R\nxEHnUSqLHZdbbk2o6HFxqMAwHwYDVR0jBBgwFoAU39Ppz1YkEZb5qNjpKFWixi4Y\nZD8wgYQGA1UdEQEB/wR6MHiGdmh0dHBzOi8vZ2l0aHViLmNvbS9zbHNhLWZyYW1l\nd29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3IvLmdpdGh1Yi93b3JrZmxvd3MvZ2Vu\nZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJlZnMvdGFncy92Mi4wLjAwOQYKKwYB\nBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50\nLmNvbTAWBgorBgEEAYO/MAECBAhzY2hlZHVsZTA2BgorBgEEAYO/MAEDBCg2MjVk\nMTNkMDFhMzY2NmJmMjcwMGE0MjZlZmE5MDAzOTMzNTRmNmNiMBkGCisGAQQBg78w\nAQQEC1ByZS1SZWxlYXNlMDUGCisGAQQBg78wAQUEJ2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbjAgBgorBgEEAYO/MAEGBBJyZWZzL2hlYWRz\nL2RldmVsb3AwOwYKKwYBBAGDvzABCAQtDCtodHRwczovL3Rva2VuLmFjdGlvbnMu\nZ2l0aHVidXNlcmNvbnRlbnQuY29tMIGGBgorBgEEAYO/MAEJBHgMdmh0dHBzOi8v\nZ2l0aHViLmNvbS9zbHNhLWZyYW1ld29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3Iv\nLmdpdGh1Yi93b3JrZmxvd3MvZ2VuZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJl\nZnMvdGFncy92Mi4wLjAwOAYKKwYBBAGDvzABCgQqDCg1YTc3NWIzNjdhNTZkNWJk\nMTE4YTIyNGE4MTFiYmEyODgxNTBhNTYzMB0GCisGAQQBg78wAQsEDwwNZ2l0aHVi\nLWhvc3RlZDBKBgorBgEEAYO/MAEMBDwMOmh0dHBzOi8vZ2l0aHViLmNvbS9hd3Mt\ncG93ZXJ0b29scy9wb3dlcnRvb2xzLWxhbWJkYS1weXRob24wOAYKKwYBBAGDvzAB\nDQQqDCg2MjVkMTNkMDFhMzY2NmJmMjcwMGE0MjZlZmE5MDAzOTMzNTRmNmNiMCIG\nCisGAQQBg78wAQ4EFAwScmVmcy9oZWFkcy9kZXZlbG9wMBkGCisGAQQBg78wAQ8E\nCwwJMjIxOTE5Mzc5MDEGCisGAQQBg78wARAEIwwhaHR0cHM6Ly9naXRodWIuY29t\nL2F3cy1wb3dlcnRvb2xzMBkGCisGAQQBg78wAREECwwJMTI5MTI3NjM4MH8GCisG\nAQQBg78wARIEcQxvaHR0cHM6Ly9naXRodWIuY29tL2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbi8uZ2l0aHViL3dvcmtmbG93cy9wcmUtcmVs\nZWFzZS55bWxAcmVmcy9oZWFkcy9kZXZlbG9wMDgGCisGAQQBg78wARMEKgwoNjI1\nZDEzZDAxYTM2NjZiZjI3MDBhNDI2ZWZhOTAwMzkzMzU0ZjZjYjAYBgorBgEEAYO/\nMAEUBAoMCHNjaGVkdWxlMG4GCisGAQQBg78wARUEYAxeaHR0cHM6Ly9naXRodWIu\nY29tL2F3cy1wb3dlcnRvb2xzL3Bvd2VydG9vbHMtbGFtYmRhLXB5dGhvbi9hY3Rp\nb25zL3J1bnMvMTE3MTg4NzUzOTkvYXR0ZW1wdHMvMTAWBgorBgEEAYO/MAEWBAgM\nBnB1YmxpYzCBiQYKKwYBBAHWeQIEAgR7BHkAdwB1AN09MGrGxxEyYxkeHJlnNwKi\nSl643jyt/4eKcoAvKe6OAAABkwWqEEAAAAQDAEYwRAIgWo0OzeexZZ4Z40gzsamx\nXeAAu083RekHWRDEKR5i2dMCIHhw5OVKxzs1hSO3QTR43uSRGsBDaCfXx6S1lSkh\nh3FuMAoGCCqGSM49BAMDA2gAMGUCMQCF1mQnvFH2D1U9ehxnMHR2IN28bV06rWYU\nK1U7Fc7eGIL0Tlgso5PWhooCnrabsk0CMGJe7Vg0w2LTpUbgwIbU1oFqo0gSPv6G\no3EcHH3DeDnY5T+SU7lSwDSYSAM2BguHTg==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a12/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a12/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..1c04e9ae3345dfb33274643870bad0cba3106fe2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a12/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a12-py3-none-any.whl","digest":{"sha256":"19568ab28f633b649238201161156935027d30c424ccee3a1ef5c961b03c3975"}},{"name":"./aws_lambda_powertools-3.2.1a12.tar.gz","digest":{"sha256":"5a889e52c3d7cf6f97d894187bc20b92dc3cd77f98cd8b5e0a46f816f9572d63"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"e8d48599642a70f5443c575ef8730fd067b2931b"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":396,"forks_count":396,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":96,"open_issues_count":96,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-07T21:12:57Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":61964,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2879,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-07T19:16:33Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2879,"watchers_count":2879,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11738303493","github_run_number":"105","github_sha1":"e8d48599642a70f5443c575ef8730fd067b2931b"}},"metadata":{"buildInvocationID":"11738303493-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"e8d48599642a70f5443c575ef8730fd067b2931b"}}]}}","signatures":[{"keyid":"","sig":"MEQCIC6aBqwOxMzRQIHtZeiXP/7VEcMjEeBCipdQmGa8FsL1AiBz85H8u7N1X99l9nsfD4f3el9Mtrci4t8IzbcN33taLA==","cert":"-----BEGIN CERTIFICATE-----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\nL6BFPeo00KJUTvf95ZehY7wIVk/QjGiQTg==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a13/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a13/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..6a084f856a201c419ac5b22f2dd6fddf00cbe681 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a13/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a13-py3-none-any.whl","digest":{"sha256":"5df594f35138606cb63041567757370b97631b7351bccebde78244ceaf030fb0"}},{"name":"./aws_lambda_powertools-3.2.1a13.tar.gz","digest":{"sha256":"01454dc954f53f787d757cfffb64c1ad30887a88cf2cc7a8023dc5300430cc01"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"68ddf3e29acdf5a54885dde555b8915b45e404e0"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":397,"forks_count":397,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":93,"open_issues_count":93,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-10T17:55:36Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":62697,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2880,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-11T06:34:42Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2880,"watchers_count":2880,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11774462017","github_run_number":"106","github_sha1":"68ddf3e29acdf5a54885dde555b8915b45e404e0"}},"metadata":{"buildInvocationID":"11774462017-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"68ddf3e29acdf5a54885dde555b8915b45e404e0"}}]}}","signatures":[{"keyid":"","sig":"MEUCIA4Q2phQGlzNeC/DVuA7wol2y/bQH5O43IiGitTjJK//AiEApW69aayPyV/azht/ALLH30Zkr112hOe11s/1qO/USTc=","cert":"-----BEGIN CERTIFICATE-----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\nGBZcWoDsLAmryYfAz0bl/hrcGrySMCELAQ==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a14/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a14/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..5504724871b505ae3b20863243f710ef8f07d63f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a14/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a14-py3-none-any.whl","digest":{"sha256":"d5e5e24ea362d87821a48dc8555f705a3b0e2a55e4339ac7be165d5ba29e8e47"}},{"name":"./aws_lambda_powertools-3.2.1a14.tar.gz","digest":{"sha256":"b8d6c03bed1326160634e0c32b75d540b7d5b7243abfa4a7d1db3b2bda361323"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"f8fe2a3c60e132cf211090417b83eb6ff9dffbc2"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":397,"forks_count":397,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":92,"open_issues_count":92,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-12T20:37:50Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":62115,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2883,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-13T00:28:12Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2883,"watchers_count":2883,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11813003739","github_run_number":"108","github_sha1":"f8fe2a3c60e132cf211090417b83eb6ff9dffbc2"}},"metadata":{"buildInvocationID":"11813003739-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"f8fe2a3c60e132cf211090417b83eb6ff9dffbc2"}}]}}","signatures":[{"keyid":"","sig":"MEUCIDKshhLu9BJqZ43smm8GqnrL7pfKTObOd2N019tmxd0GAiEAmycTcmRTFpwwFlua01Laqjs6A+haWkYtjpo7aguecPo=","cert":"-----BEGIN CERTIFICATE-----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\nwhpX+5hi3wr4SQjsJ58MfxBBfZAUip8lCw==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a15/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a15/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..98104dc66dd125cb5e1278880931a46d36fc6dc6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a15/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a15-py3-none-any.whl","digest":{"sha256":"2d2b266fb321eab52f717a6cdedf6bafedbdd66f9aa6748505d68514ac9e7782"}},{"name":"./aws_lambda_powertools-3.2.1a15.tar.gz","digest":{"sha256":"5e89cf23a9335d4895190f5d1093622495662f8b2c74ec4b4e41b83bbabb4439"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d1f7db65fec99a5f4fbec5baa5bc262850970ed5"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":397,"forks_count":397,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":95,"open_issues_count":95,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-14T07:43:22Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":62537,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2883,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-13T16:35:49Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2883,"watchers_count":2883,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11833042626","github_run_number":"109","github_sha1":"d1f7db65fec99a5f4fbec5baa5bc262850970ed5"}},"metadata":{"buildInvocationID":"11833042626-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"d1f7db65fec99a5f4fbec5baa5bc262850970ed5"}}]}}","signatures":[{"keyid":"","sig":"MEQCIGjvfyQ7gCj4qiIDDFlznFvhz0B+w/4JZXCQQnouj/VgAiB06R4y7kEIyEeMraHyYFDziCnLlM6aFtl9S6jlR381Ag==","cert":"-----BEGIN CERTIFICATE-----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\nDKnGZOjK8FjpiISB4VbmKAN0pP3LbDYmcg==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..18892ea9c68ccf3c5df2f13f65013f9d4ab15103 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a2-py3-none-any.whl","digest":{"sha256":"53ba732213196facfefb3efcaab50cadf429a4eaf1b3ef748b9107f1a788ed7e"}},{"name":"./aws_lambda_powertools-3.2.1a2.tar.gz","digest":{"sha256":"a089210bad0f7606bd40ef4706004016b31e2cc8cbb4dd84883e462869e0278a"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"fa1c29f2d497a7c233f06eb69d0f7ee1b187a9e4"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":392,"forks_count":392,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":99,"open_issues_count":99,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-24T20:33:45Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":60747,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2855,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-25T06:14:44Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2855,"watchers_count":2855,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11514280029","github_run_number":"95","github_sha1":"fa1c29f2d497a7c233f06eb69d0f7ee1b187a9e4"}},"metadata":{"buildInvocationID":"11514280029-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"fa1c29f2d497a7c233f06eb69d0f7ee1b187a9e4"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCGViolicNvg5HdRAJPhKW+yawRRDLmHEez/ASMS+rHTAIhANvMvi005K2mL4GzXbbwDfbRaHdkWA/n4cTECiqAruyU","cert":"-----BEGIN CERTIFICATE-----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\nTWFIE0m4olup3KOkvZFRB/qVWnFIoejNv+ys\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a3/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a3/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..046705acfedc733f487debef0413054cc742cd95 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a3/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a3-py3-none-any.whl","digest":{"sha256":"6df3d32c356884f16d882ac63ef3c5d038bdb20e17ff9cc17fb7503b7d8e7f38"}},{"name":"./aws_lambda_powertools-3.2.1a3.tar.gz","digest":{"sha256":"c918e032703daee3b7ecfbc239e3cbcc9baf8590afe2193f9c93b70713e90403"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"7eb6026264b434f0b1017b41b2621c165c2b5bde"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":393,"forks_count":393,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":98,"open_issues_count":98,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-27T10:03:44Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":60162,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2857,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-27T20:21:41Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2857,"watchers_count":2857,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11549711459","github_run_number":"96","github_sha1":"7eb6026264b434f0b1017b41b2621c165c2b5bde"}},"metadata":{"buildInvocationID":"11549711459-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"7eb6026264b434f0b1017b41b2621c165c2b5bde"}}]}}","signatures":[{"keyid":"","sig":"MEQCICU2qpaP/o5e4BOYXmIhCqBLmYLtbKgRel7VK//7VPt/AiAUpgBgWa7ojVEc6TynWVGD5TO16sisIxkojldCX5m6wA==","cert":"-----BEGIN CERTIFICATE-----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\n53Qj5X6Q5rwPN4nAqTPokLLnVZSaP8hlApw=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a4/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a4/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..c37957268772864f2c1a9c2c9fae20b22e4bf2a4 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a4/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a4-py3-none-any.whl","digest":{"sha256":"dbf7cb75d6783abe634ccb71bd947a25744ac3db29cbb85c18502aea2119df7b"}},{"name":"./aws_lambda_powertools-3.2.1a4.tar.gz","digest":{"sha256":"151ae5a252fd748b2b91566cb7be4b521b020406e0501e0f0cbdff289875ad34"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"42adf88b80815ae158660fe55a6df48516ebe246"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":393,"forks_count":393,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":95,"open_issues_count":95,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-28T20:41:16Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":59618,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2862,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-29T02:03:21Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2862,"watchers_count":2862,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11569609657","github_run_number":"97","github_sha1":"42adf88b80815ae158660fe55a6df48516ebe246"}},"metadata":{"buildInvocationID":"11569609657-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"42adf88b80815ae158660fe55a6df48516ebe246"}}]}}","signatures":[{"keyid":"","sig":"MEQCIAoJ0uA11nFasTEzGhm1KleZFBvzDPYHj6GBAvAPzqhXAiAjFBRUOeG9uUrtev321IDQFitklO4utCkXv/1EkiVDMg==","cert":"-----BEGIN CERTIFICATE-----\nMIIHZTCCBuygAwIBAgIUJcA5M6HY98wrzjfwFxTdMUvMvC4wCgYIKoZIzj0EAwMw\nNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRl\ncm1lZGlhdGUwHhcNMjQxMDI5MDgwODA5WhcNMjQxMDI5MDgxODA5WjAAMFkwEwYH\nKoZIzj0CAQYIKoZIzj0DAQcDQgAESC1VJxyyd3X3HV4HnRyLHc0xKtP32tVj8Niq\nS1gdvcYQUN7lP1/1oJ971z87iOXQ8K6bwL6KwERp3+PXqims26OCBgswggYHMA4G\nA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAdBgNVHQ4EFgQUpjs6\nK4FhUaGBRpzsXsabXsJ9LLYwHwYDVR0jBBgwFoAU39Ppz1YkEZb5qNjpKFWixi4Y\nZD8wgYQGA1UdEQEB/wR6MHiGdmh0dHBzOi8vZ2l0aHViLmNvbS9zbHNhLWZyYW1l\nd29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3IvLmdpdGh1Yi93b3JrZmxvd3MvZ2Vu\nZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJlZnMvdGFncy92Mi4wLjAwOQYKKwYB\nBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJjb250ZW50\nLmNvbTAWBgorBgEEAYO/MAECBAhzY2hlZHVsZTA2BgorBgEEAYO/MAEDBCg0MmFk\nZjg4YjgwODE1YWUxNTg2NjBmZTU1YTZkZjQ4NTE2ZWJlMjQ2MBkGCisGAQQBg78w\nAQQEC1ByZS1SZWxlYXNlMDUGCisGAQQBg78wAQUEJ2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbjAgBgorBgEEAYO/MAEGBBJyZWZzL2hlYWRz\nL2RldmVsb3AwOwYKKwYBBAGDvzABCAQtDCtodHRwczovL3Rva2VuLmFjdGlvbnMu\nZ2l0aHVidXNlcmNvbnRlbnQuY29tMIGGBgorBgEEAYO/MAEJBHgMdmh0dHBzOi8v\nZ2l0aHViLmNvbS9zbHNhLWZyYW1ld29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3Iv\nLmdpdGh1Yi93b3JrZmxvd3MvZ2VuZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJl\nZnMvdGFncy92Mi4wLjAwOAYKKwYBBAGDvzABCgQqDCg1YTc3NWIzNjdhNTZkNWJk\nMTE4YTIyNGE4MTFiYmEyODgxNTBhNTYzMB0GCisGAQQBg78wAQsEDwwNZ2l0aHVi\nLWhvc3RlZDBKBgorBgEEAYO/MAEMBDwMOmh0dHBzOi8vZ2l0aHViLmNvbS9hd3Mt\ncG93ZXJ0b29scy9wb3dlcnRvb2xzLWxhbWJkYS1weXRob24wOAYKKwYBBAGDvzAB\nDQQqDCg0MmFkZjg4YjgwODE1YWUxNTg2NjBmZTU1YTZkZjQ4NTE2ZWJlMjQ2MCIG\nCisGAQQBg78wAQ4EFAwScmVmcy9oZWFkcy9kZXZlbG9wMBkGCisGAQQBg78wAQ8E\nCwwJMjIxOTE5Mzc5MDEGCisGAQQBg78wARAEIwwhaHR0cHM6Ly9naXRodWIuY29t\nL2F3cy1wb3dlcnRvb2xzMBkGCisGAQQBg78wAREECwwJMTI5MTI3NjM4MH8GCisG\nAQQBg78wARIEcQxvaHR0cHM6Ly9naXRodWIuY29tL2F3cy1wb3dlcnRvb2xzL3Bv\nd2VydG9vbHMtbGFtYmRhLXB5dGhvbi8uZ2l0aHViL3dvcmtmbG93cy9wcmUtcmVs\nZWFzZS55bWxAcmVmcy9oZWFkcy9kZXZlbG9wMDgGCisGAQQBg78wARMEKgwoNDJh\nZGY4OGI4MDgxNWFlMTU4NjYwZmU1NWE2ZGY0ODUxNmViZTI0NjAYBgorBgEEAYO/\nMAEUBAoMCHNjaGVkdWxlMG4GCisGAQQBg78wARUEYAxeaHR0cHM6Ly9naXRodWIu\nY29tL2F3cy1wb3dlcnRvb2xzL3Bvd2VydG9vbHMtbGFtYmRhLXB5dGhvbi9hY3Rp\nb25zL3J1bnMvMTE1Njk2MDk2NTcvYXR0ZW1wdHMvMTAWBgorBgEEAYO/MAEWBAgM\nBnB1YmxpYzCBigYKKwYBBAHWeQIEAgR8BHoAeAB2AN09MGrGxxEyYxkeHJlnNwKi\nSl643jyt/4eKcoAvKe6OAAABktdRaWEAAAQDAEcwRQIgUf8Func35UzkZgLHNCdc\nJPuja+zNaGrHvNPiK/vXO2YCIQDZcGv+Fl+vq0FLz/hohjUUnCTFjW/9rv7w4QSM\nlfwF/TAKBggqhkjOPQQDAwNnADBkAjAt17HDTfAtPqk4TS2Pe+4SNO77U74xLffu\n7kEFfikNoIP+Yk+0dR4FgO7W2mM3GeYCMEivHWbYpVmNSW5gscNX6r5qohHW8izN\nEPR1x5OvaLWNHwCwW88EBMcc3eDIEO7oLA==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a5/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a5/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..d748f7b49a904b4c35571e2be562c50788422330 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a5/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a5-py3-none-any.whl","digest":{"sha256":"36f7be0c806856661fa4b5d634c15b5f8c743a54a5aafc50977739d6bab57bcc"}},{"name":"./aws_lambda_powertools-3.2.1a5.tar.gz","digest":{"sha256":"02c8c9cc6975b11689268f5dd8e34c77a4badacf8d003e17054c6a37eac3f092"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"bb07383ced3e2154d5c653743b0dd22ccd89784e"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":394,"forks_count":394,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":94,"open_issues_count":94,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-29T20:54:05Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":59984,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2868,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-29T17:47:10Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2868,"watchers_count":2868,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11589121149","github_run_number":"98","github_sha1":"bb07383ced3e2154d5c653743b0dd22ccd89784e"}},"metadata":{"buildInvocationID":"11589121149-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"bb07383ced3e2154d5c653743b0dd22ccd89784e"}}]}}","signatures":[{"keyid":"","sig":"MEUCIQCqRtc3pNwZDvV04+AXXAUH0KLSaWfBQwz/hNWIV4kqMAIgcyuqc1qrDrliZswcTVv4S2HaL51MLAKia15Q3VMtEi0=","cert":"-----BEGIN CERTIFICATE-----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\n3uja6gOK25qJvgbJsn6ik1ZOn8h77edGbmhm\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a6/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a6/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..678e33e0508d16447667bf96fd3ae7c91d094f31 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a6/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a6-py3-none-any.whl","digest":{"sha256":"41e097d8ca636cbec8e6243b7a10eefc649ee1c4f78e18db849e06a745ae4789"}},{"name":"./aws_lambda_powertools-3.2.1a6.tar.gz","digest":{"sha256":"547b2012042830b3a29dbaf2130834e45916c841c97624ab464df979552442a1"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"a42dadf686e2de2f0501d867c3289d79ea83de2f"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":394,"forks_count":394,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":97,"open_issues_count":97,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-30T20:48:22Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":60221,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2871,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-30T23:31:45Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2871,"watchers_count":2871,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11608164091","github_run_number":"99","github_sha1":"a42dadf686e2de2f0501d867c3289d79ea83de2f"}},"metadata":{"buildInvocationID":"11608164091-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"a42dadf686e2de2f0501d867c3289d79ea83de2f"}}]}}","signatures":[{"keyid":"","sig":"MEUCIFejJaW+7qGdqe8QtOjQFnbdbSSIA2XWSP89eua7Psa9AiEAiRsqkQdke0iZyOrihUBKsiL45knXdMq5s5ZgMapjPM8=","cert":"-----BEGIN CERTIFICATE-----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\n794vjdRNjpTdwPDtygG21Jl8rJnRNaH+6R0g\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a7/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a7/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..69434bc6a559e211c5febbe883c7915d432ea39a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a7/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a7-py3-none-any.whl","digest":{"sha256":"944dcee9c9bf13acfb01a13686080c9a0f9333e68d4fd13a1adde7c5f4869342"}},{"name":"./aws_lambda_powertools-3.2.1a7.tar.gz","digest":{"sha256":"84ccf0018723c8a4eafb3fe16c97f674eeed21ad3a715b16d586b47d95546a97"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"497e6cf7f136d3b9363f5ba62d9943fe50445c3f"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":395,"forks_count":395,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":101,"open_issues_count":101,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-10-31T20:59:01Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":60259,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2871,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-10-31T15:42:40Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2871,"watchers_count":2871,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11626274096","github_run_number":"100","github_sha1":"497e6cf7f136d3b9363f5ba62d9943fe50445c3f"}},"metadata":{"buildInvocationID":"11626274096-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"497e6cf7f136d3b9363f5ba62d9943fe50445c3f"}}]}}","signatures":[{"keyid":"","sig":"MEUCIGrI73oWL4Lvxt76s0tXoyJWICFm5cQlisSVCIg5TMvIAiEAw2fMw2kJWyqxmmub0A/8uOM7zBLS93vFJP8MQlZVW5w=","cert":"-----BEGIN CERTIFICATE-----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\n3OvVByJWEq4ziCK1Y9S2jXm/9kSiiJe9giw=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a8/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a8/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..1ec4435bf39804951c1c3e6edbc29428d4c52fad --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a8/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a8-py3-none-any.whl","digest":{"sha256":"04e1dced69c983949047a15d6cc609126cbd1ed4eaa801b786d9b40e68d76885"}},{"name":"./aws_lambda_powertools-3.2.1a8.tar.gz","digest":{"sha256":"dc1085755a2bcf8646f302ad7cab18f02eb45e859d8f79938c7b603bcf3eedb9"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5977673e1b243b9a26871f5e1da0e28144b3152f"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":395,"forks_count":395,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":104,"open_issues_count":104,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-03T10:04:16Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":60935,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2875,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-04T01:54:55Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2875,"watchers_count":2875,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11660188399","github_run_number":"101","github_sha1":"5977673e1b243b9a26871f5e1da0e28144b3152f"}},"metadata":{"buildInvocationID":"11660188399-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5977673e1b243b9a26871f5e1da0e28144b3152f"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQCBs2uRBVXLoAMdY2OyslmcPq6DdGFhaKbxeD929HyEfwIhAJLuXN1nJR4tTpwoD6WvfJX5cCelL9ShDPBzObyzK7vU","cert":"-----BEGIN CERTIFICATE-----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\n+kCeyLCLy6aklI2mdjjQfwvgFlBJXvTUrxU=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a9/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a9/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..c2a0ce4ac9369c86e1f8e8fcb83436e5476ce244 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.2.1a9/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.2.1a9-py3-none-any.whl","digest":{"sha256":"9881235570fddcdc52681dd8fca3246b47a67cbc0c600a5731631e3da360446f"}},{"name":"./aws_lambda_powertools-3.2.1a9.tar.gz","digest":{"sha256":"07b6e36a45cae1e218f579b65ea6c070e5ca89116ec74ad7b2e91201becb4d48"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"e27e1f182d8428bf149bb79cc795a5ac40ff4b4d"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":395,"forks_count":395,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":104,"open_issues_count":104,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-04T20:47:19Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":61653,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2876,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-04T18:28:02Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2876,"watchers_count":2876,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11679889345","github_run_number":"102","github_sha1":"e27e1f182d8428bf149bb79cc795a5ac40ff4b4d"}},"metadata":{"buildInvocationID":"11679889345-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"e27e1f182d8428bf149bb79cc795a5ac40ff4b4d"}}]}}","signatures":[{"keyid":"","sig":"MEUCIF4MSJAJTHMHBTkkT/cZ1Z6MqHSjtkHSvI0SPtFpAZZ1AiEAxlMAKxZsGjZ8QhKFXcPfZBxfvexG6sct9AXB11paIMk=","cert":"-----BEGIN CERTIFICATE-----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\negrIKe2K5eQyMxUTTJD4j2as5ZQha+JRH7o=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a0/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a0/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..ee41f5e3c4454b0a39fe2ef1493987733d2acf29 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a0/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.3.1a0-py3-none-any.whl","digest":{"sha256":"63e7b9e407671cd21394c907098de10daabc5f5a65b9079856d1b41ea2f67d58"}},{"name":"./aws_lambda_powertools-3.3.1a0.tar.gz","digest":{"sha256":"439c5bb134c80a56037a87a23ae61a743f091f909ed863c0b832ebf51c222725"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"f22e7c6e075d3ecb5e536a1a0416eea5bf865580"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":397,"forks_count":397,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":94,"open_issues_count":94,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-14T20:42:41Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":62714,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2886,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-14T20:44:06Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2886,"watchers_count":2886,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11852475785","github_run_number":"110","github_sha1":"f22e7c6e075d3ecb5e536a1a0416eea5bf865580"}},"metadata":{"buildInvocationID":"11852475785-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"f22e7c6e075d3ecb5e536a1a0416eea5bf865580"}}]}}","signatures":[{"keyid":"","sig":"MEQCIC+XQx9Ylu99DnpWKvdhmqF79bGCq6vOL0Mbqn3BXh7KAiA4IKsJDzLTsukDEc5OYh4MuUFdMEj0wnKof6mb2C6jjA==","cert":"-----BEGIN CERTIFICATE-----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\nNdaVlPkLlJL5v4FFo4ZJIm6KBWjFte3/cnVMBQ==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a1/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a1/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..99ef3c63cf4c331456379ec7caa8b6b3a3129e76 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a1/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.3.1a1-py3-none-any.whl","digest":{"sha256":"df0380249ea0c277832110ab27631c2ed0ae1284fb90f718bcd9a27c05fb5c25"}},{"name":"./aws_lambda_powertools-3.3.1a1.tar.gz","digest":{"sha256":"ce882dc1489f6193da22dae4c7f422cb55dc1cf17ae5e1923dd1f92a11559d9c"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"f3c3b8e1a2d5c2e69ae97861cfcf1f7a385cbb52"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":398,"forks_count":398,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":101,"open_issues_count":101,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-17T10:03:54Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":62758,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2889,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-18T07:07:17Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2889,"watchers_count":2889,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11888143908","github_run_number":"111","github_sha1":"f3c3b8e1a2d5c2e69ae97861cfcf1f7a385cbb52"}},"metadata":{"buildInvocationID":"11888143908-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"f3c3b8e1a2d5c2e69ae97861cfcf1f7a385cbb52"}}]}}","signatures":[{"keyid":"","sig":"MEUCIE1maD0SXqut3Hi35PUAt128r3GQ/8i6DrYEVUm+vJk/AiEAgk9Sq56mk6Dyu7HEbmDqLM6NE1Qeq5PVV4SwMuHKHbs=","cert":"-----BEGIN CERTIFICATE-----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\nkWXOfmRlN9HGoFghyDwWlmRuywpCKvw0ROlf\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a2/multiple.intoto.jsonl b/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a2/multiple.intoto.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..1fee67e1485502704b4f62626ab50f929795e5d1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/provenance/3.3.1a2/multiple.intoto.jsonl @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"./aws_lambda_powertools-3.3.1a2-py3-none-any.whl","digest":{"sha256":"9bbd9f99f0308c2b4b7438086b178299843c404840691bac02e3e2af26db9170"}},{"name":"./aws_lambda_powertools-3.3.1a2.tar.gz","digest":{"sha256":"ff2b35109c502d95f8e76de2a0b7109da15124cf2d6dfead46bca5915d6c7bac"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v2.0.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5426a7abb2272f480641e8b30b2a23e558152ee5"},"entryPoint":".github/workflows/pre-release.yml"},"parameters":{},"environment":{"github_actor":"leandrodamascena","github_actor_id":"4295173","github_base_ref":"","github_event_name":"schedule","github_event_payload":{"enterprise":{"avatar_url":"https://avatars.githubusercontent.com/b/1290?v=4","created_at":"2019-11-13T18:05:41Z","description":"","html_url":"https://github.com/enterprises/amazon","id":1290,"name":"Amazon","node_id":"MDEwOkVudGVycHJpc2UxMjkw","slug":"amazon","updated_at":"2024-09-30T21:02:30Z","website_url":"https://www.amazon.com/"},"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","description":"","events_url":"https://api.github.com/orgs/aws-powertools/events","hooks_url":"https://api.github.com/orgs/aws-powertools/hooks","id":129127638,"issues_url":"https://api.github.com/orgs/aws-powertools/issues","login":"aws-powertools","members_url":"https://api.github.com/orgs/aws-powertools/members{/member}","node_id":"O_kgDOB7JU1g","public_members_url":"https://api.github.com/orgs/aws-powertools/public_members{/member}","repos_url":"https://api.github.com/orgs/aws-powertools/repos","url":"https://api.github.com/orgs/aws-powertools"},"repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/assignees{/user}","blobs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/blobs{/sha}","branches_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/branches{/branch}","clone_url":"https://github.com/aws-powertools/powertools-lambda-python.git","collaborators_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/comments{/number}","commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/commits{/sha}","compare_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/compare/{base}...{head}","contents_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contents/{+path}","contributors_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/contributors","created_at":"2019-11-15T12:26:12Z","custom_properties":{},"default_branch":"develop","deployments_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/deployments","description":"A developer toolkit to implement Serverless best practices and increase developer velocity.","disabled":false,"downloads_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/downloads","events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/events","fork":false,"forks":398,"forks_count":398,"forks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/forks","full_name":"aws-powertools/powertools-lambda-python","git_commits_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/tags{/sha}","git_url":"git://github.com/aws-powertools/powertools-lambda-python.git","has_discussions":true,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":false,"homepage":"https://docs.powertools.aws.dev/lambda/python/latest/","hooks_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/hooks","html_url":"https://github.com/aws-powertools/powertools-lambda-python","id":221919379,"is_template":false,"issue_comment_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues/events{/number}","issues_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/issues{/number}","keys_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/keys{/key_id}","labels_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/labels{/name}","language":"Python","languages_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/languages","license":{"key":"mit-0","name":"MIT No Attribution","node_id":"MDc6TGljZW5zZTQx","spdx_id":"MIT-0","url":"https://api.github.com/licenses/mit-0"},"merges_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/merges","milestones_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/milestones{/number}","mirror_url":null,"name":"powertools-lambda-python","node_id":"MDEwOlJlcG9zaXRvcnkyMjE5MTkzNzk=","notifications_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/notifications{?since,all,participating}","open_issues":94,"open_issues_count":94,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/129127638?v=4","events_url":"https://api.github.com/users/aws-powertools/events{/privacy}","followers_url":"https://api.github.com/users/aws-powertools/followers","following_url":"https://api.github.com/users/aws-powertools/following{/other_user}","gists_url":"https://api.github.com/users/aws-powertools/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/aws-powertools","id":129127638,"login":"aws-powertools","node_id":"O_kgDOB7JU1g","organizations_url":"https://api.github.com/users/aws-powertools/orgs","received_events_url":"https://api.github.com/users/aws-powertools/received_events","repos_url":"https://api.github.com/users/aws-powertools/repos","site_admin":false,"starred_url":"https://api.github.com/users/aws-powertools/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/aws-powertools/subscriptions","type":"Organization","url":"https://api.github.com/users/aws-powertools","user_view_type":"public"},"private":false,"pulls_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/pulls{/number}","pushed_at":"2024-11-18T20:50:41Z","releases_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/releases{/id}","size":61131,"ssh_url":"git@github.com:aws-powertools/powertools-lambda-python.git","stargazers_count":2890,"stargazers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/stargazers","statuses_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/statuses/{sha}","subscribers_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscribers","subscription_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/subscription","svn_url":"https://github.com/aws-powertools/powertools-lambda-python","tags_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/tags","teams_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/teams","topics":["aws","aws-lambda","hacktoberfest","lambda","python","serverless"],"trees_url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python/git/trees{/sha}","updated_at":"2024-11-18T18:33:42Z","url":"https://api.github.com/repos/aws-powertools/powertools-lambda-python","visibility":"public","watchers":2890,"watchers_count":2890,"web_commit_signoff_required":true},"schedule":"0 8 * * 1-5","workflow":".github/workflows/pre-release.yml"},"github_head_ref":"","github_ref":"refs/heads/develop","github_ref_type":"branch","github_repository_id":"221919379","github_repository_owner":"aws-powertools","github_repository_owner_id":"129127638","github_run_attempt":"1","github_run_id":"11908642753","github_run_number":"112","github_sha1":"5426a7abb2272f480641e8b30b2a23e558152ee5"}},"metadata":{"buildInvocationID":"11908642753-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/aws-powertools/powertools-lambda-python@refs/heads/develop","digest":{"sha1":"5426a7abb2272f480641e8b30b2a23e558152ee5"}}]}}","signatures":[{"keyid":"","sig":"MEYCIQDdeI5RYWA5PvQIU8l+Fqsf4Mj5a6eTfxovA17VTQ+C5AIhAKb4U0Xk94XxseOlcL63aD8CzqSDyKpvtL0ZermovwfP","cert":"-----BEGIN CERTIFICATE-----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\nPDlSpgKR8EeLECyGk9sIdIFFobO9tbK7Z0A=\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..f59eea9a33bac8428329230c0652a07cdb8b2c90 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/conftest.py @@ -0,0 +1,29 @@ +import pytest + +from tests.e2e.utils.infrastructure import call_once +from tests.e2e.utils.lambda_layer.powertools_layer import LocalLambdaPowertoolsLayer + + +@pytest.fixture(scope="session", autouse=True) +def lambda_layer_build(tmp_path_factory: pytest.TempPathFactory, worker_id: str) -> str: + """Build Lambda Layer once before stacks are created + + Parameters + ---------- + tmp_path_factory : pytest.TempPathFactory + pytest temporary path factory to discover shared tmp when multiple CPU processes are spun up + worker_id : str + pytest-xdist worker identification to detect whether parallelization is enabled + + Yields + ------ + str + Lambda Layer artefact location + """ + + layer = LocalLambdaPowertoolsLayer() + yield from call_once( + task=layer.build, + tmp_path_factory=tmp_path_factory, + worker_id=worker_id, + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..f1892d7c0c931cdc0b7d79d4eff1e76065460b7d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.data_masking.infrastructure import DataMaskingStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = DataMaskingStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/handlers/basic_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/handlers/basic_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..6f696391822be94ca16199bf8932da4c1c3a064d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/handlers/basic_handler.py @@ -0,0 +1,23 @@ +from aws_lambda_powertools import Logger +from aws_lambda_powertools.utilities.data_masking import DataMasking +from aws_lambda_powertools.utilities.data_masking.provider.kms.aws_encryption_sdk import AWSEncryptionSDKProvider + +logger = Logger() + + +@logger.inject_lambda_context +def lambda_handler(event, context): + # Generating logs for test_encryption_in_logs test + message, append_keys = event.get("message", ""), event.get("append_keys", {}) + logger.append_keys(**append_keys) + logger.info(message) + + # Encrypting data for test_encryption_in_handler test + kms_key = event.get("kms_key", "") + data_masker = DataMasking(provider=AWSEncryptionSDKProvider(keys=[kms_key])) + value = [1, 2, "string", 4.5] + encrypted_data = data_masker.encrypt(value) + response = {} + response["encrypted_data"] = encrypted_data + + return response diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..ee18b272450fd32cb0ae139fda97c78dee7b8f3f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/infrastructure.py @@ -0,0 +1,20 @@ +import aws_cdk.aws_kms as kms +from aws_cdk import CfnOutput, Duration +from aws_cdk import aws_iam as iam + +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class DataMaskingStack(BaseInfrastructure): + def create_resources(self): + functions = self.create_lambda_functions(function_props={"timeout": Duration.seconds(10)}) + + key1 = kms.Key(self.stack, "MyKMSKey1", description="My KMS Key1") + CfnOutput(self.stack, "KMSKey1Arn", value=key1.key_arn, description="ARN of the created KMS Key1") + + key2 = kms.Key(self.stack, "MyKMSKey2", description="My KMS Key2") + CfnOutput(self.stack, "KMSKey2Arn", value=key2.key_arn, description="ARN of the created KMS Key2") + + functions["BasicHandler"].add_to_role_policy( + iam.PolicyStatement(effect=iam.Effect.ALLOW, actions=["kms:*"], resources=[key1.key_arn, key2.key_arn]), + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/test_e2e_data_masking.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/test_e2e_data_masking.py new file mode 100644 index 0000000000000000000000000000000000000000..3ee2400b5cc078e8f417013a4a4c1b4f4b99ddb6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/data_masking/test_e2e_data_masking.py @@ -0,0 +1,157 @@ +import json +from uuid import uuid4 + +import pytest + +from aws_lambda_powertools.utilities.data_masking import DataMasking +from aws_lambda_powertools.utilities.data_masking.exceptions import ( + DataMaskingContextMismatchError, + DataMaskingDecryptKeyError, +) +from aws_lambda_powertools.utilities.data_masking.provider.kms.aws_encryption_sdk import ( + AWSEncryptionSDKProvider, +) +from tests.e2e.utils import data_fetcher + + +@pytest.fixture +def security_context(): + return {"this": "is_secure"} + + +@pytest.fixture +def basic_handler_fn(infrastructure: dict) -> str: + return infrastructure.get("BasicHandler", "") + + +@pytest.fixture +def basic_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("BasicHandlerArn", "") + + +@pytest.fixture +def kms_key1_arn(infrastructure: dict) -> str: + return infrastructure.get("KMSKey1Arn", "") + + +@pytest.fixture +def kms_key2_arn(infrastructure: dict) -> str: + return infrastructure.get("KMSKey2Arn", "") + + +@pytest.fixture +def data_masker(kms_key1_arn) -> DataMasking: + return DataMasking(provider=AWSEncryptionSDKProvider(keys=[kms_key1_arn])) + + +@pytest.mark.xdist_group(name="data_masking") +def test_encryption(data_masker): + # GIVEN an instantiation of DataMasking with the AWS encryption provider + + # AWS Encryption SDK encrypt method only takes in bytes or strings + value = [1, 2, "string", 4.5] + + # WHEN encrypting and then decrypting the encrypted data + encrypted_data = data_masker.encrypt(value) + decrypted_data = data_masker.decrypt(encrypted_data) + + # THEN the result is the original input data + assert decrypted_data == value + + +@pytest.mark.xdist_group(name="data_masking") +def test_encryption_context(data_masker, security_context): + # GIVEN an instantiation of DataMasking with the AWS encryption provider + + value = [1, 2, "string", 4.5] + + # WHEN encrypting and then decrypting the encrypted data with an encryption_context + encrypted_data = data_masker.encrypt(value, **security_context) + decrypted_data = data_masker.decrypt(encrypted_data, **security_context) + + # THEN the result is the original input data + assert decrypted_data == value + + +@pytest.mark.xdist_group(name="data_masking") +def test_encryption_context_mismatch(data_masker, security_context): + # GIVEN an instantiation of DataMasking with the AWS encryption provider + + value = [1, 2, "string", 4.5] + + # WHEN encrypting with a encryption_context + encrypted_data = data_masker.encrypt(value, **security_context) + + # THEN decrypting with a different encryption_context should raise a ContextMismatchError + with pytest.raises(DataMaskingContextMismatchError): + data_masker.decrypt(encrypted_data, this="different_context") + + +@pytest.mark.xdist_group(name="data_masking") +def test_encryption_no_context_fail(data_masker, security_context): + # GIVEN an instantiation of DataMasking with the AWS encryption provider + + value = [1, 2, "string", 4.5] + + # WHEN encrypting with no encryption_context + encrypted_data = data_masker.encrypt(value) + + # THEN decrypting with an encryption_context should raise a ContextMismatchError + with pytest.raises(DataMaskingContextMismatchError): + data_masker.decrypt(encrypted_data, **security_context) + + +@pytest.mark.xdist_group(name="data_masking") +def test_encryption_decryption_key_mismatch(data_masker, kms_key2_arn): + # GIVEN an instantiation of DataMasking with the AWS encryption provider with a certain key + + # WHEN encrypting and then decrypting the encrypted data + value = [1, 2, "string", 4.5] + encrypted_data = data_masker.encrypt(value) + + # THEN when decrypting with a different key it should fail + data_masker_key2 = DataMasking(provider=AWSEncryptionSDKProvider(keys=[kms_key2_arn])) + + with pytest.raises(DataMaskingDecryptKeyError): + data_masker_key2.decrypt(encrypted_data) + + +@pytest.mark.xdist_group(name="data_masking") +def test_encryption_in_logs(data_masker, basic_handler_fn, basic_handler_fn_arn, kms_key1_arn): + # GIVEN an instantiation of DataMasking with the AWS encryption provider + + # WHEN encrypting a value and logging it + value = [1, 2, "string", 4.5] + encrypted_data = data_masker.encrypt(value) + message = encrypted_data + custom_key = "order_id" + additional_keys = {custom_key: f"{uuid4()}"} + payload = json.dumps({"message": message, "kms_key": kms_key1_arn, "append_keys": additional_keys}) + + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=basic_handler_fn_arn, payload=payload) + data_fetcher.get_lambda_response(lambda_arn=basic_handler_fn_arn, payload=payload) + + logs = data_fetcher.get_logs(function_name=basic_handler_fn, start_time=execution_time, minimum_log_entries=2) + + # THEN decrypting it from the logs should show the original value + for log in logs.get_log(key=custom_key): + encrypted_data = log.message + decrypted_data = data_masker.decrypt(encrypted_data) + assert decrypted_data == value + + +@pytest.mark.xdist_group(name="data_masking") +def test_encryption_in_handler(data_masker, basic_handler_fn_arn, kms_key1_arn): + # GIVEN a lambda_handler with an instantiation the AWS encryption provider data masker + + payload = {"kms_key": kms_key1_arn} + + # WHEN the handler is invoked to encrypt data + handler_result, _ = data_fetcher.get_lambda_response(lambda_arn=basic_handler_fn_arn, payload=json.dumps(payload)) + + response = json.loads(handler_result["Payload"].read()) + encrypted_data = response["encrypted_data"] + decrypted_data = data_masker.decrypt(encrypted_data) + + # THEN decrypting the encrypted data from the response should result in the original value + assert decrypted_data == [1, 2, "string", 4.5] diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..664c870e1de854c7f5b4f3b23183386b64048a9b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.event_handler.infrastructure import EventHandlerStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = EventHandlerStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/alb_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/alb_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..ef1af1792ac4c4d2dce0a61f4e845b273216485e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/alb_handler.py @@ -0,0 +1,35 @@ +from aws_lambda_powertools.event_handler import ( + ALBResolver, + CORSConfig, + Response, + content_types, +) + +cors_config = CORSConfig(allow_origin="https://www.example.org", extra_origins=["https://dev.example.org"]) +app = ALBResolver(cors=cors_config) + +# The reason we use post is that whoever is writing tests can easily assert on the +# content being sent (body, headers, cookies, content-type) to reduce cognitive load. + + +@app.post("/todos") +def todos(): + payload = app.current_event.json_body + + body = payload.get("body", "Hello World") + status_code = payload.get("status_code", 200) + headers = payload.get("headers", {}) + cookies = payload.get("cookies", []) + content_type = headers.get("Content-Type", content_types.TEXT_PLAIN) + + return Response( + status_code=status_code, + content_type=content_type, + body=body, + cookies=cookies, + headers=headers, + ) + + +def lambda_handler(event, context): + return app.resolve(event, context) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/alb_handler_with_body_none.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/alb_handler_with_body_none.py new file mode 100644 index 0000000000000000000000000000000000000000..ec72bfbd5f7aae8e248f12adc3a864a347147c5b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/alb_handler_with_body_none.py @@ -0,0 +1,17 @@ +from aws_lambda_powertools.event_handler import ( + ALBResolver, + Response, +) + +app = ALBResolver() + + +@app.get("/todos_with_no_body") +def todos(): + return Response( + status_code=200, + ) + + +def lambda_handler(event, context): + return app.resolve(event, context) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/api_gateway_http_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/api_gateway_http_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..876d78ef67b31ab4e30c52dc5eeb3bb3a8045bbc --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/api_gateway_http_handler.py @@ -0,0 +1,35 @@ +from aws_lambda_powertools.event_handler import ( + APIGatewayHttpResolver, + CORSConfig, + Response, + content_types, +) + +cors_config = CORSConfig(allow_origin="https://www.example.org", extra_origins=["https://dev.example.org"]) +app = APIGatewayHttpResolver(cors=cors_config) + +# The reason we use post is that whoever is writing tests can easily assert on the +# content being sent (body, headers, cookies, content-type) to reduce cognitive load. + + +@app.post("/todos") +def todos(): + payload = app.current_event.json_body + + body = payload.get("body", "Hello World") + status_code = payload.get("status_code", 200) + headers = payload.get("headers", {}) + cookies = payload.get("cookies", []) + content_type = headers.get("Content-Type", content_types.TEXT_PLAIN) + + return Response( + status_code=status_code, + content_type=content_type, + body=body, + cookies=cookies, + headers=headers, + ) + + +def lambda_handler(event, context): + return app.resolve(event, context) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/api_gateway_rest_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/api_gateway_rest_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..d09bf6b82c95bca71b4a6a5bda52106ebe706792 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/api_gateway_rest_handler.py @@ -0,0 +1,35 @@ +from aws_lambda_powertools.event_handler import ( + APIGatewayRestResolver, + CORSConfig, + Response, + content_types, +) + +cors_config = CORSConfig(allow_origin="https://www.example.org", extra_origins=["https://dev.example.org"]) +app = APIGatewayRestResolver(cors=cors_config) + +# The reason we use post is that whoever is writing tests can easily assert on the +# content being sent (body, headers, cookies, content-type) to reduce cognitive load. + + +@app.post("/todos") +def todos(): + payload = app.current_event.json_body + + body = payload.get("body", "Hello World") + status_code = payload.get("status_code", 200) + headers = payload.get("headers", {}) + cookies = payload.get("cookies", []) + content_type = headers.get("Content-Type", content_types.TEXT_PLAIN) + + return Response( + status_code=status_code, + content_type=content_type, + body=body, + cookies=cookies, + headers=headers, + ) + + +def lambda_handler(event, context): + return app.resolve(event, context) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/lambda_function_url_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/lambda_function_url_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..e47035a971db49d06c4e83face6bcd52c37888ee --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/lambda_function_url_handler.py @@ -0,0 +1,35 @@ +from aws_lambda_powertools.event_handler import ( + CORSConfig, + LambdaFunctionUrlResolver, + Response, + content_types, +) + +cors_config = CORSConfig(allow_origin="https://www.example.org", extra_origins=["https://dev.example.org"]) +app = LambdaFunctionUrlResolver(cors=cors_config) + +# The reason we use post is that whoever is writing tests can easily assert on the +# content being sent (body, headers, cookies, content-type) to reduce cognitive load. + + +@app.post("/todos") +def todos(): + payload = app.current_event.json_body + + body = payload.get("body", "Hello World") + status_code = payload.get("status_code", 200) + headers = payload.get("headers", {}) + cookies = payload.get("cookies", []) + content_type = headers.get("Content-Type", content_types.TEXT_PLAIN) + + return Response( + status_code=status_code, + content_type=content_type, + body=body, + cookies=cookies, + headers=headers, + ) + + +def lambda_handler(event, context): + return app.resolve(event, context) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/openapi_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/openapi_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..13cfb69f0168d34c976012ede3605d5cc4079741 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/handlers/openapi_handler.py @@ -0,0 +1,19 @@ +from aws_lambda_powertools.event_handler import ( + APIGatewayRestResolver, +) + +app = APIGatewayRestResolver(enable_validation=True) + + +@app.get("/openapi_schema") +def openapi_schema(): + return app.get_openapi_json_schema( + title="Powertools e2e API", + version="1.0.0", + description="This is a sample Powertools e2e API", + openapi_extensions={"x-amazon-apigateway-gateway-responses": {"DEFAULT_4XX"}}, + ) + + +def lambda_handler(event, context): + return app.resolve(event, context) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..9d7dbc46c402bf48714f7894277eabdd4ccb5177 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/infrastructure.py @@ -0,0 +1,100 @@ +from typing import Dict, List, Optional + +from aws_cdk import CfnOutput, Duration +from aws_cdk import aws_apigateway as apigwv1 +from aws_cdk import aws_apigatewayv2_alpha as apigwv2 +from aws_cdk import aws_apigatewayv2_authorizers_alpha as apigwv2authorizers +from aws_cdk import aws_apigatewayv2_integrations_alpha as apigwv2integrations +from aws_cdk import aws_ec2 as ec2 +from aws_cdk import aws_elasticloadbalancingv2 as elbv2 +from aws_cdk import aws_elasticloadbalancingv2_targets as targets +from aws_cdk.aws_lambda import Function, FunctionUrlAuthType + +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class EventHandlerStack(BaseInfrastructure): + def create_resources(self): + functions = self.create_lambda_functions(function_props={"timeout": Duration.seconds(10)}) + + self._create_alb(function=[functions["AlbHandler"], functions["AlbHandlerWithBodyNone"]]) + self._create_api_gateway_rest(function=[functions["ApiGatewayRestHandler"], functions["OpenapiHandler"]]) + self._create_api_gateway_http(function=functions["ApiGatewayHttpHandler"]) + self._create_lambda_function_url(function=functions["LambdaFunctionUrlHandler"]) + + def _create_alb(self, function: List[Function]): + vpc = ec2.Vpc.from_lookup( + self.stack, + "VPC", + is_default=True, + region=self.region, + ) + + alb = elbv2.ApplicationLoadBalancer(self.stack, "ALB", vpc=vpc, internet_facing=True) + CfnOutput(self.stack, "ALBDnsName", value=alb.load_balancer_dns_name) + + # Function with Body + self._create_alb_listener(alb=alb, name="Basic", port=80, function=function[0]) + self._create_alb_listener( + alb=alb, + name="MultiValueHeader", + port=8080, + function=function[0], + attributes={"lambda.multi_value_headers.enabled": "true"}, + ) + + # Function without Body + self._create_alb_listener(alb=alb, name="BasicWithoutBody", port=8081, function=function[1]) + + def _create_alb_listener( + self, + alb: elbv2.ApplicationLoadBalancer, + name: str, + port: int, + function: Function, + attributes: Optional[Dict[str, str]] = None, + ): + listener = alb.add_listener(name, port=port, protocol=elbv2.ApplicationProtocol.HTTP) + target = listener.add_targets(f"ALB{name}Target", targets=[targets.LambdaTarget(function)]) + if attributes is not None: + for key, value in attributes.items(): + target.set_attribute(key, value) + CfnOutput(self.stack, f"ALB{name}ListenerPort", value=str(port)) + + def _create_api_gateway_http(self, function: Function): + apigw = apigwv2.HttpApi( + self.stack, + "APIGatewayHTTP", + create_default_stage=True, + default_authorizer=apigwv2authorizers.HttpIamAuthorizer(), + ) + apigw.add_routes( + path="/todos", + methods=[apigwv2.HttpMethod.POST], + integration=apigwv2integrations.HttpLambdaIntegration("TodosIntegration", function), + ) + + CfnOutput(self.stack, "APIGatewayHTTPUrl", value=(apigw.url or "")) + + def _create_api_gateway_rest(self, function: List[Function]): + apigw = apigwv1.RestApi( + self.stack, + "APIGatewayRest", + deploy_options=apigwv1.StageOptions(stage_name="dev"), + # disables creation of a role that is not destroyed due to a breaking change in CDK + # https://github.com/aws/aws-cdk/issues/22020 + cloud_watch_role=False, + ) + + todos = apigw.root.add_resource("todos") + todos.add_method("POST", apigwv1.LambdaIntegration(function[0], proxy=True)) + + openapi_schema = apigw.root.add_resource("openapi_schema") + openapi_schema.add_method("GET", apigwv1.LambdaIntegration(function[1], proxy=True)) + + CfnOutput(self.stack, "APIGatewayRestUrl", value=apigw.url) + + def _create_lambda_function_url(self, function: Function): + # Maintenance: move auth to IAM when we create sigv4 builders + function_url = function.add_function_url(auth_type=FunctionUrlAuthType.AWS_IAM) + CfnOutput(self.stack, "LambdaFunctionUrl", value=function_url.url) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_cors.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_cors.py new file mode 100644 index 0000000000000000000000000000000000000000..921a227e94471031e4a52c4042d52504ff7f9cd0 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_cors.py @@ -0,0 +1,252 @@ +import pytest +from requests import Request + +from tests.e2e.utils import data_fetcher +from tests.e2e.utils.auth import build_iam_auth + + +@pytest.fixture +def alb_basic_listener_endpoint(infrastructure: dict) -> str: + dns_name = infrastructure.get("ALBDnsName") + port = infrastructure.get("ALBBasicListenerPort", "") + return f"http://{dns_name}:{port}" + + +@pytest.fixture +def apigw_http_endpoint(infrastructure: dict) -> str: + return infrastructure.get("APIGatewayHTTPUrl", "") + + +@pytest.fixture +def apigw_rest_endpoint(infrastructure: dict) -> str: + return infrastructure.get("APIGatewayRestUrl", "") + + +@pytest.fixture +def lambda_function_url_endpoint(infrastructure: dict) -> str: + return infrastructure.get("LambdaFunctionUrl", "") + + +@pytest.mark.xdist_group(name="event_handler") +def test_alb_cors_with_correct_origin(alb_basic_listener_endpoint): + # GIVEN + url = f"{alb_basic_listener_endpoint}/todos" + headers = {"Origin": "https://www.example.org"} + + # WHEN + response = data_fetcher.get_http_response(Request(method="POST", url=url, headers=headers, json={})) + + # THEN response has CORS headers + assert response.headers["Access-Control-Allow-Origin"] == "https://www.example.org" + + +@pytest.mark.xdist_group(name="event_handler") +def test_alb_cors_with_correct_alternative_origin(alb_basic_listener_endpoint): + # GIVEN + url = f"{alb_basic_listener_endpoint}/todos" + headers = {"Origin": "https://dev.example.org"} + + # WHEN + response = data_fetcher.get_http_response(Request(method="POST", url=url, headers=headers, json={})) + + # THEN response has CORS headers + assert response.headers["Access-Control-Allow-Origin"] == "https://dev.example.org" + + +@pytest.mark.xdist_group(name="event_handler") +def test_alb_cors_with_unknown_origin(alb_basic_listener_endpoint): + # GIVEN + url = f"{alb_basic_listener_endpoint}/todos" + headers = {"Origin": "https://www.google.com"} + + # WHEN + response = data_fetcher.get_http_response(Request(method="POST", url=url, headers=headers, json={})) + + # THEN response does NOT have CORS headers + assert "Access-Control-Allow-Origin" not in response.headers + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_http_cors_with_correct_origin(apigw_http_endpoint): + # GIVEN + url = f"{apigw_http_endpoint}todos" + headers = {"Origin": "https://www.example.org"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + auth=build_iam_auth(url=url, aws_service="execute-api"), + ), + ) + + # THEN response has CORS headers + assert response.headers["Access-Control-Allow-Origin"] == "https://www.example.org" + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_http_cors_with_correct_alternative_origin(apigw_http_endpoint): + # GIVEN + url = f"{apigw_http_endpoint}todos" + headers = {"Origin": "https://dev.example.org"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + auth=build_iam_auth(url=url, aws_service="execute-api"), + ), + ) + + # THEN response has CORS headers + assert response.headers["Access-Control-Allow-Origin"] == "https://dev.example.org" + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_http_cors_with_unknown_origin(apigw_http_endpoint): + # GIVEN + url = f"{apigw_http_endpoint}todos" + headers = {"Origin": "https://www.google.com"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + auth=build_iam_auth(url=url, aws_service="execute-api"), + ), + ) + + # THEN response does NOT have CORS headers + assert "Access-Control-Allow-Origin" not in response.headers + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_rest_cors_with_correct_origin(apigw_rest_endpoint): + # GIVEN + url = f"{apigw_rest_endpoint}todos" + headers = {"Origin": "https://www.example.org"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + ), + ) + + # THEN response has CORS headers + assert response.headers["Access-Control-Allow-Origin"] == "https://www.example.org" + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_rest_cors_with_correct_alternative_origin(apigw_rest_endpoint): + # GIVEN + url = f"{apigw_rest_endpoint}todos" + headers = {"Origin": "https://dev.example.org"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + ), + ) + + # THEN response has CORS headers + assert response.headers["Access-Control-Allow-Origin"] == "https://dev.example.org" + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_rest_cors_with_unknown_origin(apigw_rest_endpoint): + # GIVEN + url = f"{apigw_rest_endpoint}todos" + headers = {"Origin": "https://www.google.com"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + ), + ) + + # THEN response does NOT have CORS headers + assert "Access-Control-Allow-Origin" not in response.headers + + +@pytest.mark.xdist_group(name="event_handler") +def test_lambda_function_url_cors_with_correct_origin(lambda_function_url_endpoint): + # GIVEN + url = f"{lambda_function_url_endpoint}todos" + headers = {"Origin": "https://www.example.org"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) + + # THEN response has CORS headers + assert response.headers["Access-Control-Allow-Origin"] == "https://www.example.org" + + +@pytest.mark.xdist_group(name="event_handler") +def test_lambda_function_url_cors_with_correct_alternative_origin(lambda_function_url_endpoint): + # GIVEN + url = f"{lambda_function_url_endpoint}todos" + headers = {"Origin": "https://dev.example.org"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) + + # THEN response has CORS headers + assert response.headers["Access-Control-Allow-Origin"] == "https://dev.example.org" + + +@pytest.mark.xdist_group(name="event_handler") +def test_lambda_function_url_cors_with_unknown_origin(lambda_function_url_endpoint): + # GIVEN + url = f"{lambda_function_url_endpoint}todos" + headers = {"Origin": "https://www.google.com"} + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + headers=headers, + json={}, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) + + # THEN response does NOT have CORS headers + assert "Access-Control-Allow-Origin" not in response.headers diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_header_serializer.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_header_serializer.py new file mode 100644 index 0000000000000000000000000000000000000000..6eb9c6d0fd77d2f98dd6c107fc203f06032753b8 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_header_serializer.py @@ -0,0 +1,225 @@ +from uuid import uuid4 + +import pytest +from requests import Request + +from aws_lambda_powertools.shared.cookies import Cookie +from tests.e2e.utils import data_fetcher +from tests.e2e.utils.auth import build_iam_auth + + +@pytest.fixture +def alb_basic_listener_endpoint(infrastructure: dict) -> str: + dns_name = infrastructure.get("ALBDnsName") + port = infrastructure.get("ALBBasicListenerPort", "") + return f"http://{dns_name}:{port}" + + +@pytest.fixture +def alb_multi_value_header_listener_endpoint(infrastructure: dict) -> str: + dns_name = infrastructure.get("ALBDnsName") + port = infrastructure.get("ALBMultiValueHeaderListenerPort", "") + return f"http://{dns_name}:{port}" + + +@pytest.fixture +def apigw_rest_endpoint(infrastructure: dict) -> str: + return infrastructure.get("APIGatewayRestUrl", "") + + +@pytest.fixture +def apigw_http_endpoint(infrastructure: dict) -> str: + return infrastructure.get("APIGatewayHTTPUrl", "") + + +@pytest.fixture +def lambda_function_url_endpoint(infrastructure: dict) -> str: + return infrastructure.get("LambdaFunctionUrl", "") + + +@pytest.mark.xdist_group(name="event_handler") +def test_alb_headers_serializer(alb_basic_listener_endpoint): + # GIVEN + url = f"{alb_basic_listener_endpoint}/todos" + body = "Hello World" + status_code = 200 + headers = {"Content-Type": "text/plain", "Vary": ["Accept-Encoding", "User-Agent"]} + cookies = [ + Cookie(name="session_id", value=str(uuid4()), secure=True, http_only=True), + Cookie(name="ab_experiment", value="3"), + ] + last_cookie = cookies[-1] + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body, "status_code": status_code, "headers": headers, "cookies": list(map(str, cookies))}, + ), + ) + + # THEN + assert response.status_code == status_code + # response.content is a binary string, needs to be decoded to compare with the real string + assert response.content.decode("ascii") == body + + # Only the last header should be set + for key, value in headers.items(): + assert key in response.headers + new_value = value if isinstance(value, str) else sorted(value)[-1] + assert response.headers[key] == new_value + + # Only the last cookie should be set + assert len(response.cookies.items()) == 1 + assert last_cookie.name in response.cookies + assert response.cookies.get(last_cookie.name) == last_cookie.value + + +@pytest.mark.xdist_group(name="event_handler") +def test_alb_multi_value_headers_serializer(alb_multi_value_header_listener_endpoint): + # GIVEN + url = f"{alb_multi_value_header_listener_endpoint}/todos" + body = "Hello World" + status_code = 200 + headers = {"Content-Type": "text/plain", "Vary": ["Accept-Encoding", "User-Agent"]} + cookies = [ + Cookie(name="session_id", value=str(uuid4()), secure=True, http_only=True), + Cookie(name="ab_experiment", value="3"), + ] + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body, "status_code": status_code, "headers": headers, "cookies": list(map(str, cookies))}, + ), + ) + + # THEN + assert response.status_code == status_code + # response.content is a binary string, needs to be decoded to compare with the real string + assert response.content.decode("ascii") == body + + for key, value in headers.items(): + assert key in response.headers + new_value = value if isinstance(value, str) else ", ".join(sorted(value)) + + # ALB sorts the header values randomly, so we have to re-order them for comparison here + returned_value = ", ".join(sorted(response.headers[key].split(", "))) + assert returned_value == new_value + + for cookie in cookies: + assert cookie.name in response.cookies + assert response.cookies.get(cookie.name) == cookie.value + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_rest_headers_serializer(apigw_rest_endpoint): + # GIVEN + url = f"{apigw_rest_endpoint}todos" + body = "Hello World" + status_code = 200 + headers = {"Content-Type": "text/plain", "Vary": ["Accept-Encoding", "User-Agent"]} + cookies = [ + Cookie(name="session_id", value=str(uuid4()), secure=True, http_only=True), + Cookie(name="ab_experiment", value="3"), + ] + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body, "status_code": status_code, "headers": headers, "cookies": list(map(str, cookies))}, + ), + ) + + # THEN + assert response.status_code == status_code + # response.content is a binary string, needs to be decoded to compare with the real string + assert response.content.decode("ascii") == body + + for key, value in headers.items(): + assert key in response.headers + new_value = value if isinstance(value, str) else ", ".join(sorted(value)) + assert response.headers[key] == new_value + + for cookie in cookies: + assert cookie.name in response.cookies + assert response.cookies.get(cookie.name) == cookie.value + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_http_headers_serializer(apigw_http_endpoint): + # GIVEN + url = f"{apigw_http_endpoint}todos" + body = "Hello World" + status_code = 200 + headers = {"Content-Type": "text/plain", "Vary": ["Accept-Encoding", "User-Agent"]} + cookies = [ + Cookie(name="session_id", value=str(uuid4()), secure=True, http_only=True), + Cookie(name="ab_experiment", value="3"), + ] + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body, "status_code": status_code, "headers": headers, "cookies": list(map(str, cookies))}, + auth=build_iam_auth(url=url, aws_service="execute-api"), + ), + ) + + # THEN + assert response.status_code == status_code + # response.content is a binary string, needs to be decoded to compare with the real string + assert response.content.decode("ascii") == body + + for key, value in headers.items(): + assert key in response.headers + new_value = value if isinstance(value, str) else ", ".join(sorted(value)) + assert response.headers[key] == new_value + + for cookie in cookies: + assert cookie.name in response.cookies + assert response.cookies.get(cookie.name) == cookie.value + + +@pytest.mark.xdist_group(name="event_handler") +def test_lambda_function_url_headers_serializer(lambda_function_url_endpoint): + # GIVEN + url = f"{lambda_function_url_endpoint}todos" # the function url endpoint already has the trailing / + body = "Hello World" + status_code = 200 + headers = {"Content-Type": "text/plain", "Vary": ["Accept-Encoding", "User-Agent"]} + cookies = [ + Cookie(name="session_id", value=str(uuid4()), secure=True, http_only=True), + Cookie(name="ab_experiment", value="3"), + ] + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body, "status_code": status_code, "headers": headers, "cookies": list(map(str, cookies))}, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) + + # THEN + assert response.status_code == status_code + # response.content is a binary string, needs to be decoded to compare with the real string + assert response.content.decode("ascii") == body + + for key, value in headers.items(): + assert key in response.headers + new_value = value if isinstance(value, str) else ", ".join(sorted(value)) + assert response.headers[key] == new_value + + for cookie in cookies: + assert cookie.name in response.cookies + assert response.cookies.get(cookie.name) == cookie.value diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_openapi.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_openapi.py new file mode 100644 index 0000000000000000000000000000000000000000..d69c3b142b278caa6bbb44dd9204830ee8c9d398 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_openapi.py @@ -0,0 +1,27 @@ +import pytest +from requests import Request + +from tests.e2e.utils import data_fetcher + + +@pytest.fixture +def apigw_rest_endpoint(infrastructure: dict) -> str: + return infrastructure.get("APIGatewayRestUrl", "") + + +@pytest.mark.xdist_group(name="event_handler") +def test_get_openapi_schema(apigw_rest_endpoint): + # GIVEN + url = f"{apigw_rest_endpoint}openapi_schema" + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="GET", + url=url, + ), + ) + + assert "Powertools e2e API" in response.text + assert "x-amazon-apigateway-gateway-responses" in response.text + assert response.status_code == 200 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_paths_ending_with_slash.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_paths_ending_with_slash.py new file mode 100644 index 0000000000000000000000000000000000000000..efbc02cf1aca96436653fbeff44891e49ae3ff89 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_paths_ending_with_slash.py @@ -0,0 +1,108 @@ +import pytest +from requests import HTTPError, Request + +from tests.e2e.utils import data_fetcher +from tests.e2e.utils.auth import build_iam_auth + + +@pytest.fixture +def alb_basic_listener_endpoint(infrastructure: dict) -> str: + dns_name = infrastructure.get("ALBDnsName") + port = infrastructure.get("ALBBasicListenerPort", "") + return f"http://{dns_name}:{port}" + + +@pytest.fixture +def alb_multi_value_header_listener_endpoint(infrastructure: dict) -> str: + dns_name = infrastructure.get("ALBDnsName") + port = infrastructure.get("ALBMultiValueHeaderListenerPort", "") + return f"http://{dns_name}:{port}" + + +@pytest.fixture +def apigw_rest_endpoint(infrastructure: dict) -> str: + return infrastructure.get("APIGatewayRestUrl", "") + + +@pytest.fixture +def apigw_http_endpoint(infrastructure: dict) -> str: + return infrastructure.get("APIGatewayHTTPUrl", "") + + +@pytest.fixture +def lambda_function_url_endpoint(infrastructure: dict) -> str: + return infrastructure.get("LambdaFunctionUrl", "") + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_rest_trailing_slash(apigw_rest_endpoint): + # GIVEN API URL ends in a trailing slash + url = f"{apigw_rest_endpoint}todos/" + body = "Hello World" + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body}, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) + + # THEN expect a HTTP 200 response + assert response.status_code == 200 + + +@pytest.mark.xdist_group(name="event_handler") +def test_api_gateway_http_trailing_slash(apigw_http_endpoint): + # GIVEN the URL for the API ends in a trailing slash API gateway should return a 404 + url = f"{apigw_http_endpoint}todos/" + body = "Hello World" + + # WHEN calling an invalid URL (with trailing slash) expect HTTPError exception from data_fetcher + with pytest.raises(HTTPError): + data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body}, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) + + +@pytest.mark.xdist_group(name="event_handler") +def test_lambda_function_url_trailing_slash(lambda_function_url_endpoint): + # GIVEN the URL for the API ends in a trailing slash it should behave as if there was not one + url = f"{lambda_function_url_endpoint}todos/" # the function url endpoint already has the trailing / + body = "Hello World" + + # WHEN calling an invalid URL (with trailing slash) expect HTTPError exception from data_fetcher + with pytest.raises(HTTPError): + data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body}, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) + + +@pytest.mark.xdist_group(name="event_handler") +def test_alb_url_trailing_slash(alb_multi_value_header_listener_endpoint): + # GIVEN url has a trailing slash - it should behave as if there was not one + url = f"{alb_multi_value_header_listener_endpoint}/todos/" + body = "Hello World" + + # WHEN calling an invalid URL (with trailing slash) expect HTTPError exception from data_fetcher + with pytest.raises(HTTPError): + data_fetcher.get_http_response( + Request( + method="POST", + url=url, + json={"body": body}, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_response_code.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_response_code.py new file mode 100644 index 0000000000000000000000000000000000000000..46bf8bcf1834e765bcc37c20a0477363412cc2e2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler/test_response_code.py @@ -0,0 +1,29 @@ +import pytest +from requests import Request + +from tests.e2e.utils import data_fetcher +from tests.e2e.utils.auth import build_iam_auth + + +@pytest.fixture +def alb_basic_without_body_listener_endpoint(infrastructure: dict) -> str: + dns_name = infrastructure.get("ALBDnsName") + port = infrastructure.get("ALBBasicWithoutBodyListenerPort", "") + return f"http://{dns_name}:{port}" + + +@pytest.mark.xdist_group(name="event_handler") +def test_alb_with_body_empty(alb_basic_without_body_listener_endpoint): + # GIVEN url has a trailing slash - it should behave as if there was not one + url = f"{alb_basic_without_body_listener_endpoint}/todos_with_no_body" + + # WHEN calling an invalid URL (with trailing slash) expect HTTPError exception from data_fetcher + response = data_fetcher.get_http_response( + Request( + method="GET", + url=url, + auth=build_iam_auth(url=url, aws_service="lambda"), + ), + ) + + assert response.status_code == 200 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..1f6d8c406de90dc7b487affe8f58b66e6243656e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.event_handler_appsync.infrastructure import EventHandlerAppSyncStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = EventHandlerAppSyncStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/files/schema.graphql b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/files/schema.graphql new file mode 100644 index 0000000000000000000000000000000000000000..9733ba2f666e0a8c9d35bd3509497137d52cb2f8 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/files/schema.graphql @@ -0,0 +1,22 @@ +schema { + query: Query +} + +type Query { + getPost(post_id:ID!): Post + allPosts: [Post] +} + +type Post { + post_id: ID! + author: String! + title: String + content: String + url: String + ups: Int + downs: Int + relatedPosts: [Post] + relatedPostsAsync: [Post] + relatedPostsAggregate: [Post] + relatedPostsAsyncAggregate: [Post] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/handlers/appsync_resolver_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/handlers/appsync_resolver_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..594290f478d76332833b91a5c9ca5a56da7b21fb --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/handlers/appsync_resolver_handler.py @@ -0,0 +1,114 @@ +from typing import List, Optional + +from pydantic import BaseModel + +from aws_lambda_powertools.event_handler import AppSyncResolver +from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent +from aws_lambda_powertools.utilities.typing import LambdaContext + +app = AppSyncResolver() + + +posts = { + "1": { + "post_id": "1", + "title": "First book", + "author": "Author1", + "url": "https://amazon.com/", + "content": "SAMPLE TEXT AUTHOR 1", + "ups": "100", + "downs": "10", + }, + "2": { + "post_id": "2", + "title": "Second book", + "author": "Author2", + "url": "https://amazon.com", + "content": "SAMPLE TEXT AUTHOR 2", + "ups": "100", + "downs": "10", + }, + "3": { + "post_id": "3", + "title": "Third book", + "author": "Author3", + "url": None, + "content": None, + "ups": None, + "downs": None, + }, + "4": { + "post_id": "4", + "title": "Fourth book", + "author": "Author4", + "url": "https://www.amazon.com/", + "content": "SAMPLE TEXT AUTHOR 4", + "ups": "1000", + "downs": "0", + }, + "5": { + "post_id": "5", + "title": "Fifth book", + "author": "Author5", + "url": "https://www.amazon.com/", + "content": "SAMPLE TEXT AUTHOR 5", + "ups": "50", + "downs": "0", + }, +} + +posts_related = { + "1": [posts["4"]], + "2": [posts["3"], posts["5"]], + "3": [posts["2"], posts["1"]], + "4": [posts["2"], posts["1"]], + "5": [], +} + + +class Post(BaseModel): + post_id: str + author: str + title: str + url: str + content: str + ups: str + downs: str + + +# PROCESSING SINGLE RESOLVERS +@app.resolver(type_name="Query", field_name="getPost") +def get_post(post_id: str = "") -> dict: + post = Post(**posts[post_id]).dict() + return post + + +@app.resolver(type_name="Query", field_name="allPosts") +def all_posts() -> List[dict]: + return list(posts.values()) + + +# PROCESSING BATCH WITHOUT AGGREGATION +@app.batch_resolver(type_name="Post", field_name="relatedPosts", aggregate=False) +def related_posts(event: AppSyncResolverEvent) -> Optional[list]: + return posts_related[event.source["post_id"]] if event.source else None + + +@app.async_batch_resolver(type_name="Post", field_name="relatedPostsAsync", aggregate=False) +async def related_posts_async(event: AppSyncResolverEvent) -> Optional[list]: + return posts_related[event.source["post_id"]] if event.source else None + + +# PROCESSING BATCH WITH AGGREGATION +@app.batch_resolver(type_name="Post", field_name="relatedPostsAggregate") +def related_posts_aggregate(event: List[AppSyncResolverEvent]) -> Optional[list]: + return [posts_related[record.source.get("post_id")] for record in event] + + +@app.async_batch_resolver(type_name="Post", field_name="relatedPostsAsyncAggregate") +async def related_posts_async_aggregate(event: List[AppSyncResolverEvent]) -> Optional[list]: + return [posts_related[record.source.get("post_id")] for record in event] + + +def lambda_handler(event, context: LambdaContext) -> dict: + return app.resolve(event, context) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..1a07270572a3c7baf4081a9b2ebf749ecb9de77f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/infrastructure.py @@ -0,0 +1,76 @@ +from pathlib import Path + +from aws_cdk import CfnOutput, Duration, Expiration +from aws_cdk import aws_appsync_alpha as appsync +from aws_cdk.aws_lambda import Function + +from tests.e2e.utils.data_builder import build_random_value +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class EventHandlerAppSyncStack(BaseInfrastructure): + def create_resources(self): + functions = self.create_lambda_functions() + + self._create_appsync_endpoint(function=functions["AppsyncResolverHandler"]) + + def _create_appsync_endpoint(self, function: Function): + api = appsync.GraphqlApi( + self.stack, + "Api", + name=f"e2e-tests{build_random_value()}", + schema=appsync.SchemaFile.from_asset(str(Path(self.feature_path, "files/schema.graphql"))), + authorization_config=appsync.AuthorizationConfig( + default_authorization=appsync.AuthorizationMode( + authorization_type=appsync.AuthorizationType.API_KEY, + api_key_config=appsync.ApiKeyConfig( + description="public key for getting data", + expires=Expiration.after(Duration.hours(25)), + name="API Token", + ), + ), + ), + xray_enabled=False, + ) + lambda_datasource = api.add_lambda_data_source("DataSource", lambda_function=function) + + lambda_datasource.create_resolver( + "QueryGetAllPostsResolver", + type_name="Query", + field_name="allPosts", + ) + lambda_datasource.create_resolver( + "QueryGetPostResolver", + type_name="Query", + field_name="getPost", + ) + lambda_datasource.create_resolver( + "QueryGetPostRelatedResolver", + type_name="Post", + field_name="relatedPosts", + max_batch_size=10, + ) + + lambda_datasource.create_resolver( + "QueryGetPostRelatedAsyncResolver", + type_name="Post", + field_name="relatedPostsAsync", + max_batch_size=10, + ) + + lambda_datasource.create_resolver( + "QueryGetPostRelatedResolverAggregate", + type_name="Post", + field_name="relatedPostsAggregate", + max_batch_size=10, + ) + + lambda_datasource.create_resolver( + "QueryGetPostRelatedAsyncResolverAggregate", + type_name="Post", + field_name="relatedPostsAsyncAggregate", + max_batch_size=10, + ) + + CfnOutput(self.stack, "GraphQLHTTPUrl", value=api.graphql_url) + CfnOutput(self.stack, "GraphQLAPIKey", value=api.api_key) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/test_appsync_resolvers.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/test_appsync_resolvers.py new file mode 100644 index 0000000000000000000000000000000000000000..35549a1fdef06579f28c43f12f02140169fa9aa7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/event_handler_appsync/test_appsync_resolvers.py @@ -0,0 +1,176 @@ +import json + +import pytest +from requests import Request + +from tests.e2e.utils import data_fetcher + + +@pytest.fixture +def appsync_endpoint(infrastructure: dict) -> str: + return infrastructure["GraphQLHTTPUrl"] + + +@pytest.fixture +def appsync_access_key(infrastructure: dict) -> str: + return infrastructure["GraphQLAPIKey"] + + +@pytest.mark.xdist_group(name="event_handler") +def test_appsync_get_all_posts(appsync_endpoint, appsync_access_key): + # GIVEN + body = { + "query": "query MyQuery { allPosts { post_id }}", + "variables": None, + "operationName": "MyQuery", + } + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=appsync_endpoint, + json=body, + headers={"x-api-key": appsync_access_key, "Content-Type": "application/json"}, + ), + ) + + # THEN expect a HTTP 200 response and content return list of Posts + assert response.status_code == 200 + assert response.content is not None + + data = json.loads(response.content.decode("ascii"))["data"] + + assert data["allPosts"] is not None + assert len(data["allPosts"]) > 0 + + +@pytest.mark.xdist_group(name="event_handler") +def test_appsync_get_post(appsync_endpoint, appsync_access_key): + # GIVEN + post_id = "1" + body = { + "query": f'query MyQuery {{ getPost(post_id: "{post_id}") {{ post_id }} }}', + "variables": None, + "operationName": "MyQuery", + } + + # WHEN + response = data_fetcher.get_http_response( + Request( + method="POST", + url=appsync_endpoint, + json=body, + headers={"x-api-key": appsync_access_key, "Content-Type": "application/json"}, + ), + ) + + # THEN expect a HTTP 200 response and content return Post id + assert response.status_code == 200 + assert response.content is not None + + data = json.loads(response.content.decode("ascii"))["data"] + + assert data["getPost"]["post_id"] == post_id + + +@pytest.mark.xdist_group(name="event_handler") +def test_appsync_get_related_posts_batch_without_aggregate(appsync_endpoint, appsync_access_key): + # GIVEN a batch event + post_id = "2" + related_posts_ids = ["3", "5"] + + body = { + "query": f""" + query MyQuery {{ + getPost(post_id: "{post_id}") {{ + post_id + relatedPosts {{ + post_id + }} + relatedPostsAsync {{ + post_id + }} + }} + }} + """, + "variables": None, + "operationName": "MyQuery", + } + + # WHEN we invoke the AppSync API with a batch event + response = data_fetcher.get_http_response( + Request( + method="POST", + url=appsync_endpoint, + json=body, + headers={"x-api-key": appsync_access_key, "Content-Type": "application/json"}, + ), + ) + + # THEN expect a HTTP 200 response and content return Post id with dependent Posts id's + assert response.status_code == 200 + assert response.content is not None + + data = json.loads(response.content.decode("ascii"))["data"] + + assert data["getPost"]["post_id"] == post_id + + assert len(data["getPost"]["relatedPosts"]) == len(related_posts_ids) + for post in data["getPost"]["relatedPosts"]: + assert post["post_id"] in related_posts_ids + + assert len(data["getPost"]["relatedPostsAsync"]) == len(related_posts_ids) + for post in data["getPost"]["relatedPostsAsync"]: + assert post["post_id"] in related_posts_ids + + +@pytest.mark.xdist_group(name="event_handler") +def test_appsync_get_related_posts_batch_with_aggregate(appsync_endpoint, appsync_access_key): + # GIVEN a batch event + post_id = "2" + related_posts_ids = ["3", "5"] + + body = { + "query": f""" + query MyQuery {{ + getPost(post_id: "{post_id}") {{ + post_id + relatedPostsAggregate {{ + post_id + }} + relatedPostsAsyncAggregate {{ + post_id + }} + }} + }} + """, + "variables": None, + "operationName": "MyQuery", + } + + # WHEN we invoke the AppSync API with a batch event + response = data_fetcher.get_http_response( + Request( + method="POST", + url=appsync_endpoint, + json=body, + headers={"x-api-key": appsync_access_key, "Content-Type": "application/json"}, + ), + ) + + # THEN expect a HTTP 200 response and content return Post id with dependent Posts id's + assert response.status_code == 200 + assert response.content is not None + + data = json.loads(response.content.decode("ascii"))["data"] + + assert data["getPost"]["post_id"] == post_id + + assert len(data["getPost"]["relatedPostsAggregate"]) == len(related_posts_ids) + for post in data["getPost"]["relatedPostsAggregate"]: + assert post["post_id"] in related_posts_ids + + assert len(data["getPost"]["relatedPostsAsyncAggregate"]) == len(related_posts_ids) + for post in data["getPost"]["relatedPostsAsyncAggregate"]: + assert post["post_id"] in related_posts_ids diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..61578d904a6046ec371a047cc33567a0e33f270b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.idempotency.infrastructure import IdempotencyDynamoDBStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = IdempotencyDynamoDBStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/function_thread_safety_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/function_thread_safety_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..a4644aa61c3f39658ffcc72e02c1bac2601d95a0 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/function_thread_safety_handler.py @@ -0,0 +1,29 @@ +import os +import time +from concurrent.futures import ThreadPoolExecutor, as_completed +from threading import current_thread + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + idempotent_function, +) + +TABLE_NAME = os.getenv("IdempotencyTable", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=TABLE_NAME) +threads_count = 2 + + +@idempotent_function(persistence_store=persistence_layer, data_keyword_argument="record") +def record_handler(record): + time_now = time.time() + return {"thread_name": current_thread().name, "time": str(time_now)} + + +def lambda_handler(event, context): + with ThreadPoolExecutor(max_workers=threads_count) as executor: + futures = [executor.submit(record_handler, **{"record": i}) for i in range(threads_count)] + + return [ + {"state": future._state, "exception": future.exception(), "output": future.result()} + for future in as_completed(futures) + ] diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/optional_idempotency_key_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/optional_idempotency_key_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..f1b7052041feb2fc719944a2666ad25ad4d511da --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/optional_idempotency_key_handler.py @@ -0,0 +1,17 @@ +import os +import uuid + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) + +TABLE_NAME = os.getenv("IdempotencyTable", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=TABLE_NAME) +config = IdempotencyConfig(event_key_jmespath='headers."X-Idempotency-Key"', use_local_cache=True) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + return {"request": str(uuid.uuid4())} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/parallel_execution_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/parallel_execution_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..cd66be0cd1d0f2d715b5706f6aa282eeca0db5fe --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/parallel_execution_handler.py @@ -0,0 +1,17 @@ +import os +import time + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + idempotent, +) + +TABLE_NAME = os.getenv("IdempotencyTable", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=TABLE_NAME) + + +@idempotent(persistence_store=persistence_layer) +def lambda_handler(event, context): + time.sleep(15) + + return event diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/payload_tampering_validation_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/payload_tampering_validation_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..dacb6ce63e0f1f30a94bf92752fc752b5e4b408c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/payload_tampering_validation_handler.py @@ -0,0 +1,17 @@ +import os +import uuid + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) + +TABLE_NAME = os.getenv("IdempotencyTable", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=TABLE_NAME) +config = IdempotencyConfig(event_key_jmespath='["refund_id", "customer_id"]', payload_validation_jmespath="details") + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + return {"request": str(uuid.uuid4())} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/response_hook.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/response_hook.py new file mode 100644 index 0000000000000000000000000000000000000000..b56d09f25b9fc27bb29b63a89cbee09eb8218e33 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/response_hook.py @@ -0,0 +1,29 @@ +import os + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.datarecord import ( + DataRecord, +) + +TABLE_NAME = os.getenv("IdempotencyTable", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=TABLE_NAME) + + +def my_response_hook(response: dict, idempotent_data: DataRecord) -> dict: + # Return inserted Header data into the Idempotent Response + response["x-response-hook"] = idempotent_data.idempotency_key + + # Must return the response here + return response + + +config = IdempotencyConfig(response_hook=my_response_hook) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + return {"message": "first_response"} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/ttl_cache_expiration_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/ttl_cache_expiration_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..a9bf4fb2b64aaafa65ac5fab8029d788039011d5 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/ttl_cache_expiration_handler.py @@ -0,0 +1,19 @@ +import os +import time + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) + +TABLE_NAME = os.getenv("IdempotencyTable", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=TABLE_NAME) +config = IdempotencyConfig(expires_after_seconds=5) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + time_now = time.time() + + return {"time": str(time_now)} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/ttl_cache_timeout_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/ttl_cache_timeout_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..ad1a51b495d6933c4e307b66980a9b7b3285616a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/handlers/ttl_cache_timeout_handler.py @@ -0,0 +1,20 @@ +import os +import time + +from aws_lambda_powertools.utilities.idempotency import ( + DynamoDBPersistenceLayer, + IdempotencyConfig, + idempotent, +) + +TABLE_NAME = os.getenv("IdempotencyTable", "") +persistence_layer = DynamoDBPersistenceLayer(table_name=TABLE_NAME) +config = IdempotencyConfig(expires_after_seconds=1) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + sleep_time: int = event.get("sleep") or 0 + time.sleep(sleep_time) + + return event diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..6ca14d576efa21692482ba0cbe1233071a78d34a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/infrastructure.py @@ -0,0 +1,37 @@ +from aws_cdk import CfnOutput, Duration, RemovalPolicy +from aws_cdk import aws_dynamodb as dynamodb +from aws_cdk.aws_dynamodb import Table + +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class IdempotencyDynamoDBStack(BaseInfrastructure): + def create_resources(self): + table = self._create_dynamodb_table() + + env_vars = {"IdempotencyTable": table.table_name} + functions = self.create_lambda_functions( + function_props={"environment": env_vars, "timeout": Duration.seconds(10)}, + ) + + table.grant_read_write_data(functions["TtlCacheExpirationHandler"]) + table.grant_read_write_data(functions["TtlCacheTimeoutHandler"]) + table.grant_read_write_data(functions["ParallelExecutionHandler"]) + table.grant_read_write_data(functions["FunctionThreadSafetyHandler"]) + table.grant_read_write_data(functions["OptionalIdempotencyKeyHandler"]) + table.grant_read_write_data(functions["PayloadTamperingValidationHandler"]) + table.grant_read_write_data(functions["ResponseHook"]) + + def _create_dynamodb_table(self) -> Table: + table = dynamodb.Table( + self.stack, + "Idempotency", + removal_policy=RemovalPolicy.DESTROY, + partition_key=dynamodb.Attribute(name="id", type=dynamodb.AttributeType.STRING), + time_to_live_attribute="expiration", + billing_mode=dynamodb.BillingMode.PAY_PER_REQUEST, + ) + + CfnOutput(self.stack, "DynamoDBTable", value=table.table_name) + + return table diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/test_idempotency_dynamodb.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/test_idempotency_dynamodb.py new file mode 100644 index 0000000000000000000000000000000000000000..75d774e702e744df3f9f23405d6c33503ea79000 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency/test_idempotency_dynamodb.py @@ -0,0 +1,252 @@ +import json +from copy import deepcopy +from time import sleep + +import pytest + +from tests.e2e.utils import data_fetcher +from tests.e2e.utils.data_fetcher.common import ( + GetLambdaResponseOptions, + get_lambda_response_in_parallel, +) + + +@pytest.fixture +def ttl_cache_expiration_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("TtlCacheExpirationHandlerArn", "") + + +@pytest.fixture +def ttl_cache_timeout_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("TtlCacheTimeoutHandlerArn", "") + + +@pytest.fixture +def parallel_execution_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("ParallelExecutionHandlerArn", "") + + +@pytest.fixture +def function_thread_safety_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("FunctionThreadSafetyHandlerArn", "") + + +@pytest.fixture +def optional_idempotency_key_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("OptionalIdempotencyKeyHandlerArn", "") + + +@pytest.fixture +def payload_tampering_validation_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("PayloadTamperingValidationHandlerArn", "") + + +@pytest.fixture +def response_hook_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("ResponseHookArn", "") + + +@pytest.fixture +def idempotency_table_name(infrastructure: dict) -> str: + return infrastructure.get("DynamoDBTable", "") + + +@pytest.mark.xdist_group(name="idempotency") +def test_ttl_caching_expiration_idempotency(ttl_cache_expiration_handler_fn_arn: str): + # GIVEN + payload = json.dumps({"message": "Powertools for AWS Lambda (Python) - TTL 5s"}) + + # WHEN + # first execution + first_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_expiration_handler_fn_arn, + payload=payload, + ) + first_execution_response = first_execution["Payload"].read().decode("utf-8") + + # the second execution should return the same response as the first execution + second_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_expiration_handler_fn_arn, + payload=payload, + ) + second_execution_response = second_execution["Payload"].read().decode("utf-8") + + # wait 8s to expire ttl and execute again, this should return a new response value + sleep(8) + third_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_expiration_handler_fn_arn, + payload=payload, + ) + third_execution_response = third_execution["Payload"].read().decode("utf-8") + + # THEN + assert first_execution_response == second_execution_response + assert third_execution_response != second_execution_response + + +@pytest.mark.xdist_group(name="idempotency") +def test_ttl_caching_timeout_idempotency(ttl_cache_timeout_handler_fn_arn: str): + # GIVEN + payload_timeout_execution = json.dumps( + {"sleep": 12, "message": "Powertools for AWS Lambda (Python) - TTL 1s"}, + sort_keys=True, + ) + payload_working_execution = json.dumps( + {"sleep": 0, "message": "Powertools for AWS Lambda (Python) - TTL 1s"}, + sort_keys=True, + ) + + # WHEN + # first call should fail due to timeout + execution_with_timeout, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_timeout_handler_fn_arn, + payload=payload_timeout_execution, + raise_on_error=False, + ) + execution_with_timeout_response = execution_with_timeout["Payload"].read().decode("utf-8") + + # the second call should work and return the payload + execution_working, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_timeout_handler_fn_arn, + payload=payload_working_execution, + ) + execution_working_response = execution_working["Payload"].read().decode("utf-8") + + # THEN + assert "Task timed out after" in execution_with_timeout_response + assert payload_working_execution == execution_working_response + + +@pytest.mark.xdist_group(name="idempotency") +def test_parallel_execution_idempotency(parallel_execution_handler_fn_arn: str): + # GIVEN + payload = json.dumps({"message": "Powertools for AWS Lambda (Python) - Parallel execution"}) + + invocation_options = [ + GetLambdaResponseOptions(lambda_arn=parallel_execution_handler_fn_arn, payload=payload, raise_on_error=False), + GetLambdaResponseOptions(lambda_arn=parallel_execution_handler_fn_arn, payload=payload, raise_on_error=False), + ] + + # WHEN executing Lambdas in parallel + execution_result_list = get_lambda_response_in_parallel(invocation_options) + + timeout_execution_response = execution_result_list[0][0]["Payload"].read().decode("utf-8") + error_idempotency_execution_response = execution_result_list[1][0]["Payload"].read().decode("utf-8") + + # THEN + assert "Execution already in progress with idempotency key" in error_idempotency_execution_response + assert "Task timed out after" in timeout_execution_response + + +@pytest.mark.xdist_group(name="idempotency") +def test_idempotent_function_thread_safety(function_thread_safety_handler_fn_arn: str): + # GIVEN + payload = json.dumps({"message": "Powertools for AWS Lambda (Python) - Idempotent function thread safety check"}) + + # WHEN + # first execution + first_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=function_thread_safety_handler_fn_arn, + payload=payload, + ) + first_execution_response = first_execution["Payload"].read().decode("utf-8") + + # the second execution should return the same response as the first execution + second_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=function_thread_safety_handler_fn_arn, + payload=payload, + ) + second_execution_response = second_execution["Payload"].read().decode("utf-8") + + # THEN + # Function threads finished without exception AND + # first and second execution is the same + for function_thread in json.loads(first_execution_response): + assert function_thread["state"] == "FINISHED" + assert function_thread["exception"] is None + assert function_thread["output"] is not None + + # we use set() here because we want to compare the elements regardless of their order in the array + assert set(first_execution_response) == set(second_execution_response) + + +@pytest.mark.xdist_group(name="idempotency") +def test_optional_idempotency_key(optional_idempotency_key_fn_arn: str): + # GIVEN two payloads where only one has the expected idempotency key + payload = json.dumps({"headers": {"X-Idempotency-Key": "here"}}) + payload_without = json.dumps({"headers": {}}) + + # WHEN + # we make one request with an idempotency key + first_execution, _ = data_fetcher.get_lambda_response(lambda_arn=optional_idempotency_key_fn_arn, payload=payload) + first_execution_response = first_execution["Payload"].read().decode("utf-8") + + # and two others without the idempotency key + second_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=optional_idempotency_key_fn_arn, + payload=payload_without, + ) + second_execution_response = second_execution["Payload"].read().decode("utf-8") + + third_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=optional_idempotency_key_fn_arn, + payload=payload_without, + ) + third_execution_response = third_execution["Payload"].read().decode("utf-8") + + # THEN + # we should treat 2nd and 3rd requests with NULL idempotency key as non-idempotent transactions + # that is, no cache, no calls to persistent store, etc. + assert first_execution_response != second_execution_response + assert first_execution_response != third_execution_response + assert second_execution_response != third_execution_response + + +@pytest.mark.xdist_group(name="idempotency") +def test_payload_tampering_validation(payload_tampering_validation_fn_arn: str): + # GIVEN a transaction with the idempotency key on refund and customer IDs + transaction = { + "refund_id": "ffd11882-d476-4598-bbf1-643f2be5addf", + "customer_id": "9e9fc440-9e65-49b5-9e71-1382ea1b1658", + "details": {"company_name": "Parker, Johnson and Rath", "currency": "Turkish Lira"}, + } + + # AND a second transaction with the exact idempotency key but different currency + tampered_transaction = deepcopy(transaction) + tampered_transaction["details"]["currency"] = "Euro" + + # WHEN we make both requests to a Lambda Function that enabled payload validation + data_fetcher.get_lambda_response(lambda_arn=payload_tampering_validation_fn_arn, payload=json.dumps(transaction)) + + # THEN we should receive a payload validation error in the second request + with pytest.raises(RuntimeError, match="Payload does not match stored record"): + data_fetcher.get_lambda_response( + lambda_arn=payload_tampering_validation_fn_arn, + payload=json.dumps(tampered_transaction), + ) + + +@pytest.mark.xdist_group(name="idempotency") +def test_response_hook_idempotency(response_hook_handler_fn_arn: str): + # GIVEN + payload = json.dumps({"message": "Powertools for AWS Lambda (Python)"}) + + # WHEN + # first execution + first_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=response_hook_handler_fn_arn, + payload=payload, + ) + first_execution_response = first_execution["Payload"].read().decode("utf-8") + + # the second execution should include response hook + second_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=response_hook_handler_fn_arn, + payload=payload, + ) + second_execution_response = second_execution["Payload"].read().decode("utf-8") + + # THEN first execution should not trigger response hook + # THEN seconde execution must trigger response hook + assert "x-response-hook" not in first_execution_response + assert "x-response-hook" in second_execution_response diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..0e12288fe9a91e1026e8f7f0e2394359a823ad67 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/conftest.py @@ -0,0 +1,20 @@ +import pytest + +from tests.e2e.idempotency_redis.infrastructure import IdempotencyRedisServerlessStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + + stack = IdempotencyRedisServerlessStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/function_thread_safety_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/function_thread_safety_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..6d326c17e403bc95d2bf3dcb7a9b8a874af92dbe --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/function_thread_safety_handler.py @@ -0,0 +1,29 @@ +import os +import time +from concurrent.futures import ThreadPoolExecutor, as_completed +from threading import current_thread + +from aws_lambda_powertools.utilities.idempotency import ( + idempotent_function, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import RedisCachePersistenceLayer + +REDIS_HOST = os.getenv("RedisEndpoint", "") +persistence_layer = RedisCachePersistenceLayer(host=REDIS_HOST, port=6379) +threads_count = 2 + + +@idempotent_function(persistence_store=persistence_layer, data_keyword_argument="record") +def record_handler(record): + time_now = time.time() + return {"thread_name": current_thread().name, "time": str(time_now)} + + +def lambda_handler(event, context): + with ThreadPoolExecutor(max_workers=threads_count) as executor: + futures = [executor.submit(record_handler, **{"record": i}) for i in range(threads_count)] + + return [ + {"state": future._state, "exception": future.exception(), "output": future.result()} + for future in as_completed(futures) + ] diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/optional_idempotency_key_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/optional_idempotency_key_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..75be8b31299a6cd7f8ef709a02541cfa922fc4b2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/optional_idempotency_key_handler.py @@ -0,0 +1,17 @@ +import os +import uuid + +from aws_lambda_powertools.utilities.idempotency import ( + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import RedisCachePersistenceLayer + +REDIS_HOST = os.getenv("RedisEndpoint", "") +persistence_layer = RedisCachePersistenceLayer(host=REDIS_HOST, port=6379) +config = IdempotencyConfig(event_key_jmespath='headers."X-Idempotency-Key"', use_local_cache=True) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + return {"request": str(uuid.uuid4())} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/parallel_execution_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/parallel_execution_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..ff628d7a60eb5438426017c79d2fb67680d736ee --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/parallel_execution_handler.py @@ -0,0 +1,17 @@ +import os +import time + +from aws_lambda_powertools.utilities.idempotency import ( + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import RedisCachePersistenceLayer + +REDIS_HOST = os.getenv("RedisEndpoint", "") +persistence_layer = RedisCachePersistenceLayer(host=REDIS_HOST, port=6379) + + +@idempotent(persistence_store=persistence_layer) +def lambda_handler(event, context): + time.sleep(15) + + return event diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/response_hook.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/response_hook.py new file mode 100644 index 0000000000000000000000000000000000000000..4acf7f3edb876c045dcf96eb4e9b608c37cc7dfd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/response_hook.py @@ -0,0 +1,29 @@ +import os + +from aws_lambda_powertools.utilities.idempotency import ( + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.datarecord import ( + DataRecord, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import RedisCachePersistenceLayer + +REDIS_HOST = os.getenv("RedisEndpoint", "") +persistence_layer = RedisCachePersistenceLayer(host=REDIS_HOST, port=6379) + + +def my_response_hook(response: dict, idempotent_data: DataRecord) -> dict: + # Return inserted Header data into the Idempotent Response + response["x-response-hook"] = idempotent_data.idempotency_key + + # Must return the response here + return response + + +config = IdempotencyConfig(response_hook=my_response_hook) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + return {"message": "first_response"} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/ttl_cache_expiration_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/ttl_cache_expiration_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..a93413e157e5c96abd19e521f4a96eecef28009f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/ttl_cache_expiration_handler.py @@ -0,0 +1,19 @@ +import os +import time + +from aws_lambda_powertools.utilities.idempotency import ( + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import RedisCachePersistenceLayer + +REDIS_HOST = os.getenv("RedisEndpoint", "") +persistence_layer = RedisCachePersistenceLayer(host=REDIS_HOST, port=6379) +config = IdempotencyConfig(expires_after_seconds=5) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + time_now = time.time() + + return {"time": str(time_now)} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/ttl_cache_timeout_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/ttl_cache_timeout_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..56c2372b2c0328730c889f3b871658ae009a479b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/handlers/ttl_cache_timeout_handler.py @@ -0,0 +1,20 @@ +import os +import time + +from aws_lambda_powertools.utilities.idempotency import ( + IdempotencyConfig, + idempotent, +) +from aws_lambda_powertools.utilities.idempotency.persistence.redis import RedisCachePersistenceLayer + +REDIS_HOST = os.getenv("RedisEndpoint", "") +persistence_layer = RedisCachePersistenceLayer(host=REDIS_HOST, port=6379) +config = IdempotencyConfig(expires_after_seconds=1) + + +@idempotent(config=config, persistence_store=persistence_layer) +def lambda_handler(event, context): + sleep_time: int = event.get("sleep") or 0 + time.sleep(sleep_time) + + return event diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..774db857043b646a469982ed7e2e9de06600df51 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/infrastructure.py @@ -0,0 +1,93 @@ +import time +from typing import Tuple + +from aws_cdk import Duration +from aws_cdk import aws_ec2 as ec2 +from aws_cdk.aws_ec2 import ( + SecurityGroup, + SubnetType, + Vpc, +) +from aws_cdk.aws_elasticache import ( + CfnServerlessCache, +) + +from tests.e2e.utils.data_builder import build_random_value +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class IdempotencyRedisServerlessStack(BaseInfrastructure): + def create_resources(self) -> None: + service_name = build_random_value(10).replace("_", "") + + vpc_stack: Vpc = self._create_vpc(service_name, "172.150.0.0/16") + security_groups: Tuple = self._create_security_groups(vpc_stack) + redis_cluster: CfnServerlessCache = self._create_redis_cache(service_name, vpc_stack, security_groups[0]) + + env_vars = {"RedisEndpoint": f"{str(redis_cluster.attr_endpoint_address)}"} + + self.create_lambda_functions( + function_props={ + "environment": env_vars, + "vpc": vpc_stack, + "security_groups": [security_groups[1]], + "timeout": Duration.seconds(10), + }, + ) + + def _create_vpc(self, service_name: str, cidr: str) -> Vpc: + vpc_stack: Vpc = Vpc( + self.stack, + "VPC-ServerlessCache", + nat_gateways=1, + vpc_name=f"VPC-ServerlessCache-{service_name}", + ip_addresses=ec2.IpAddresses.cidr(cidr), + subnet_configuration=[ + ec2.SubnetConfiguration(name="public", subnet_type=SubnetType.PUBLIC, cidr_mask=24), + ec2.SubnetConfiguration(name="private", subnet_type=SubnetType.PRIVATE_WITH_EGRESS, cidr_mask=24), + ], + max_azs=2, + ) + + return vpc_stack + + def _create_security_groups(self, vpc_stack: Vpc) -> Tuple[SecurityGroup, SecurityGroup]: + # Create a security group for the ElastiCache cluster + cache_security_group: SecurityGroup = SecurityGroup(self.stack, "ElastiCacheSecurityGroup", vpc=vpc_stack) + cache_security_group.add_ingress_rule( + peer=ec2.Peer.ipv4(vpc_stack.vpc_cidr_block), + connection=ec2.Port.tcp(6379), + description="Allow inbound traffic from VPC", + ) + + lambda_security_group = SecurityGroup( + self.stack, + "LambdaSecurityGroup", + vpc=vpc_stack, + allow_all_ipv6_outbound=True, + allow_all_outbound=True, + ) + + return cache_security_group, lambda_security_group + + def _create_redis_cache( + self, + service_name: str, + vpc_stack: Vpc, + cache_security_group: SecurityGroup, + ) -> CfnServerlessCache: + cache_cluster = CfnServerlessCache( + self.stack, + "ElastiCacheCluster", + engine="redis", + security_group_ids=[cache_security_group.security_group_id], + subnet_ids=[subnet.subnet_id for subnet in vpc_stack.private_subnets], + serverless_cache_name=f"Cache-{service_name}", + ) + + # Just to make sure the Cluster will be ready before the Stack is complete + while cache_cluster.attr_status == "CREATING": + print("Waiting for ElastiCache serverless to be created...") + time.sleep(5) + + return cache_cluster diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/test_idempotency_redis.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/test_idempotency_redis.py new file mode 100644 index 0000000000000000000000000000000000000000..ee5502b2dec6f1a4c2f96c0778b8959b83261b37 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/idempotency_redis/test_idempotency_redis.py @@ -0,0 +1,214 @@ +import json +from time import sleep + +import pytest + +from tests.e2e.utils import data_fetcher +from tests.e2e.utils.data_fetcher.common import GetLambdaResponseOptions, get_lambda_response_in_parallel + + +@pytest.fixture +def ttl_cache_expiration_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("TtlCacheExpirationHandlerArn", "") + + +@pytest.fixture +def ttl_cache_timeout_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("TtlCacheTimeoutHandlerArn", "") + + +@pytest.fixture +def parallel_execution_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("ParallelExecutionHandlerArn", "") + + +@pytest.fixture +def function_thread_safety_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("FunctionThreadSafetyHandlerArn", "") + + +@pytest.fixture +def optional_idempotency_key_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("OptionalIdempotencyKeyHandlerArn", "") + + +@pytest.fixture +def response_hook_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("ResponseHookArn", "") + + +@pytest.mark.xdist_group(name="idempotency-redis") +def test_ttl_caching_expiration_idempotency(ttl_cache_expiration_handler_fn_arn: str): + # GIVEN + payload = json.dumps({"message": "Powertools for AWS Lambda (Python) - TTL 5s"}) + + # WHEN + # first execution + first_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_expiration_handler_fn_arn, + payload=payload, + ) + first_execution_response = first_execution["Payload"].read().decode("utf-8") + + # the second execution should return the same response as the first execution + second_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_expiration_handler_fn_arn, + payload=payload, + ) + second_execution_response = second_execution["Payload"].read().decode("utf-8") + + # wait 8s to expire ttl and execute again, this should return a new response value + sleep(8) + third_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_expiration_handler_fn_arn, + payload=payload, + ) + third_execution_response = third_execution["Payload"].read().decode("utf-8") + + # THEN + assert first_execution_response == second_execution_response + assert third_execution_response != second_execution_response + + +@pytest.mark.xdist_group(name="idempotency-redis") +def test_ttl_caching_timeout_idempotency(ttl_cache_timeout_handler_fn_arn: str): + # GIVEN + payload_timeout_execution = json.dumps( + {"sleep": 12, "message": "Powertools for AWS Lambda (Python) - TTL 1s"}, + sort_keys=True, + ) + payload_working_execution = json.dumps( + {"sleep": 0, "message": "Powertools for AWS Lambda (Python) - TTL 1s"}, + sort_keys=True, + ) + + # WHEN + # first call should fail due to timeout + execution_with_timeout, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_timeout_handler_fn_arn, + payload=payload_timeout_execution, + raise_on_error=False, + ) + execution_with_timeout_response = execution_with_timeout["Payload"].read().decode("utf-8") + + # the second call should work and return the payload + execution_working, _ = data_fetcher.get_lambda_response( + lambda_arn=ttl_cache_timeout_handler_fn_arn, + payload=payload_working_execution, + ) + execution_working_response = execution_working["Payload"].read().decode("utf-8") + + # THEN + assert "Task timed out after" in execution_with_timeout_response + assert payload_working_execution == execution_working_response + + +@pytest.mark.xdist_group(name="idempotency-redis") +def test_parallel_execution_idempotency(parallel_execution_handler_fn_arn: str): + # GIVEN + payload = json.dumps({"message": "Powertools for AWS Lambda (Python) - Parallel execution"}) + + invocation_options = [ + GetLambdaResponseOptions(lambda_arn=parallel_execution_handler_fn_arn, payload=payload, raise_on_error=False), + GetLambdaResponseOptions(lambda_arn=parallel_execution_handler_fn_arn, payload=payload, raise_on_error=False), + ] + + # WHEN executing Lambdas in parallel + execution_result_list = get_lambda_response_in_parallel(invocation_options) + + timeout_execution_response = execution_result_list[0][0]["Payload"].read().decode("utf-8") + error_idempotency_execution_response = execution_result_list[1][0]["Payload"].read().decode("utf-8") + + # THEN + assert "Execution already in progress with idempotency key" in error_idempotency_execution_response + assert "Task timed out after" in timeout_execution_response + + +@pytest.mark.xdist_group(name="idempotency-redis") +def test_idempotent_function_thread_safety(function_thread_safety_handler_fn_arn: str): + # GIVEN + payload = json.dumps({"message": "Powertools for AWS Lambda (Python) - Idempotent function thread safety check"}) + + # WHEN + # first execution + first_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=function_thread_safety_handler_fn_arn, + payload=payload, + ) + first_execution_response = first_execution["Payload"].read().decode("utf-8") + + # the second execution should return the same response as the first execution + second_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=function_thread_safety_handler_fn_arn, + payload=payload, + ) + second_execution_response = second_execution["Payload"].read().decode("utf-8") + + # THEN + # Function threads finished without exception AND + # first and second execution is the same + for function_thread in json.loads(first_execution_response): + assert function_thread["state"] == "FINISHED" + assert function_thread["exception"] is None + assert function_thread["output"] is not None + + # we use set() here because we want to compare the elements regardless of their order in the array + assert set(first_execution_response) == set(second_execution_response) + + +@pytest.mark.xdist_group(name="idempotency-redis") +def test_optional_idempotency_key(optional_idempotency_key_fn_arn: str): + # GIVEN two payloads where only one has the expected idempotency key + payload = json.dumps({"headers": {"X-Idempotency-Key": "here"}}) + payload_without = json.dumps({"headers": {}}) + + # WHEN + # we make one request with an idempotency key + first_execution, _ = data_fetcher.get_lambda_response(lambda_arn=optional_idempotency_key_fn_arn, payload=payload) + first_execution_response = first_execution["Payload"].read().decode("utf-8") + + # and two others without the idempotency key + second_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=optional_idempotency_key_fn_arn, + payload=payload_without, + ) + second_execution_response = second_execution["Payload"].read().decode("utf-8") + + third_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=optional_idempotency_key_fn_arn, + payload=payload_without, + ) + third_execution_response = third_execution["Payload"].read().decode("utf-8") + + # THEN + # we should treat 2nd and 3rd requests with NULL idempotency key as non-idempotent transactions + # that is, no cache, no calls to persistent store, etc. + assert first_execution_response != second_execution_response + assert first_execution_response != third_execution_response + assert second_execution_response != third_execution_response + + +@pytest.mark.xdist_group(name="idempotency") +def test_response_hook_idempotency(response_hook_handler_fn_arn: str): + # GIVEN + payload = json.dumps({"message": "Powertools for AWS Lambda (Python)"}) + + # WHEN + # first execution + first_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=response_hook_handler_fn_arn, + payload=payload, + ) + first_execution_response = first_execution["Payload"].read().decode("utf-8") + + # the second execution should include response hook + second_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=response_hook_handler_fn_arn, + payload=payload, + ) + second_execution_response = second_execution["Payload"].read().decode("utf-8") + + # THEN first execution should not trigger response hook + # THEN seconde execution must trigger response hook + assert "x-response-hook" not in first_execution_response + assert "x-response-hook" in second_execution_response diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..ad336931a93e84c64f605f1d26bebf1f9efffa79 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.logger.infrastructure import LoggerStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = LoggerStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/handlers/basic_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/handlers/basic_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..0f0dd46b4aafd7eae3aba95301ce212cc89d1cfa --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/handlers/basic_handler.py @@ -0,0 +1,11 @@ +from aws_lambda_powertools import Logger + +logger = Logger() + + +@logger.inject_lambda_context +def lambda_handler(event, context): + message, append_keys = event.get("message", ""), event.get("append_keys", {}) + logger.append_keys(**append_keys) + logger.info(message) + return "success" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/handlers/tz_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/handlers/tz_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..06f6cfbf846ce34ed328d44b0ceaba12a9999123 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/handlers/tz_handler.py @@ -0,0 +1,27 @@ +import os +import time + +from aws_lambda_powertools import Logger + + +def lambda_handler(event, context): + utc, datefmt, tz = event.get("utc", False), event.get("datefmt", None), event.get("tz", None) + if tz: + # set TZ envrionment variable to given tz param + os.environ["TZ"] = tz + time.tzset() + + # init logger using given params + logger = Logger(service=f"{utc}-{datefmt}-{tz}", utc=utc, datefmt=datefmt) + + # return the converter this Logger is using + if logger.handlers[0].formatter.converter == time.localtime: + loggerType = "localtime_converter" + elif logger.handlers[0].formatter.converter == time.gmtime: + loggerType = "gmtime_converter" + else: + loggerType = "unknown" + + # print the message to Cloudwatch, timestamp included + logger.info(loggerType) + return "success" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..242b3c10892f52a73c7b7261e12c09d437f2e935 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/infrastructure.py @@ -0,0 +1,6 @@ +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class LoggerStack(BaseInfrastructure): + def create_resources(self): + self.create_lambda_functions() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/test_logger.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/test_logger.py new file mode 100644 index 0000000000000000000000000000000000000000..3aa2433b69653c5158cde1646f3cfa3eb8321184 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/logger/test_logger.py @@ -0,0 +1,112 @@ +import json +import os +import time +from uuid import uuid4 + +import pytest + +from aws_lambda_powertools.shared.constants import LOGGER_LAMBDA_CONTEXT_KEYS +from tests.e2e.utils import data_fetcher + + +@pytest.fixture +def basic_handler_fn(infrastructure: dict) -> str: + return infrastructure.get("BasicHandler", "") + + +@pytest.fixture +def basic_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("BasicHandlerArn", "") + + +@pytest.fixture +def tz_handler_fn(infrastructure: dict) -> str: + return infrastructure.get("TzHandler", "") + + +@pytest.fixture +def tz_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("TzHandlerArn", "") + + +@pytest.mark.xdist_group(name="logger") +def test_basic_lambda_logs_visible(basic_handler_fn, basic_handler_fn_arn): + # GIVEN + message = "logs should be visible with default settings" + custom_key = "order_id" + additional_keys = {custom_key: f"{uuid4()}"} + payload = json.dumps({"message": message, "append_keys": additional_keys}) + + # WHEN + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=basic_handler_fn_arn, payload=payload) + data_fetcher.get_lambda_response(lambda_arn=basic_handler_fn_arn, payload=payload) + + # THEN + logs = data_fetcher.get_logs(function_name=basic_handler_fn, start_time=execution_time, minimum_log_entries=2) + + assert len(logs) == 2 + assert len(logs.get_cold_start_log()) == 1 + assert len(logs.get_log(key=custom_key)) == 2 + assert logs.have_keys(*LOGGER_LAMBDA_CONTEXT_KEYS) is True + + +@pytest.mark.xdist_group(name="logger") +@pytest.mark.parametrize("tz", ["US/Eastern", "UTC", "Asia/Shanghai"]) +@pytest.mark.parametrize("datefmt", ["%z", None]) +def test_lambda_tz_with_utc(tz_handler_fn, tz_handler_fn_arn, tz, datefmt): + # GIVEN: UTC is set to True, indicating that the Lambda function must use UTC. + utc = True + payload = json.dumps({"utc": utc, "tz": tz, "datefmt": datefmt}) + + # WHEN invoking sample hander using combination of timezone and date format + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=tz_handler_fn_arn, payload=payload) + data_fetcher.get_lambda_response(lambda_arn=tz_handler_fn_arn, payload=payload) + + logs = data_fetcher.get_logs( + function_name=tz_handler_fn, + start_time=execution_time, + minimum_log_entries=1, + filter_expression='{ $.service = "' + f"{utc}-{datefmt}-{tz}" + '" }', + ) + result_list = logs.logs + + assert len(result_list) > 0 + result = result_list[0] + + # THEN Make sure that the result list of logs is not empty, indicating that logs were collected + # THEN Make sure that the message in the first log entry indicates the use of "gmtime_converter" + assert result.message == "gmtime_converter" + assert result.timestamp[-5:] == "+0000" + + +@pytest.mark.xdist_group(name="logger") +@pytest.mark.parametrize("tz", ["US/Eastern", "UTC", "Asia/Shanghai"]) +@pytest.mark.parametrize("datefmt", ["%z", None]) +def test_lambda_tz_without_utc(tz_handler_fn, tz_handler_fn_arn, tz, datefmt): + # GIVEN: UTC is set to False, indicating that the Lambda function should not use UTC. + utc = False + payload = json.dumps({"utc": utc, "tz": tz, "datefmt": datefmt}) + + # WHEN invoking sample handler using combination of timezone and date format + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=tz_handler_fn_arn, payload=payload) + data_fetcher.get_lambda_response(lambda_arn=tz_handler_fn_arn, payload=payload) + + logs = data_fetcher.get_logs( + function_name=tz_handler_fn, + start_time=execution_time, + minimum_log_entries=1, + filter_expression='{ $.service = "' + f"{utc}-{datefmt}-{tz}" + '" }', + ) + result_list = logs.logs + + # THEN Make sure that the result list of logs is not empty, indicating that logs were collected + # THEN Make sure that the message in the first log entry indicates the use of "localtime_converter" + # THEN Make sure that the timestamp in the first log entry matches the current time in the specified timezone + assert len(result_list) > 0 + result = result_list[0] + + assert result.message == "localtime_converter" + + os.environ["TZ"] = tz + time.tzset() + assert result.timestamp[-5:] == time.strftime("%z", time.localtime()) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..197aaff847f4a2ae2db7e54740b3d61f326560e9 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.metrics.infrastructure import MetricsStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = MetricsStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/handlers/basic_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/handlers/basic_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..ef5e079e604bd05ad315105c995ebfc557cc7696 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/handlers/basic_handler.py @@ -0,0 +1,17 @@ +from aws_lambda_powertools import Metrics + +my_metrics = Metrics() + + +@my_metrics.log_metrics +def lambda_handler(event, context): + metrics, namespace, service = event.get("metrics"), event.get("namespace"), event.get("service") + + # Maintenance: create a public method to set these explicitly + my_metrics.namespace = namespace + my_metrics.service = service + + for metric in metrics: + my_metrics.add_metric(**metric) + + return "success" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/handlers/cold_start.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/handlers/cold_start.py new file mode 100644 index 0000000000000000000000000000000000000000..20f2ad16f85222a36244e589616eb602dbe02750 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/handlers/cold_start.py @@ -0,0 +1,12 @@ +from aws_lambda_powertools import Metrics + +my_metrics = Metrics() + + +@my_metrics.log_metrics(capture_cold_start_metric=True) +def lambda_handler(event, context): + # Maintenance: create a public method to set these explicitly + my_metrics.namespace = event.get("namespace") + my_metrics.service = event.get("service") + + return "success" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..7cc1eb8c4981d097e8f24fff646c4996f972effb --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/infrastructure.py @@ -0,0 +1,6 @@ +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class MetricsStack(BaseInfrastructure): + def create_resources(self): + self.create_lambda_functions() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/test_metrics.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/test_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..4285d011524cdd1c7215617f70db9c4456f12c04 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/metrics/test_metrics.py @@ -0,0 +1,75 @@ +import json + +import pytest + +from tests.e2e.utils import data_builder, data_fetcher + + +@pytest.fixture +def basic_handler_fn(infrastructure: dict) -> str: + return infrastructure.get("BasicHandler", "") + + +@pytest.fixture +def basic_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("BasicHandlerArn", "") + + +@pytest.fixture +def cold_start_fn(infrastructure: dict) -> str: + return infrastructure.get("ColdStart", "") + + +@pytest.fixture +def cold_start_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("ColdStartArn", "") + + +METRIC_NAMESPACE = "powertools-e2e-metric" + + +@pytest.mark.xdist_group(name="metrics") +def test_basic_lambda_metric_is_visible(basic_handler_fn: str, basic_handler_fn_arn: str): + # GIVEN + metric_name = data_builder.build_metric_name() + service = data_builder.build_service_name() + dimensions = data_builder.build_add_dimensions_input(service=service) + metrics = data_builder.build_multiple_add_metric_input(metric_name=metric_name, value=1, quantity=3) + + # WHEN + event = json.dumps({"metrics": metrics, "service": service, "namespace": METRIC_NAMESPACE}) + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=basic_handler_fn_arn, payload=event) + + metric_values = data_fetcher.get_metrics( + namespace=METRIC_NAMESPACE, + start_date=execution_time, + metric_name=metric_name, + dimensions=dimensions, + ) + + # THEN + assert metric_values == [3.0] + + +@pytest.mark.xdist_group(name="metrics") +def test_cold_start_metric(cold_start_fn_arn: str, cold_start_fn: str): + # GIVEN + metric_name = "ColdStart" + service = data_builder.build_service_name() + dimensions = data_builder.build_add_dimensions_input(function_name=cold_start_fn, service=service) + + # WHEN we invoke twice + event = json.dumps({"service": service, "namespace": METRIC_NAMESPACE}) + + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=cold_start_fn_arn, payload=event) + data_fetcher.get_lambda_response(lambda_arn=cold_start_fn_arn, payload=event) + + metric_values = data_fetcher.get_metrics( + namespace=METRIC_NAMESPACE, + start_date=execution_time, + metric_name=metric_name, + dimensions=dimensions, + ) + + # THEN + assert metric_values == [1.0] diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..991466073848adbe302f1857b0f04334c5439ef9 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.parameters.infrastructure import ParametersStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = ParametersStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/handlers/parameter_appconfig_freeform_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/handlers/parameter_appconfig_freeform_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..7c73273102e98c248cdf83b7e24839deb6cd9504 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/handlers/parameter_appconfig_freeform_handler.py @@ -0,0 +1,13 @@ +from aws_lambda_powertools.utilities import parameters +from aws_lambda_powertools.utilities.typing import LambdaContext + + +def lambda_handler(event: dict, context: LambdaContext): + # Retrieve a single configuration, latest version + value: bytes = parameters.get_app_config( + name=event.get("name"), + environment=event.get("environment"), + application=event.get("application"), + ) + + return value diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/handlers/parameter_ssm_get_parameters_by_name.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/handlers/parameter_ssm_get_parameters_by_name.py new file mode 100644 index 0000000000000000000000000000000000000000..948fad2aa12dc34379fb71b47a9eab428e4ee42e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/handlers/parameter_ssm_get_parameters_by_name.py @@ -0,0 +1,15 @@ +import json +import os +from typing import Any, Dict, List, cast + +from aws_lambda_powertools.utilities.parameters.ssm import get_parameters_by_name +from aws_lambda_powertools.utilities.typing import LambdaContext + +parameters_list: List[str] = cast(List, json.loads(os.getenv("parameters", ""))) + + +def lambda_handler(event: dict, context: LambdaContext) -> Dict[str, Any]: + parameters_to_fetch: Dict[str, Any] = {param: {} for param in parameters_list} + + # response`{parameter:value}` + return get_parameters_by_name(parameters=parameters_to_fetch, max_age=0) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..810e0f101d4c70c70ede63601b40418f7d9c7bc3 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/infrastructure.py @@ -0,0 +1,139 @@ +import json +from typing import List + +from aws_cdk import CfnOutput, Duration +from aws_cdk import aws_appconfig as appconfig +from aws_cdk import aws_iam as iam +from aws_cdk import aws_ssm as ssm +from aws_cdk.aws_lambda import Function + +from tests.e2e.utils.data_builder import build_random_value, build_service_name +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class ParametersStack(BaseInfrastructure): + def create_resources(self): + parameters = self._create_ssm_parameters() + + env_vars = {"parameters": json.dumps(parameters)} + functions = self.create_lambda_functions( + function_props={"environment": env_vars, "timeout": Duration.seconds(30)}, + ) + + self._create_app_config(function=functions["ParameterAppconfigFreeformHandler"]) + + # NOTE: Enforce least-privilege for our param tests only + functions["ParameterSsmGetParametersByName"].add_to_role_policy( + iam.PolicyStatement( + effect=iam.Effect.ALLOW, + actions=[ + "ssm:GetParameters", + ], + resources=[f"arn:aws:ssm:{self.region}:{self.account_id}:parameter/powertools/e2e/parameters/*"], + ), + ) + + def _create_app_config(self, function: Function): + service_name = build_service_name() + + cfn_application = appconfig.CfnApplication( + self.stack, + id="appconfig-app", + name=f"powertools-e2e-{service_name}", + description="Powertools for AWS Lambda (Python) End-to-End testing for AppConfig", + ) + CfnOutput(self.stack, "AppConfigApplication", value=cfn_application.name) + + cfn_environment = appconfig.CfnEnvironment( + self.stack, + "appconfig-env", + application_id=cfn_application.ref, + name=f"powertools-e2e{service_name}", + description="Powertools for AWS Lambda (Python) End-to-End testing environment", + ) + CfnOutput(self.stack, "AppConfigEnvironment", value=cfn_environment.name) + + cfn_deployment_strategy = appconfig.CfnDeploymentStrategy( + self.stack, + "appconfig-deployment-strategy", + deployment_duration_in_minutes=0, + final_bake_time_in_minutes=0, + growth_factor=100, + name=f"deploymente2e{service_name}", + description="deploymente2e", + replicate_to="NONE", + growth_type="LINEAR", + ) + + self._create_app_config_freeform( + app=cfn_application, + environment=cfn_environment, + strategy=cfn_deployment_strategy, + function=function, + service_name=service_name, + ) + + def _create_app_config_freeform( + self, + app: appconfig.CfnApplication, + environment: appconfig.CfnEnvironment, + strategy: appconfig.CfnDeploymentStrategy, + function: Function, + service_name: str, + ): + cfn_configuration_profile = appconfig.CfnConfigurationProfile( + self.stack, + "appconfig-profile", + application_id=app.ref, + location_uri="hosted", + type="AWS.Freeform", + name=f"profilee2e{service_name}", + description="profilee2e", + ) + CfnOutput(self.stack, "AppConfigProfile", value=cfn_configuration_profile.name) + + cfn_hosted_configuration_version = appconfig.CfnHostedConfigurationVersion( + self.stack, + "appconfig-hosted-deploy", + application_id=app.ref, + configuration_profile_id=cfn_configuration_profile.ref, + content='{"save_history": {"default": true}}', + content_type="application/json", + description="hostedconfiguratione2e", + ) + CfnOutput(self.stack, "AppConfigConfigurationValue", value=cfn_hosted_configuration_version.content) + + appconfig.CfnDeployment( + self.stack, + "appconfig-deployment", + application_id=app.ref, + configuration_profile_id=cfn_configuration_profile.ref, + configuration_version=cfn_hosted_configuration_version.ref, + deployment_strategy_id=strategy.ref, + environment_id=environment.ref, + description="deployment", + ) + + function.add_to_role_policy( + iam.PolicyStatement( + effect=iam.Effect.ALLOW, + actions=[ + "appconfig:GetLatestConfiguration", + "appconfig:StartConfigurationSession", + ], + resources=["*"], + ), + ) + + def _create_ssm_parameters(self) -> List[str]: + parameters: List[str] = [] + + for _ in range(10): + param = f"/powertools/e2e/parameters/{build_random_value()}" + rand = build_random_value() + ssm.StringParameter(self.stack, f"param-{rand}", parameter_name=param, string_value=rand) + parameters.append(param) + + CfnOutput(self.stack, "ParametersNameList", value=json.dumps(parameters)) + + return parameters diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/test_appconfig.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/test_appconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..28f50a653f46f0b23477bfdc8f717b6b011c5080 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/test_appconfig.py @@ -0,0 +1,63 @@ +import json + +import pytest + +from tests.e2e.utils import data_fetcher + + +@pytest.fixture +def parameter_appconfig_freeform_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("ParameterAppconfigFreeformHandlerArn", "") + + +@pytest.fixture +def parameter_appconfig_freeform_handler_fn(infrastructure: dict) -> str: + return infrastructure.get("ParameterAppconfigFreeformHandler", "") + + +@pytest.fixture +def parameter_appconfig_freeform_value(infrastructure: dict) -> str: + return infrastructure.get("AppConfigConfigurationValue", "") + + +@pytest.fixture +def parameter_appconfig_freeform_application(infrastructure: dict) -> str: + return infrastructure.get("AppConfigApplication", "") + + +@pytest.fixture +def parameter_appconfig_freeform_environment(infrastructure: dict) -> str: + return infrastructure.get("AppConfigEnvironment", "") + + +@pytest.fixture +def parameter_appconfig_freeform_profile(infrastructure: dict) -> str: + return infrastructure.get("AppConfigProfile", "") + + +@pytest.mark.xdist_group(name="parameters") +def test_get_parameter_appconfig_freeform( + parameter_appconfig_freeform_handler_fn_arn: str, + parameter_appconfig_freeform_value: str, + parameter_appconfig_freeform_application: str, + parameter_appconfig_freeform_environment: str, + parameter_appconfig_freeform_profile: str, +): + # GIVEN + payload = json.dumps( + { + "name": parameter_appconfig_freeform_profile, + "environment": parameter_appconfig_freeform_environment, + "application": parameter_appconfig_freeform_application, + }, + ) + expected_return = parameter_appconfig_freeform_value + + # WHEN + parameter_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=parameter_appconfig_freeform_handler_fn_arn, + payload=payload, + ) + parameter_value = parameter_execution["Payload"].read().decode("utf-8") + + assert parameter_value == expected_return diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/test_ssm.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/test_ssm.py new file mode 100644 index 0000000000000000000000000000000000000000..239813fab5178eb52286cff640f0fe82c707b1da --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parameters/test_ssm.py @@ -0,0 +1,34 @@ +import json +from typing import Any, Dict, List + +import pytest + +from tests.e2e.utils import data_fetcher + + +@pytest.fixture +def ssm_get_parameters_by_name_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("ParameterSsmGetParametersByNameArn", "") + + +@pytest.fixture +def parameters_list(infrastructure: dict) -> List[str]: + param_list = infrastructure.get("ParametersNameList", "[]") + return json.loads(param_list) + + +@pytest.mark.xdist_group(name="parameters") +def test_get_parameters_by_name( + ssm_get_parameters_by_name_fn_arn: str, + parameters_list: str, +): + # GIVEN/WHEN + function_response, _ = data_fetcher.get_lambda_response(lambda_arn=ssm_get_parameters_by_name_fn_arn) + parameter_values: Dict[str, Any] = json.loads(function_response["Payload"].read().decode("utf-8")) + + # THEN + for param in parameters_list: + try: + assert parameter_values[param] is not None + except (KeyError, TypeError): + pytest.fail(f"Parameter {param} not found in response") diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..d7ef0aa0176b331510b03b46759ffec6b63dc5d4 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.parser.infrastructure import ParserStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = ParserStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_basic_model.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_basic_model.py new file mode 100644 index 0000000000000000000000000000000000000000..7b0d89dda53cd5f734d8974f220b4375c9670382 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_basic_model.py @@ -0,0 +1,14 @@ +from pydantic import BaseModel + +from aws_lambda_powertools.utilities.parser import event_parser +from aws_lambda_powertools.utilities.typing import LambdaContext + + +class BasicModel(BaseModel): + product: str + version: str + + +@event_parser +def lambda_handler(event: BasicModel, context: LambdaContext): + return {"product": event.product} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_dataclass.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_dataclass.py new file mode 100644 index 0000000000000000000000000000000000000000..7f465fe79ecb3d957f96be05e8394217b5942137 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_dataclass.py @@ -0,0 +1,15 @@ +from dataclasses import dataclass + +from aws_lambda_powertools.utilities.parser import event_parser +from aws_lambda_powertools.utilities.typing import LambdaContext + + +@dataclass +class BasicDataclass: + product: str + version: str + + +@event_parser +def lambda_handler(event: BasicDataclass, context: LambdaContext): + return {"product": event.product} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_model_type_class.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_model_type_class.py new file mode 100644 index 0000000000000000000000000000000000000000..7e635dee13a17c40cae01806a4e86ec9a9808e3f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_model_type_class.py @@ -0,0 +1,23 @@ +import json +from typing import Any, Dict, Type, Union + +from pydantic import BaseModel + +from aws_lambda_powertools.utilities.parser import parse +from aws_lambda_powertools.utilities.typing import LambdaContext + +AnyInheritedModel = Union[Type[BaseModel], BaseModel] +RawDictOrModel = Union[Dict[str, Any], AnyInheritedModel] + + +class ModelWithUnionType(BaseModel): + name: str + profile: RawDictOrModel + + +def lambda_handler(event: ModelWithUnionType, context: LambdaContext): + event = json.dumps(event) + + event_parsed = parse(event=event, model=ModelWithUnionType) + + return {"name": event_parsed.name} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_union_tag.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_union_tag.py new file mode 100644 index 0000000000000000000000000000000000000000..e2013251d8f2b8d0208b6f0c845743e41efc66b2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/handlers/handler_with_union_tag.py @@ -0,0 +1,31 @@ +from typing import Literal, Union + +from pydantic import BaseModel, Field +from typing_extensions import Annotated + +from aws_lambda_powertools.utilities.parser import event_parser +from aws_lambda_powertools.utilities.typing import LambdaContext + + +class SuccessCallback(BaseModel): + order_id: str + status: Literal["success"] + error_msg: str + + +class ErrorCallback(BaseModel): + status: Literal["error"] + error_msg: str + + +class PartialFailureCallback(BaseModel): + status: Literal["partial"] + error_msg: str + + +OrderCallback = Annotated[Union[SuccessCallback, ErrorCallback, PartialFailureCallback], Field(discriminator="status")] + + +@event_parser +def lambda_handler(event: OrderCallback, context: LambdaContext): + return {"error_msg": event.error_msg} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..5d66905e7c736a27019894639099cd79ff6529d1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/infrastructure.py @@ -0,0 +1,6 @@ +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class ParserStack(BaseInfrastructure): + def create_resources(self): + self.create_lambda_functions() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/test_parser.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/test_parser.py new file mode 100644 index 0000000000000000000000000000000000000000..aa52889aeabde9052b229170f7dfa94e4ade5699 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/parser/test_parser.py @@ -0,0 +1,89 @@ +import json + +import pytest + +from tests.e2e.utils import data_fetcher + + +@pytest.fixture +def handler_with_basic_model_arn(infrastructure: dict) -> str: + return infrastructure.get("HandlerWithBasicModelArn", "") + + +@pytest.fixture +def handler_with_union_tag_arn(infrastructure: dict) -> str: + return infrastructure.get("HandlerWithUnionTagArn", "") + + +@pytest.fixture +def handler_with_dataclass_arn(infrastructure: dict) -> str: + return infrastructure.get("HandlerWithDataclass", "") + + +@pytest.fixture +def handler_with_type_model_class(infrastructure: dict) -> str: + return infrastructure.get("HandlerWithModelTypeClass", "") + + +@pytest.mark.xdist_group(name="parser") +def test_parser_with_basic_model(handler_with_basic_model_arn): + # GIVEN + payload = json.dumps({"product": "powertools", "version": "v3"}) + + # WHEN + parser_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=handler_with_basic_model_arn, + payload=payload, + ) + + ret = parser_execution["Payload"].read().decode("utf-8") + + assert "powertools" in ret + + +@pytest.mark.xdist_group(name="parser") +def test_parser_with_union_tag(handler_with_union_tag_arn): + # GIVEN + payload = json.dumps({"status": "partial", "error_msg": "partial failure"}) + + # WHEN + parser_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=handler_with_union_tag_arn, + payload=payload, + ) + + ret = parser_execution["Payload"].read().decode("utf-8") + + assert "partial failure" in ret + + +@pytest.mark.xdist_group(name="parser") +def test_parser_with_dataclass(handler_with_dataclass_arn): + # GIVEN + payload = json.dumps({"product": "powertools", "version": "v3"}) + + # WHEN + parser_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=handler_with_dataclass_arn, + payload=payload, + ) + + ret = parser_execution["Payload"].read().decode("utf-8") + + assert "powertools" in ret + + +@pytest.mark.xdist_group(name="parser") +def test_parser_with_type_model(handler_with_type_model_class): + # GIVEN + payload = json.dumps({"name": "powertools", "profile": {"description": "python", "size": "XXL"}}) + + # WHEN + parser_execution, _ = data_fetcher.get_lambda_response( + lambda_arn=handler_with_type_model_class, + payload=payload, + ) + + ret = parser_execution["Payload"].read().decode("utf-8") + + assert "powertools" in ret diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/pytest.ini b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/pytest.ini new file mode 100644 index 0000000000000000000000000000000000000000..3fc35fa5847c2d3d22fcdd99760c26b79358fb09 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/pytest.ini @@ -0,0 +1,2 @@ +[pytest] +addopts = -ra -vv --dist loadgroup \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/csv.txt b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/csv.txt new file mode 100644 index 0000000000000000000000000000000000000000..cfc6a96e553c349371a84688fc33290ad9f14283 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/csv.txt @@ -0,0 +1,2 @@ +name,value +hello,world diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/fileset.zip.lzma b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/fileset.zip.lzma new file mode 100644 index 0000000000000000000000000000000000000000..964c0b33553197fe402d929e57bf3eda52d8d308 Binary files /dev/null and b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/fileset.zip.lzma differ diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/plain.txt b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/plain.txt new file mode 100644 index 0000000000000000000000000000000000000000..3b18e512dba79e4c8300dd08aeb37f8e728b8dad --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/assets/plain.txt @@ -0,0 +1 @@ +hello world diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..94f7f212af0fa23229af4edd2c79b605c27e4280 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/conftest.py @@ -0,0 +1,19 @@ +import pytest + +from tests.e2e.streaming.infrastructure import StreamingStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = StreamingStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/handlers/s3_object_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/handlers/s3_object_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..3c47f4ab3b7ac5b853e5ab4c96de79da55dfea78 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/handlers/s3_object_handler.py @@ -0,0 +1,84 @@ +import zipfile + +import botocore.exceptions + +from aws_lambda_powertools.utilities.streaming import S3Object +from aws_lambda_powertools.utilities.streaming.transformations import ( + CsvTransform, + GzipTransform, + ZipTransform, +) + +""" +Event schema + +bucket: str +key: str +version_id: str, optional + +is_gzip: bool, optional +is_csv: bool, optional + +transform_gunzip: bool, optional +transform_csv: bool, optional +transform_zip: bool, optional +transform_zip_lzma: bool, optional + +transform_in_place: bool, optional +""" + + +def lambda_handler(event, context): + bucket = event.get("bucket") + key = event.get("key") + version_id = event.get("version_id", None) + + gunzip = event.get("is_gzip", False) + csv = event.get("is_csv", False) + + transform_gzip = event.get("transform_gzip", False) + transform_csv = event.get("transform_csv", False) + transform_zip = event.get("transform_zip", False) + transform_zip_lzma = event.get("transform_zip_lzma", False) + transform_in_place = event.get("transform_in_place", False) + + response = {} + + try: + obj = S3Object(bucket=bucket, key=key, version_id=version_id, is_gzip=gunzip, is_csv=csv) + response["size"] = obj.size + + transformations = [] + if transform_gzip: + transformations.append(GzipTransform()) + if transform_zip: + transformations.append(ZipTransform()) + if transform_csv: + transformations.append(CsvTransform()) + if transform_zip_lzma: + transformations.append(ZipTransform(compression=zipfile.ZIP_LZMA)) + + if len(transformations) > 0: + if transform_in_place: + obj.transform(transformations, in_place=True) + else: + obj = obj.transform(transformations) + + if transform_zip or transform_zip_lzma: + response["manifest"] = obj.namelist() + response["body"] = ( + obj.read(obj.namelist()[1]).rstrip().decode("utf-8") + ) # extracts the second file on the zip + elif transform_csv or csv: + response["body"] = obj.__next__() + elif transform_gzip or gunzip: + response["body"] = obj.readline().rstrip().decode("utf-8") + else: + response["body"] = obj.readline().rstrip().decode("utf-8") + except botocore.exceptions.ClientError as e: + if e.response["Error"]["Code"] == "404": + response["error"] = "Not found" + else: + raise + + return response diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..31152c69535329b76d82ec2b1803ac4a9ee74a58 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/infrastructure.py @@ -0,0 +1,52 @@ +from pathlib import Path + +from aws_cdk import CfnOutput, Duration, RemovalPolicy +from aws_cdk import aws_s3 as s3 +from aws_cdk import aws_s3_deployment as s3deploy + +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class StreamingStack(BaseInfrastructure): + def create_resources(self): + functions = self.create_lambda_functions(function_props={"timeout": Duration.seconds(10)}) + + regular_bucket = s3.Bucket( + self.stack, + "S3Bucket", + removal_policy=RemovalPolicy.DESTROY, + auto_delete_objects=True, + block_public_access=s3.BlockPublicAccess.BLOCK_ALL, + ) + self.create_s3_deployment(regular_bucket) + + for function in functions.values(): + regular_bucket.grant_read(function) + + CfnOutput(self.stack, "RegularBucket", value=regular_bucket.bucket_name) + + versioned_bucket = s3.Bucket( + self.stack, + "S3VersionedBucket", + versioned=True, + removal_policy=RemovalPolicy.DESTROY, + auto_delete_objects=True, + block_public_access=s3.BlockPublicAccess.BLOCK_ALL, + ) + self.create_s3_deployment(versioned_bucket) + + for function in functions.values(): + versioned_bucket.grant_read(function) + + CfnOutput(self.stack, "VersionedBucket", value=versioned_bucket.bucket_name) + + def create_s3_deployment(self, bucket: s3.IBucket): + current_dir = Path(__file__).parent.resolve() + sources = [s3deploy.Source.asset(str(current_dir / "assets"))] + + s3deploy.BucketDeployment( + self.stack, + f"Deployment{bucket.node.id}", + sources=sources, + destination_bucket=bucket, + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/test_s3_object.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/test_s3_object.py new file mode 100644 index 0000000000000000000000000000000000000000..4a16c58b2b6e967f985408dc8f3bf57c8dc5f6e3 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/streaming/test_s3_object.py @@ -0,0 +1,194 @@ +import json + +import boto3 +import pytest + +from tests.e2e.utils import data_fetcher + + +@pytest.fixture +def regular_bucket_name(infrastructure: dict) -> str: + return infrastructure.get("RegularBucket", "") + + +@pytest.fixture +def versioned_bucket_name(infrastructure: dict) -> str: + return infrastructure.get("VersionedBucket", "") + + +@pytest.fixture +def s3_object_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("S3ObjectHandler", "") + + +@pytest.mark.xdist_group(name="streaming") +def get_object_version(bucket, key) -> str: + s3 = boto3.client("s3") + versions = s3.list_object_versions(Bucket=bucket) + + for version in versions["Versions"]: + version_id = version["VersionId"] + version_key = version["Key"] + + if version_key == key: + return version_id + + raise ValueError(f"Cannot find versioned {key} inside {bucket}") + + +def get_lambda_result_payload(s3_object_handler_fn_arn: str, payload: dict) -> dict: + handler_result, _ = data_fetcher.get_lambda_response( + lambda_arn=s3_object_handler_fn_arn, + payload=json.dumps(payload), + ) + + return json.loads(handler_result["Payload"].read()) + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_size(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "plain.txt"} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("size") == 12 + assert result.get("body") == "hello world" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_versioned_object_size(s3_object_handler_fn_arn, versioned_bucket_name): + key = "plain.txt" + payload = { + "bucket": versioned_bucket_name, + "key": key, + "version_id": get_object_version(versioned_bucket_name, key), + } + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("size") == 12 + assert result.get("body") == "hello world" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_non_existent(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "NOTEXISTENT.txt"} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("error") == "Not found" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_csv_constructor(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "csv.txt", "is_csv": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == {"name": "hello", "value": "world"} + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_versioned_object_csv_constructor(s3_object_handler_fn_arn, versioned_bucket_name): + key = "csv.txt" + payload = { + "bucket": versioned_bucket_name, + "key": key, + "version_id": get_object_version(versioned_bucket_name, key), + "is_csv": True, + } + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == {"name": "hello", "value": "world"} + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_csv_transform(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "csv.txt", "transform_csv": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == {"name": "hello", "value": "world"} + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_csv_transform_in_place(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "csv.txt", "transform_csv": True, "in_place": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == {"name": "hello", "value": "world"} + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_csv_gzip_constructor(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "csv.txt.gz", "is_csv": True, "is_gzip": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == {"name": "hello", "value": "world"} + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_versioned_object_csv_gzip_constructor(s3_object_handler_fn_arn, versioned_bucket_name): + key = "csv.txt.gz" + payload = { + "bucket": versioned_bucket_name, + "key": key, + "version_id": get_object_version(versioned_bucket_name, key), + "is_csv": True, + "is_gzip": True, + } + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == {"name": "hello", "value": "world"} + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_gzip_constructor(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "plain.txt.gz", "is_gzip": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == "hello world" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_versioned_object_gzip_constructor(s3_object_handler_fn_arn, versioned_bucket_name): + key = "plain.txt.gz" + payload = { + "bucket": versioned_bucket_name, + "key": key, + "version_id": get_object_version(versioned_bucket_name, key), + "is_gzip": True, + } + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == "hello world" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_gzip_transform(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "plain.txt.gz", "transform_gzip": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == "hello world" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_gzip_transform_in_place(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "plain.txt.gz", "transform_gzip": True, "in_place": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("body") == "hello world" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_zip_transform(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "fileset.zip", "transform_zip": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("manifest") == ["1.txt", "2.txt"] + assert result.get("body") == "This is file 2" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_zip_transform_in_place(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "fileset.zip", "transform_zip": True, "in_place": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("manifest") == ["1.txt", "2.txt"] + assert result.get("body") == "This is file 2" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_zip_lzma_transform(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "fileset.zip.lzma", "transform_zip_lzma": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("manifest") == ["1.txt", "2.txt"] + assert result.get("body") == "This is file 2" + + +@pytest.mark.xdist_group(name="streaming") +def test_s3_object_zip_lzma_transform_in_place(s3_object_handler_fn_arn, regular_bucket_name): + payload = {"bucket": regular_bucket_name, "key": "fileset.zip.lzma", "transform_zip_lzma": True, "in_place": True} + result = get_lambda_result_payload(s3_object_handler_fn_arn, payload) + assert result.get("manifest") == ["1.txt", "2.txt"] + assert result.get("body") == "This is file 2" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..d3728ab91ba04aa252fc9b7d5a63f606f9b63b9a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/conftest.py @@ -0,0 +1,20 @@ +import pytest + +from tests.e2e.tracer.infrastructure import TracerStack + + +@pytest.fixture(autouse=True, scope="package") +def infrastructure(): + """Setup and teardown logic for E2E test infrastructure + + + Yields + ------ + Dict[str, str] + CloudFormation Outputs from deployed infrastructure + """ + stack = TracerStack() + try: + yield stack.deploy() + finally: + stack.delete() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/async_capture.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/async_capture.py new file mode 100644 index 0000000000000000000000000000000000000000..814e0b92e02b186b6671550faf48aff4b0da74f4 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/async_capture.py @@ -0,0 +1,17 @@ +import asyncio +from uuid import uuid4 + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +@tracer.capture_method +async def async_get_users(): + return [{"id": f"{uuid4()}"} for _ in range(5)] + + +def lambda_handler(event: dict, context: LambdaContext): + tracer.service = event.get("service") + return asyncio.run(async_get_users()) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/basic_handler.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/basic_handler.py new file mode 100644 index 0000000000000000000000000000000000000000..89a6b062423c965eb6cbf3347a3a58c07208c5d2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/basic_handler.py @@ -0,0 +1,17 @@ +from uuid import uuid4 + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +@tracer.capture_method +def get_todos(): + return [{"id": f"{uuid4()}", "completed": False} for _ in range(5)] + + +@tracer.capture_lambda_handler +def lambda_handler(event: dict, context: LambdaContext): + tracer.service = event.get("service") + return get_todos() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/same_function_name.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/same_function_name.py new file mode 100644 index 0000000000000000000000000000000000000000..240e3329bc8d767e2410b5f653cc5fe5bb830289 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/handlers/same_function_name.py @@ -0,0 +1,35 @@ +from abc import ABC, abstractmethod +from uuid import uuid4 + +from aws_lambda_powertools import Tracer +from aws_lambda_powertools.utilities.typing import LambdaContext + +tracer = Tracer() + + +class MainAbstractClass(ABC): + @abstractmethod + def get_all(self): + raise NotImplementedError + + +class Comments(MainAbstractClass): + @tracer.capture_method + def get_all(self): + return [{"id": f"{uuid4()}", "completed": False} for _ in range(5)] + + +class Todos(MainAbstractClass): + @tracer.capture_method + def get_all(self): + return [{"id": f"{uuid4()}", "completed": False} for _ in range(5)] + + +def lambda_handler(event: dict, context: LambdaContext): + # Maintenance: create a public method to set these explicitly + tracer.service = event["service"] + + todos = Todos() + comments = Comments() + + return {"todos": todos.get_all(), "comments": comments.get_all()} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..8562359acf01003154f59dbf36c0f7e6161fb5ea --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/infrastructure.py @@ -0,0 +1,6 @@ +from tests.e2e.utils.infrastructure import BaseInfrastructure + + +class TracerStack(BaseInfrastructure): + def create_resources(self) -> None: + self.create_lambda_functions() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/test_tracer.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/test_tracer.py new file mode 100644 index 0000000000000000000000000000000000000000..5dfe68ee08c56ced2d3120bac01635ed04e7a8bd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/tracer/test_tracer.py @@ -0,0 +1,113 @@ +import json + +import pytest + +from tests.e2e.tracer.handlers import async_capture, basic_handler +from tests.e2e.utils import data_builder, data_fetcher + + +@pytest.fixture +def basic_handler_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("BasicHandlerArn", "") + + +@pytest.fixture +def basic_handler_fn(infrastructure: dict) -> str: + return infrastructure.get("BasicHandler", "") + + +@pytest.fixture +def same_function_name_fn(infrastructure: dict) -> str: + return infrastructure.get("SameFunctionName", "") + + +@pytest.fixture +def same_function_name_arn(infrastructure: dict) -> str: + return infrastructure.get("SameFunctionNameArn", "") + + +@pytest.fixture +def async_fn_arn(infrastructure: dict) -> str: + return infrastructure.get("AsyncCaptureArn", "") + + +@pytest.fixture +def async_fn(infrastructure: dict) -> str: + return infrastructure.get("AsyncCapture", "") + + +@pytest.mark.xdist_group(name="tracer") +def test_lambda_handler_trace_is_visible(basic_handler_fn_arn: str, basic_handler_fn: str): + # GIVEN + service = data_builder.build_service_name() + handler_name = basic_handler.lambda_handler.__name__ + handler_subsegment = f"## {handler_name}" + handler_metadata_key = f"{handler_name} response" + + method_name = f"basic_handler.{basic_handler.get_todos.__name__}" + method_subsegment = f"## {method_name}" + method_metadata_key = f"{method_name} response" + + trace_query = data_builder.build_trace_default_query(function_name=basic_handler_fn) + + # WHEN + event = json.dumps({"service": service}) + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=basic_handler_fn_arn, payload=event) + data_fetcher.get_lambda_response(lambda_arn=basic_handler_fn_arn, payload=event) + + # THEN + trace = data_fetcher.get_traces(start_date=execution_time, filter_expression=trace_query, minimum_traces=2) + + assert len(trace.get_annotation(key="ColdStart", value=True)) == 1 + assert len(trace.get_metadata(key=handler_metadata_key, namespace=service)) == 2 + assert len(trace.get_metadata(key=method_metadata_key, namespace=service)) == 2 + assert len(trace.get_subsegment(name=handler_subsegment)) == 2 + assert len(trace.get_subsegment(name=method_subsegment)) == 2 + + +@pytest.mark.xdist_group(name="tracer") +def test_lambda_handler_trace_multiple_functions_same_name(same_function_name_arn: str, same_function_name_fn: str): + # GIVEN + service = data_builder.build_service_name() + method_name_todos = "same_function_name.Todos.get_all" + method_subsegment_todos = f"## {method_name_todos}" + method_metadata_key_todos = f"{method_name_todos} response" + + method_name_comments = "same_function_name.Comments.get_all" + method_subsegment_comments = f"## {method_name_comments}" + method_metadata_key_comments = f"{method_name_comments} response" + + trace_query = data_builder.build_trace_default_query(function_name=same_function_name_fn) + + # WHEN + event = json.dumps({"service": service}) + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=same_function_name_arn, payload=event) + + # THEN + trace = data_fetcher.get_traces(start_date=execution_time, filter_expression=trace_query) + + assert len(trace.get_metadata(key=method_metadata_key_todos, namespace=service)) == 1 + assert len(trace.get_metadata(key=method_metadata_key_comments, namespace=service)) == 1 + assert len(trace.get_subsegment(name=method_subsegment_todos)) == 1 + assert len(trace.get_subsegment(name=method_subsegment_comments)) == 1 + + +@pytest.mark.xdist_group(name="tracer") +def test_async_trace_is_visible(async_fn_arn: str, async_fn: str): + # GIVEN + service = data_builder.build_service_name() + async_fn_name = f"async_capture.{async_capture.async_get_users.__name__}" + async_fn_name_subsegment = f"## {async_fn_name}" + async_fn_name_metadata_key = f"{async_fn_name} response" + + trace_query = data_builder.build_trace_default_query(function_name=async_fn) + + # WHEN + event = json.dumps({"service": service}) + _, execution_time = data_fetcher.get_lambda_response(lambda_arn=async_fn_arn, payload=event) + + # THEN + trace = data_fetcher.get_traces(start_date=execution_time, filter_expression=trace_query) + + assert len(trace.get_subsegment(name=async_fn_name_subsegment)) == 1 + assert len(trace.get_metadata(key=async_fn_name_metadata_key, namespace=service)) == 1 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/auth.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/auth.py new file mode 100644 index 0000000000000000000000000000000000000000..124a2e9a13b6192f6fd1e3ef046beb95967093af --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/auth.py @@ -0,0 +1,13 @@ +from urllib.parse import urlparse + +import boto3 +from aws_requests_auth.boto_utils import BotoAWSRequestsAuth + + +def build_iam_auth(url: str, aws_service: str) -> BotoAWSRequestsAuth: + """Generates IAM auth keys for a given hostname and service. + This can be directly passed on to the requests library to authenticate the request. + """ + hostname = urlparse(url).hostname + region = boto3.session.Session().region_name + return BotoAWSRequestsAuth(aws_host=hostname, aws_region=region, aws_service=aws_service) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/base.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/base.py new file mode 100644 index 0000000000000000000000000000000000000000..2a6e6032e52499bf14d6f74abbf96deb2560c42a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/base.py @@ -0,0 +1,20 @@ +from abc import ABC, abstractmethod +from typing import Dict, Optional + + +class InfrastructureProvider(ABC): + @abstractmethod + def create_lambda_functions(self, function_props: Optional[Dict] = None) -> Dict: + pass + + @abstractmethod + def deploy(self) -> Dict[str, str]: + pass + + @abstractmethod + def delete(self): + pass + + @abstractmethod + def create_resources(self): + pass diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/constants.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..445c9f00113d8580c3afbcd512c1ed3d20125a45 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/constants.py @@ -0,0 +1,8 @@ +import sys + +from aws_lambda_powertools import PACKAGE_PATH + +PYTHON_RUNTIME_VERSION = f"V{''.join(map(str, sys.version_info[:2]))}" +SOURCE_CODE_ROOT_PATH = PACKAGE_PATH.parent +CDK_OUT_PATH = SOURCE_CODE_ROOT_PATH / "cdk.out" +LAYER_BUILD_PATH = CDK_OUT_PATH / "layer_build" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..72c216faa76a1a152f7ee79ab80634b3cda4fdbc --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/__init__.py @@ -0,0 +1,13 @@ +from tests.e2e.utils.data_builder.common import build_random_value, build_service_name +from tests.e2e.utils.data_builder.metrics import ( + build_add_dimensions_input, + build_add_metric_input, + build_metric_name, + build_metric_query_data, + build_multiple_add_metric_input, +) +from tests.e2e.utils.data_builder.traces import ( + build_put_annotations_input, + build_put_metadata_input, + build_trace_default_query, +) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/common.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/common.py new file mode 100644 index 0000000000000000000000000000000000000000..f28778ffed31d4139b0b2f68f1041f7a36405e3e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/common.py @@ -0,0 +1,9 @@ +import secrets + + +def build_service_name() -> str: + return f"test_service{build_random_value()}" + + +def build_random_value(nbytes: int = 10) -> str: + return secrets.token_urlsafe(nbytes).replace("-", "") diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/metrics.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..55d728c3b31ea252be939a25d2128c83de009960 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/metrics.py @@ -0,0 +1,119 @@ +from typing import Dict, List, Optional + +from mypy_boto3_cloudwatch.type_defs import DimensionTypeDef, MetricDataQueryTypeDef + +from aws_lambda_powertools.metrics import MetricUnit +from tests.e2e.utils.data_builder.common import build_random_value + + +def build_metric_query_data( + namespace: str, + metric_name: str, + period: int = 60, + stat: str = "Sum", + dimensions: Optional[List[DimensionTypeDef]] = None, +) -> List[MetricDataQueryTypeDef]: + """Create input for CloudWatch GetMetricData API call + + Parameters + ---------- + namespace : str + Metric namespace to search for + metric_name : str + Metric name to search for + period : int, optional + Time period in seconds to search metrics, by default 60 + stat : str, optional + Aggregate function to use for results, by default "Sum" + dimensions : Optional[List[DimensionTypeDef]], optional + Metric dimensions to search for, by default None + + Returns + ------- + List[MetricDataQueryTypeDef] + _description_ + """ + dimensions = dimensions or [] + data_query: List[MetricDataQueryTypeDef] = [ + { + "Id": metric_name.lower(), + "MetricStat": { + "Metric": {"Namespace": namespace, "MetricName": metric_name}, + "Period": period, + "Stat": stat, + }, + "ReturnData": True, + }, + ] + + if dimensions: + data_query[0]["MetricStat"]["Metric"]["Dimensions"] = dimensions + + return data_query + + +def build_add_metric_input(metric_name: str, value: float, unit: str = MetricUnit.Count.value) -> Dict: + """Create a metric input to be used with Metrics.add_metric() + + Parameters + ---------- + metric_name : str + metric name + value : float + metric value + unit : str, optional + metric unit, by default Count + + Returns + ------- + Dict + Metric input + """ + return {"name": metric_name, "unit": unit, "value": value} + + +def build_multiple_add_metric_input( + metric_name: str, + value: float, + unit: str = MetricUnit.Count.value, + quantity: int = 1, +) -> List[Dict]: + """Create list of metrics input to be used with Metrics.add_metric() + + Parameters + ---------- + metric_name : str + metric name + value : float + metric value + unit : str, optional + metric unit, by default Count + quantity : int, optional + number of metrics to be created, by default 1 + + Returns + ------- + List[Dict] + List of metrics + """ + return [{"name": metric_name, "unit": unit, "value": value} for _ in range(quantity)] + + +def build_add_dimensions_input(**dimensions) -> List[DimensionTypeDef]: + """Create dimensions input to be used with either get_metrics or Metrics.add_dimension() + + Parameters + ---------- + dimensions : str + key=value pair as dimension + + Returns + ------- + List[DimensionTypeDef] + Metric dimension input + """ + return [{"Name": name, "Value": value} for name, value in dimensions.items()] + + +def build_metric_name() -> str: + return f"test_metric{build_random_value()}" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/traces.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/traces.py new file mode 100644 index 0000000000000000000000000000000000000000..e6356582a30557980e27de092bd21e81fd99d9b2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_builder/traces.py @@ -0,0 +1,39 @@ +from typing import Any, Dict, List, Optional + + +def build_trace_default_query(function_name: str) -> str: + return f'service(id(name: "{function_name}"))' + + +def build_put_annotations_input(**annotations: str) -> List[Dict]: + """Create trace annotations input to be used with Tracer.put_annotation() + + Parameters + ---------- + annotations : str + annotations in key=value form + + Returns + ------- + List[Dict] + List of put annotations input + """ + return [{"key": key, "value": value} for key, value in annotations.items()] + + +def build_put_metadata_input(namespace: Optional[str] = None, **metadata: Any) -> List[Dict]: + """Create trace metadata input to be used with Tracer.put_metadata() + + All metadata will be under `test` namespace + + Parameters + ---------- + metadata : Any + metadata in key=value form + + Returns + ------- + List[Dict] + List of put metadata input + """ + return [{"key": key, "value": value, "namespace": namespace} for key, value in metadata.items()] diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fdd1de5c515e15d91ed89eaa602958f54d16c3fd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/__init__.py @@ -0,0 +1,5 @@ +from tests.e2e.utils.data_fetcher.common import get_http_response, get_lambda_response +from tests.e2e.utils.data_fetcher.idempotency import get_ddb_idempotency_record +from tests.e2e.utils.data_fetcher.logs import get_logs +from tests.e2e.utils.data_fetcher.metrics import get_metrics +from tests.e2e.utils.data_fetcher.traces import get_traces diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/common.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/common.py new file mode 100644 index 0000000000000000000000000000000000000000..1300daa55aa2179312f55b884c8303062f76aed7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/common.py @@ -0,0 +1,117 @@ +import functools +import time +from concurrent.futures import Future, ThreadPoolExecutor +from datetime import datetime +from typing import List, Optional, Tuple + +import boto3 +import requests +from mypy_boto3_lambda.client import LambdaClient +from mypy_boto3_lambda.type_defs import InvocationResponseTypeDef +from pydantic import BaseModel, ConfigDict +from requests import Request, Response +from requests.exceptions import RequestException +from retry import retry + +GetLambdaResponse = Tuple[InvocationResponseTypeDef, datetime] + + +class GetLambdaResponseOptions(BaseModel): + lambda_arn: str + payload: Optional[str] = None + client: Optional[LambdaClient] = None + raise_on_error: bool = True + + model_config = ConfigDict( + arbitrary_types_allowed=True, + ) + + +def get_lambda_response( + lambda_arn: str, + payload: Optional[str] = None, + client: Optional[LambdaClient] = None, + raise_on_error: bool = True, +) -> GetLambdaResponse: + """Invoke function synchronously + + Parameters + ---------- + lambda_arn : str + Lambda function ARN to invoke + payload : Optional[str], optional + JSON payload for Lambda invocation, by default None + client : Optional[LambdaClient], optional + Boto3 Lambda SDK client, by default None + raise_on_error : bool, optional + Whether to raise exception upon invocation error, by default True + + Returns + ------- + Tuple[InvocationResponseTypeDef, datetime] + Function response and approximate execution time + + Raises + ------ + RuntimeError + Function invocation error details + """ + client = client or boto3.client("lambda") + payload = payload or "" + execution_time = datetime.utcnow() + response: InvocationResponseTypeDef = client.invoke( + FunctionName=lambda_arn, + InvocationType="RequestResponse", + Payload=payload, + ) + + has_error = response.get("FunctionError", "") == "Unhandled" + if has_error and raise_on_error: + error_payload = response["Payload"].read().decode() + raise RuntimeError(f"Function failed invocation: {error_payload}") + + return response, execution_time + + +@retry(RequestException, delay=2, jitter=1.5, tries=5) +def get_http_response(request: Request) -> Response: + session = requests.Session() + result = session.send(request.prepare()) + result.raise_for_status() + return result + + +def get_lambda_response_in_parallel( + get_lambda_response_options: List[GetLambdaResponseOptions], +) -> List[GetLambdaResponse]: + """Invoke functions in parallel + + Parameters + ---------- + get_lambda_response_options : List[GetLambdaResponseOptions] + List of options to call get_lambda_response with + + Returns + ------- + List[GetLambdaResponse] + Function responses and approximate execution time + """ + result_list = [] + with ThreadPoolExecutor() as executor: + running_tasks: List[Future] = [] + for options in get_lambda_response_options: + # Sleep 0.5, 1, 1.5, ... seconds between each invocation. This way + # we can guarantee that lambdas are executed in parallel, but they are + # called in the same "order" as they are passed in, thus guaranteeing that + # we can assert on the correct output. + time.sleep(0.5 * len(running_tasks)) + + get_lambda_response_callback = functools.partial(get_lambda_response, **options.model_dump()) + running_tasks.append( + executor.submit(get_lambda_response_callback), + ) + + executor.shutdown(wait=True) + result_list.extend(running_task.result() for running_task in running_tasks) + + return result_list diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/idempotency.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/idempotency.py new file mode 100644 index 0000000000000000000000000000000000000000..109e6735d3b2af5505462f76593850687dfed9ad --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/idempotency.py @@ -0,0 +1,39 @@ +import boto3 +from retry import retry + + +@retry(ValueError, delay=2, jitter=1.5, tries=10) +def get_ddb_idempotency_record( + function_name: str, + table_name: str, +) -> int: + """_summary_ + + Parameters + ---------- + function_name : str + Name of Lambda function to fetch dynamodb record + table_name : str + Name of DynamoDB table + + Returns + ------- + int + Count of records found + + Raises + ------ + ValueError + When no record is found within retry window + """ + ddb_client = boto3.resource("dynamodb") + table = ddb_client.Table(table_name) + ret = table.scan( + FilterExpression="contains (id, :functionName)", + ExpressionAttributeValues={":functionName": f"{function_name}#"}, + ) + + if not ret["Items"]: + raise ValueError("Empty response from DynamoDB Repeating...") + + return ret["Count"] diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/logs.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/logs.py new file mode 100644 index 0000000000000000000000000000000000000000..dc036cba36e390322867291ae8a6745e5c2664ea --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/logs.py @@ -0,0 +1,164 @@ +import json +from datetime import datetime +from typing import List, Optional, Union + +import boto3 +from mypy_boto3_logs.client import CloudWatchLogsClient +from pydantic import BaseModel +from retry import retry + + +class Log(BaseModel, extra="allow"): + level: str + location: str + message: Union[dict, str] + timestamp: str + service: str + cold_start: Optional[bool] = None + function_name: Optional[str] = None + function_memory_size: Optional[str] = None + function_arn: Optional[str] = None + function_request_id: Optional[str] = None + xray_trace_id: Optional[str] = None + + +class LogFetcher: + def __init__( + self, + function_name: str, + start_time: datetime, + log_client: Optional[CloudWatchLogsClient] = None, + filter_expression: Optional[str] = None, + minimum_log_entries: int = 1, + ): + """Fetch and expose Powertools for AWS Lambda (Python) Logger logs from CloudWatch Logs + + Parameters + ---------- + function_name : str + Name of Lambda function to fetch logs for + start_time : datetime + Start date range to filter traces + log_client : Optional[CloudWatchLogsClient], optional + Amazon CloudWatch Logs Client, by default boto3.client('logs) + filter_expression : Optional[str], optional + CloudWatch Logs Filter Pattern expression, by default "message" + minimum_log_entries: int + Minimum number of log entries to be retrieved before exhausting retry attempts + """ + self.function_name = function_name + self.start_time = int(start_time.timestamp()) + self.log_client = log_client or boto3.client("logs") + self.filter_expression = filter_expression or "message" # Logger message key + self.log_group = f"/aws/lambda/{self.function_name}" + self.minimum_log_entries = minimum_log_entries + self.logs: List[Log] = self._get_logs() + + def get_log(self, key: str, value: Optional[any] = None) -> List[Log]: + """Get logs based on key or key and value + + Parameters + ---------- + key : str + Log key name + value : Optional[any], optional + Log value, by default None + + Returns + ------- + List[Log] + List of Log instances + """ + logs = [] + for log in self.logs: + log_value = getattr(log, key, None) + if value is not None and log_value == value: + logs.append(log) + elif value is None and hasattr(log, key): + logs.append(log) + return logs + + def get_cold_start_log(self) -> List[Log]: + """Get logs where cold start was true + + Returns + ------- + List[Log] + List of Log instances + """ + return [log for log in self.logs if log.cold_start] + + def have_keys(self, *keys) -> bool: + """Whether an arbitrary number of key names exist in each log event + + Returns + ------- + bool + Whether keys are present + """ + return all(hasattr(log, key) for log in self.logs for key in keys) + + def _get_logs(self) -> List[Log]: + ret = self.log_client.filter_log_events( + logGroupName=self.log_group, + startTime=self.start_time, + filterPattern=self.filter_expression, + ) + + if not ret["events"]: + raise ValueError("Empty response from Cloudwatch Logs. Repeating...") + + filtered_logs = [] + for event in ret["events"]: + try: + message = Log(**json.loads(event["message"])) + except json.decoder.JSONDecodeError: + continue + filtered_logs.append(message) + + if len(filtered_logs) < self.minimum_log_entries: + raise ValueError( + f"Number of log entries found doesn't meet minimum required ({self.minimum_log_entries}). Repeating...", + ) + + return filtered_logs + + def __len__(self) -> int: + return len(self.logs) + + +@retry(ValueError, delay=2, jitter=1.5, tries=10) +def get_logs( + function_name: str, + start_time: datetime, + minimum_log_entries: int = 1, + filter_expression: Optional[str] = None, + log_client: Optional[CloudWatchLogsClient] = None, +) -> LogFetcher: + """_summary_ + + Parameters + ---------- + function_name : str + Name of Lambda function to fetch logs for + start_time : datetime + Start date range to filter traces + minimum_log_entries : int + Minimum number of log entries to be retrieved before exhausting retry attempts + log_client : Optional[CloudWatchLogsClient], optional + Amazon CloudWatch Logs Client, by default boto3.client('logs) + filter_expression : Optional[str], optional + CloudWatch Logs Filter Pattern expression, by default "message" + + Returns + ------- + LogFetcher + LogFetcher instance with logs available as properties and methods + """ + return LogFetcher( + function_name=function_name, + start_time=start_time, + filter_expression=filter_expression, + log_client=log_client, + minimum_log_entries=minimum_log_entries, + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/metrics.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..361e7bdaf5d73888e1fc22e59b62d86c714157fa --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/metrics.py @@ -0,0 +1,75 @@ +from datetime import datetime, timedelta +from typing import List, Optional + +import boto3 +from mypy_boto3_cloudwatch.client import CloudWatchClient +from mypy_boto3_cloudwatch.type_defs import DimensionTypeDef +from retry import retry + +from tests.e2e.utils.data_builder import build_metric_query_data + + +@retry(ValueError, delay=2, jitter=1.5, tries=10) +def get_metrics( + namespace: str, + start_date: datetime, + metric_name: str, + dimensions: Optional[List[DimensionTypeDef]] = None, + cw_client: Optional[CloudWatchClient] = None, + end_date: Optional[datetime] = None, + period: int = 60, + stat: str = "Sum", +) -> List[float]: + """Fetch CloudWatch Metrics + + It takes into account eventual consistency with up to 10 retries and 1.5s jitter. + + Parameters + ---------- + namespace : str + Metric Namespace + start_date : datetime + Start window to fetch metrics + metric_name : str + Metric name + dimensions : Optional[List[DimensionTypeDef]], optional + List of Metric Dimension, by default None + cw_client : Optional[CloudWatchClient], optional + Boto3 CloudWatch low-level client (boto3.client("cloudwatch"), by default None + end_date : Optional[datetime], optional + End window to fetch metrics, by default start_date + 2 minutes window + period : int, optional + Time period to fetch metrics for, by default 60 + stat : str, optional + Aggregation function to use when fetching metrics, by default "Sum" + + Returns + ------- + List[float] + List with metric values found + + Raises + ------ + ValueError + When no metric is found within retry window + """ + cw_client = cw_client or boto3.client("cloudwatch") + end_date = end_date or start_date + timedelta(minutes=2) + + metric_query = build_metric_query_data( + namespace=namespace, + metric_name=metric_name, + period=period, + stat=stat, + dimensions=dimensions, + ) + + response = cw_client.get_metric_data( + MetricDataQueries=metric_query, + StartTime=start_date, + EndTime=end_date or datetime.utcnow(), + ) + result = response["MetricDataResults"][0]["Values"] + if not result: + raise ValueError("Empty response from Cloudwatch. Repeating...") + return result diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/traces.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/traces.py new file mode 100644 index 0000000000000000000000000000000000000000..d4c4dd298682d084c788f9f0996b23da4de695c7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/data_fetcher/traces.py @@ -0,0 +1,267 @@ +import json +from datetime import datetime, timedelta +from typing import Any, Dict, Generator, List, Optional + +import boto3 +from botocore.paginate import PageIterator +from mypy_boto3_xray.client import XRayClient +from mypy_boto3_xray.type_defs import TraceSummaryTypeDef +from pydantic import BaseModel +from retry import retry + + +class TraceSubsegment(BaseModel): + id: str # noqa: A003 VNE003 # id is a field we can't change + name: str + start_time: float + end_time: float + aws: Optional[dict] = None + subsegments: Optional[List["TraceSubsegment"]] = None + annotations: Optional[Dict[str, Any]] = None + metadata: Optional[Dict[str, Dict[str, Any]]] = None + + +class TraceDocument(BaseModel): + id: str # noqa: A003 VNE003 # id is a field we can't change + name: str + start_time: float + end_time: float + trace_id: str + parent_id: Optional[str] = None + aws: Dict + origin: str + subsegments: Optional[List[TraceSubsegment]] = None + + +class TraceFetcher: + default_exclude_seg_name: List = ["Initialization", "Invocation", "Overhead"] + + def __init__( + self, + filter_expression: str, + start_date: datetime, + end_date: Optional[datetime] = None, + xray_client: Optional[XRayClient] = None, + exclude_segment_name: Optional[List[str]] = None, + resource_name: Optional[List[str]] = None, + origin: Optional[List[str]] = None, + minimum_traces: int = 1, + ): + """Fetch and expose traces from X-Ray based on parameters + + Data is recursively fetched in the following order: + + * Trace summaries + * Trace IDs + * Traces + * Segments + * Subsegments + * Nested Subsegments + + Parameters + ---------- + filter_expression : str + AWS X-Ray Filter Expressions + see: https://docs.aws.amazon.com/xray/latest/devguide/xray-console-filters.html + start_date : datetime + Start date range to filter traces + end_date : Optional[datetime], optional + End date range to filter traces, by default 5 minutes past start_date + xray_client : Optional[XRayClient], optional + AWS X-Ray SDK Client, by default boto3.client('xray') + exclude_segment_name : Optional[List[str]], optional + Name of segments to exclude, by default ["Initialization", "Invocation", "Overhead"] + resource_name : Optional[List[str]], optional + Name of resource to filter traces (e.g., function name), by default None + origin : Optional[List[str]], optional + Trace origin name to filter traces, by default ["AWS::Lambda::Function"] + minimum_traces : int + Minimum number of traces to be retrieved before exhausting retry attempts + """ + self.filter_expression = filter_expression + self.start_date = start_date + self.end_date = end_date or self.start_date + timedelta(minutes=5) + self.xray_client = xray_client or boto3.client("xray") + self.trace_documents: Dict[str, TraceDocument] = {} + self.subsegments: List[TraceSubsegment] = [] + self.exclude_segment_name = exclude_segment_name or self.default_exclude_seg_name + self.resource_name = resource_name + self.origin = origin or ["AWS::Lambda::Function"] + self.annotations: List[Dict[str, Any]] = [] + self.metadata: List[Dict[str, Dict[str, Any]]] = [] + self.minimum_traces = minimum_traces + + paginator = self.xray_client.get_paginator("get_trace_summaries") + pages = paginator.paginate( + StartTime=self.start_date, + EndTime=self.end_date, + TimeRangeType="Event", + Sampling=False, + FilterExpression=self.filter_expression, + ) + + trace_ids = self._get_trace_ids(pages) + self.trace_documents = self._get_trace_documents(trace_ids) + self.subsegments = self._get_subsegments() + + def get_annotation(self, key: str, value: Optional[any] = None) -> List: + return [ + annotation + for annotation in self.annotations + if (value is not None and annotation.get(key) == value) or (value is None and key in annotation) + ] + + def get_metadata(self, key: str, namespace: str = "") -> List[Dict[str, Any]]: + seen = [] + for meta in self.metadata: + metadata = meta.get(namespace, {}) + if key in metadata: + seen.append(metadata) + return seen + + def get_subsegment(self, name: str) -> List: + return [seg for seg in self.subsegments if seg.name == name] + + def _find_nested_subsegments(self, subsegments: List[TraceSubsegment]) -> Generator[TraceSubsegment, None, None]: + """Recursively yield any subsegment that we might be interested. + + It excludes any subsegments contained in exclude_segment_name. + Since these are nested, subsegment name might be '## lambda_handler'. + + It also populates annotations and metadata nested in subsegments. + + Parameters + ---------- + subsegment : TraceSubsegment + subsegment to traverse + seen : List + list of subsegments to be updated + """ + for seg in subsegments: + if seg.name not in self.exclude_segment_name: + if seg.annotations: + self.annotations.append(seg.annotations) + + if seg.metadata: + self.metadata.append(seg.metadata) + + yield seg + + if seg.subsegments: + # recursively iterate over any arbitrary number of subsegments + yield from self._find_nested_subsegments(seg.subsegments) + + def _get_subsegments(self) -> List[TraceSubsegment]: + """Find subsegments and potentially any nested subsegments + + It excludes any subsegments contained in exclude_segment_name. + Since these are top-level, subsegment name might be 'Overhead/Invocation, etc.'. + + Returns + ------- + List[TraceSubsegment] + List of subsegments + """ + seen = [] + for document in self.trace_documents.values(): + if document.subsegments: + seen.extend(self._find_nested_subsegments(document.subsegments)) + + return seen + + def _get_trace_ids(self, pages: PageIterator) -> List[str]: + """Get list of trace IDs found + + Parameters + ---------- + pages : PageIterator + Paginated streaming response from AWS X-Ray + + Returns + ------- + List[str] + Trace IDs + + Raises + ------ + ValueError + When no traces are available within time range and filter expression + """ + summaries: List[TraceSummaryTypeDef] = [trace["TraceSummaries"] for trace in pages if trace["TraceSummaries"]] + if not summaries: + raise ValueError("Empty response from X-Ray. Repeating...") + + trace_ids = [trace["Id"] for trace in summaries[0]] # type: ignore[index] # TypedDict not being recognized + if len(trace_ids) < self.minimum_traces: + raise ValueError( + f"Number of traces found doesn't meet minimum required ({self.minimum_traces}). Repeating...", + ) + + return trace_ids + + def _get_trace_documents(self, trace_ids: List[str]) -> Dict[str, TraceDocument]: + """Find trace documents available in each trace segment + + Returns + ------- + Dict[str, TraceDocument] + Trace documents grouped by their ID + """ + traces = self.xray_client.batch_get_traces(TraceIds=trace_ids) + documents: Dict = {} + segments = [seg for trace in traces["Traces"] for seg in trace["Segments"]] + for seg in segments: + trace_document = TraceDocument(**json.loads(seg["Document"])) + if trace_document.origin in self.origin or trace_document.name == self.resource_name: + documents[trace_document.id] = trace_document + return documents + + +@retry(ValueError, delay=5, jitter=1.5, tries=10) +def get_traces( + filter_expression: str, + start_date: datetime, + end_date: Optional[datetime] = None, + xray_client: Optional[XRayClient] = None, + exclude_segment_name: Optional[List[str]] = None, + resource_name: Optional[List[str]] = None, + origin: Optional[List[str]] = None, + minimum_traces: int = 1, +) -> TraceFetcher: + """Fetch traces from AWS X-Ray + + Parameters + ---------- + filter_expression : str + AWS X-Ray Filter Expressions + see: https://docs.aws.amazon.com/xray/latest/devguide/xray-console-filters.html + start_date : datetime + Start date range to filter traces + end_date : Optional[datetime], optional + End date range to filter traces, by default 5 minutes past start_date + xray_client : Optional[XRayClient], optional + AWS X-Ray SDK Client, by default boto3.client('xray') + exclude_segment_name : Optional[List[str]], optional + Name of segments to exclude, by default ["Initialization", "Invocation", "Overhead"] + resource_name : Optional[List[str]], optional + Name of resource to filter traces (e.g., function name), by default None + origin : Optional[List[str]], optional + Trace origin name to filter traces, by default ["AWS::Lambda::Function"] + minimum_traces : int + Minimum number of traces to be retrieved before exhausting retry attempts + + Returns + ------- + TraceFetcher + TraceFetcher instance with trace data available as properties and methods + """ + return TraceFetcher( + filter_expression=filter_expression, + start_date=start_date, + end_date=end_date, + xray_client=xray_client, + exclude_segment_name=exclude_segment_name, + resource_name=resource_name, + origin=origin, + minimum_traces=minimum_traces, + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/infrastructure.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/infrastructure.py new file mode 100644 index 0000000000000000000000000000000000000000..a78ba1884e87d85db5b6728018462a294835b6c8 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/infrastructure.py @@ -0,0 +1,356 @@ +import json +import logging +import os +import subprocess +import sys +import textwrap +from pathlib import Path +from typing import Callable, Dict, Generator, Optional +from uuid import uuid4 + +import boto3 +import pytest +from aws_cdk import App, CfnOutput, Environment, RemovalPolicy, Stack, aws_logs +from aws_cdk.aws_lambda import ( + Architecture, + Code, + Function, + LayerVersion, + Runtime, + Tracing, +) +from filelock import FileLock + +from tests.e2e.utils.base import InfrastructureProvider +from tests.e2e.utils.constants import ( + CDK_OUT_PATH, + PYTHON_RUNTIME_VERSION, + SOURCE_CODE_ROOT_PATH, +) +from tests.e2e.utils.lambda_layer.powertools_layer import LocalLambdaPowertoolsLayer + +logger = logging.getLogger(__name__) + + +class BaseInfrastructure(InfrastructureProvider): + RANDOM_STACK_VALUE: str = f"{uuid4()}" + + def __init__(self) -> None: + self.feature_path = Path(sys.modules[self.__class__.__module__].__file__).parent # absolute path to feature + self.feature_name = self.feature_path.parts[-1].replace("_", "-") # logger, tracer, event-handler, etc. + self.stack_name = f"test{PYTHON_RUNTIME_VERSION}-{self.feature_name}-{self.RANDOM_STACK_VALUE}" + self.stack_outputs: Dict[str, str] = {} + + # NOTE: CDK stack account and region are tokens, we need to resolve earlier + self.session = boto3.session.Session() + self.cfn = self.session.client("cloudformation") + self.account_id = self.session.client("sts").get_caller_identity()["Account"] + self.region = self.session.region_name + + self.app = App() + self.stack = Stack(self.app, self.stack_name, env=Environment(account=self.account_id, region=self.region)) + + # NOTE: Introspect feature details to generate CDK App (_create_temp_cdk_app method), Synth and Deployment + self._feature_infra_class_name = self.__class__.__name__ + self._feature_infra_module_path = self.feature_path / "infrastructure" + self._feature_infra_file = self.feature_path / "infrastructure.py" + self._handlers_dir = self.feature_path / "handlers" + self._cdk_out_dir: Path = CDK_OUT_PATH / self.feature_name + self._stack_outputs_file = f'{self._cdk_out_dir / "stack_outputs.json"}' + + if not self._feature_infra_file.exists(): + raise FileNotFoundError( + "You must have your infrastructure defined in 'tests/e2e//infrastructure.py'.", + ) + + def create_lambda_functions( + self, + function_props: Optional[Dict] = None, + architecture: Architecture = Architecture.X86_64, + ) -> Dict[str, Function]: + """Create Lambda functions available under handlers_dir + + It creates CloudFormation Outputs for every function found in PascalCase. For example, + {handlers_dir}/basic_handler.py creates `BasicHandler` and `BasicHandlerArn` outputs. + + + Parameters + ---------- + function_props: Optional[Dict] + Dictionary representing CDK Lambda FunctionProps to override defaults + + architecture: Architecture + Used to create Lambda Layer and functions in a different architecture. Defaults to x86_64. + + Returns + ------- + output: Dict[str, Function] + A dict with PascalCased function names and the corresponding CDK Function object + + Examples + -------- + + Creating Lambda functions available in the handlers directory + + ```python + self.create_lambda_functions() + ``` + + Creating Lambda functions and override runtime to Python 3.13 + + ```python + from aws_cdk.aws_lambda import Runtime + + self.create_lambda_functions(function_props={"runtime": Runtime.PYTHON_3_13) + ``` + """ + if not self._handlers_dir.exists(): + raise RuntimeError(f"Handlers dir '{self._handlers_dir}' must exist for functions to be created.") + + layer_build = LocalLambdaPowertoolsLayer(architecture=architecture).build() + layer = LayerVersion( + self.stack, + "aws-lambda-powertools-e2e-test", + layer_version_name="aws-lambda-powertools-e2e-test", + compatible_runtimes=[ + Runtime.PYTHON_3_8, + Runtime.PYTHON_3_9, + Runtime.PYTHON_3_10, + Runtime.PYTHON_3_11, + Runtime.PYTHON_3_12, + Runtime.PYTHON_3_13, + ], + compatible_architectures=[architecture], + code=Code.from_asset(path=layer_build), + ) + + # NOTE: Agree on a convention if we need to support multi-file handlers + # as we're simply taking any file under `handlers/` to be a Lambda function. + handlers = list(self._handlers_dir.rglob("*.py")) + source = Code.from_asset(f"{self._handlers_dir}") + logger.debug(f"Creating functions for handlers: {handlers}") + + function_settings_override = function_props or {} + output: Dict[str, Function] = {} + + for fn in handlers: + fn_name = fn.stem + fn_name_pascal_case = fn_name.title().replace("_", "") # basic_handler -> BasicHandler + logger.debug(f"Creating function: {fn_name_pascal_case}") + function_settings = { + "id": f"{fn_name}-lambda", + "code": source, + "handler": f"{fn_name}.lambda_handler", + "tracing": Tracing.ACTIVE, + "runtime": self._determine_runtime_version(), + "layers": [layer], + "architecture": architecture, + **function_settings_override, + } + + function = Function(self.stack, **function_settings) + + aws_logs.LogGroup( + self.stack, + id=f"{fn_name}-lg", + log_group_name=f"/aws/lambda/{function.function_name}", + retention=aws_logs.RetentionDays.ONE_DAY, + removal_policy=RemovalPolicy.DESTROY, + ) + + # CFN Outputs only support hyphen hence pascal case + self.add_cfn_output(name=fn_name_pascal_case, value=function.function_name, arn=function.function_arn) + + output[fn_name_pascal_case] = function + + return output + + def deploy(self) -> Dict[str, str]: + """Synthesize and deploy a CDK app, and return its stack outputs + + NOTE: It auto-generates a temporary CDK app to benefit from CDK CLI lookup features + + Returns + ------- + Dict[str, str] + CloudFormation Stack Outputs with output key and value + """ + stack_file = self._create_temp_cdk_app() + synth_command = f"npx cdk synth --app 'python {stack_file}' -o {self._cdk_out_dir}" + deploy_command = ( + f"npx cdk deploy --app '{self._cdk_out_dir}' -O {self._stack_outputs_file} " + "--require-approval=never --method=direct" + ) + + # CDK launches a background task, so we must wait + subprocess.check_output(synth_command, shell=True) + subprocess.check_output(deploy_command, shell=True) + return self._read_stack_output() + + def delete(self) -> None: + """Delete CloudFormation Stack""" + logger.debug(f"Deleting stack: {self.stack_name}") + self.cfn.delete_stack(StackName=self.stack_name) + + def _sync_stack_name(self, stack_output: Dict): + """Synchronize initial stack name with CDK final stack name + + When using `cdk synth` with context methods (`from_lookup`), + CDK can initialize the Stack multiple times until it resolves + the context. + + Parameters + ---------- + stack_output : Dict + CDK CloudFormation Outputs, where the key is the stack name + """ + self.stack_name = list(stack_output.keys())[0] + + def _read_stack_output(self): + content = Path(self._stack_outputs_file).read_text() + outputs: Dict = json.loads(content) + self._sync_stack_name(stack_output=outputs) + + # discard stack_name and get outputs as dict + self.stack_outputs = list(outputs.values())[0] + return self.stack_outputs + + def _create_temp_cdk_app(self): + """Autogenerate a CDK App with our Stack so that CDK CLI can deploy it + + This allows us to keep our BaseInfrastructure while supporting context lookups. + """ + # cdk.out/tracer/cdk_app_v39.py + temp_file = self._cdk_out_dir / f"cdk_app_{PYTHON_RUNTIME_VERSION}.py" + + if temp_file.exists(): + # no need to regenerate CDK app since it's just boilerplate + return temp_file + + # Convert from POSIX path to Python module: tests.e2e.tracer.infrastructure + infra_module = str(self._feature_infra_module_path.relative_to(SOURCE_CODE_ROOT_PATH)).replace(os.sep, ".") + + code = f""" + from {infra_module} import {self._feature_infra_class_name} + stack = {self._feature_infra_class_name}() + stack.create_resources() + stack.app.synth() + """ + + if not self._cdk_out_dir.is_dir(): + self._cdk_out_dir.mkdir(parents=True, exist_ok=True) + + with temp_file.open("w") as fd: + fd.write(textwrap.dedent(code)) + + # allow CDK to read/execute file for stack deployment + temp_file.chmod(0o755) + return temp_file + + def _determine_runtime_version(self) -> Runtime: + """Determine Python runtime version based on the current Python interpreter""" + version = sys.version_info + if version.major == 3 and version.minor == 8: + return Runtime.PYTHON_3_8 + elif version.major == 3 and version.minor == 9: + return Runtime.PYTHON_3_9 + elif version.major == 3 and version.minor == 10: + return Runtime.PYTHON_3_10 + elif version.major == 3 and version.minor == 11: + return Runtime.PYTHON_3_11 + elif version.major == 3 and version.minor == 12: + return Runtime.PYTHON_3_12 + elif version.major == 3 and version.minor == 13: + return Runtime.PYTHON_3_13 + else: + raise ValueError(f"Unsupported Python version: {version}") + + def create_resources(self) -> None: + """Create any necessary CDK resources. It'll be called before deploy + + Examples + ------- + + Creating a S3 bucket and export name and ARN + + ```python + def created_resources(self): + s3 = s3.Bucket(self.stack, "MyBucket") + + # This will create MyBucket and MyBucketArn CloudFormation Output + self.add_cfn_output(name="MyBucket", value=s3.bucket_name, arn_value=bucket.bucket_arn) + ``` + + Creating Lambda functions available in the handlers directory + + ```python + def created_resources(self): + self.create_lambda_functions() + ``` + """ + raise NotImplementedError() + + def add_cfn_output(self, name: str, value: str, arn: str = ""): + """Create {Name} and optionally {Name}Arn CloudFormation Outputs. + + Parameters + ---------- + name : str + CloudFormation Output Key + value : str + CloudFormation Output Value + arn : str + CloudFormation Output Value for ARN + """ + CfnOutput(self.stack, f"{name}", value=value) + if arn: + CfnOutput(self.stack, f"{name}Arn", value=arn) + + +def call_once( + task: Callable, + tmp_path_factory: pytest.TempPathFactory, + worker_id: str, + callback: Optional[Callable] = None, +) -> Generator[object, None, None]: + """Call function and serialize results once whether CPU parallelization is enabled or not + + Parameters + ---------- + task : Callable + Function to call once and JSON serialize result whether parallel test is enabled or not. + tmp_path_factory : pytest.TempPathFactory + pytest temporary path factory to discover shared tmp when multiple CPU processes are spun up + worker_id : str + pytest-xdist worker identification to detect whether parallelization is enabled + callback : Callable + Function to call when job is complete. + + Yields + ------ + Generator[object, None, None] + Callable output when called + """ + + try: + if worker_id == "master": + # no parallelization, call and return + yield task() + else: + # tmp dir shared by all workers + root_tmp_dir = tmp_path_factory.getbasetemp().parent + cache = root_tmp_dir / f"{PYTHON_RUNTIME_VERSION}_cache.json" + + with FileLock(f"{cache}.lock"): + # If cache exists, return task outputs back + # otherwise it's the first run by the main worker + # run and return task outputs for subsequent workers reuse + if cache.is_file(): + callable_result = json.loads(cache.read_text()) + else: + callable_result: Dict = task() + cache.write_text(json.dumps(callable_result)) + yield callable_result + finally: + if callback is not None: + callback() diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/lambda_layer/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/lambda_layer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/lambda_layer/base.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/lambda_layer/base.py new file mode 100644 index 0000000000000000000000000000000000000000..e38e936eefc46dd60ff5a179baefd5f89a1ae4c9 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/lambda_layer/base.py @@ -0,0 +1,32 @@ +from abc import ABC, abstractmethod +from pathlib import Path + + +class BaseLocalLambdaLayer(ABC): + def __init__(self, output_dir: Path): + self.output_dir = output_dir / "layer_build" + self.target_dir = f"{self.output_dir}/python" + + @abstractmethod + def build(self) -> str: + """Builds a Lambda Layer locally + + Returns + ------- + build_path : str + Path where newly built Lambda Layer is + """ + raise NotImplementedError() + + def before_build(self): + """Any step to run before build process begins. + + By default, it creates output dir and its parents if it doesn't exist. + """ + if not self.output_dir.exists(): + # Create missing parent directories if missing + self.output_dir.mkdir(parents=True, exist_ok=True) + + def after_build(self): # noqa: B027 + """Any step after a build succeed""" + ... diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/lambda_layer/powertools_layer.py b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/lambda_layer/powertools_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..2ebf9dc7e3c548ee54f370c00610f5d873e2b622 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/lambda_layer/powertools_layer.py @@ -0,0 +1,83 @@ +import subprocess +from pathlib import Path +from typing import List + +from aws_cdk.aws_lambda import Architecture +from dirhash import dirhash + +from aws_lambda_powertools import PACKAGE_PATH +from tests.e2e.utils.constants import CDK_OUT_PATH, SOURCE_CODE_ROOT_PATH +from tests.e2e.utils.lambda_layer.base import BaseLocalLambdaLayer + + +class LocalLambdaPowertoolsLayer(BaseLocalLambdaLayer): + IGNORE_EXTENSIONS = ["pyc"] + ARCHITECTURE_PLATFORM_MAPPING = { + Architecture.X86_64.name: ("manylinux_2_17_x86_64", "manylinux_2_28_x86_64"), + Architecture.ARM_64.name: ("manylinux_2_17_aarch64", "manylinux_2_28_aarch64"), + } + + def __init__(self, output_dir: Path = CDK_OUT_PATH, architecture: Architecture = Architecture.X86_64): + super().__init__(output_dir) + self.package = f"{SOURCE_CODE_ROOT_PATH}[all,redis,datamasking]" + + self.platform_args = self._resolve_platform(architecture) + self.build_args = f"{self.platform_args} --only-binary=:all: --upgrade" + self.build_command = f"python -m pip install {self.package} {self.build_args} --target {self.target_dir}" + self.cleanup_command = ( + f"rm -rf {self.target_dir}/boto* {self.target_dir}/s3transfer* && " + f"rm -rf {self.target_dir}/*dateutil* {self.target_dir}/urllib3* {self.target_dir}/six* && " + f"rm -rf {self.target_dir}/jmespath* && " + f"find {self.target_dir} -name '*.so' -type f -exec strip '{{}}' \\; && " + f"find {self.target_dir} -wholename '*/tests/*' -type f -delete && " + f"find {self.target_dir} -regex '^.*\\(__pycache__\\|\\.py[co]\\)$' -delete" + ) + self.source_diff_file: Path = CDK_OUT_PATH / "layer_build.diff" + + def build(self) -> str: + self.before_build() + + if self._has_source_changed(): + subprocess.run(self.build_command, shell=True, check=True) + + self.after_build() + + return str(self.output_dir) + + def after_build(self): + subprocess.run(self.cleanup_command, shell=True, check=True) + + def _has_source_changed(self) -> bool: + """Hashes source code and + + Returns + ------- + change : bool + Whether source code hash has changed + """ + diff = self.source_diff_file.read_text() if self.source_diff_file.exists() else "" + new_diff = dirhash(directory=PACKAGE_PATH, algorithm="md5", ignore=self.IGNORE_EXTENSIONS) + if new_diff != diff or not self.output_dir.exists(): + self.source_diff_file.write_text(new_diff) + return True + + return False + + def _resolve_platform(self, architecture: Architecture) -> str: + """Returns the correct pip platform tag argument for the manylinux project (see PEP 599) + + Returns + ------- + str + pip's platform argument, e.g., --platform manylinux_2_17_x86_64 --platform manylinux_2_28_x86_64 + """ + platforms = self.ARCHITECTURE_PLATFORM_MAPPING.get(architecture.name) + if not platforms: + raise ValueError( + f"unknown architecture {architecture.name}. Supported: {self.ARCHITECTURE_PLATFORM_MAPPING.keys()}", + ) + + return self._build_platform_args(platforms) + + def _build_platform_args(self, platforms: List[str]): + return " ".join([f"--platform {platform}" for platform in platforms]) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/py.typed b/testbed/aws-powertools__powertools-lambda-python/tests/e2e/utils/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/activeMQEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/activeMQEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..18ef927c4fd4dbc2968655bc139a27f84b5f483e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/activeMQEvent.json @@ -0,0 +1,55 @@ +{ + "eventSource": "aws:amq", + "eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8", + "messages": [ + { + "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1.mq.us-west-2.amazonaws.com-37557-1234520418293-4:1:1:1:1", + "messageType": "jms/text-message", + "data": "QUJDOkFBQUE=", + "connectionId": "myJMSCoID", + "redelivered": false, + "destination": { + "physicalName": "testQueue" + }, + "timestamp": 1598827811958, + "brokerInTime": 1598827811958, + "brokerOutTime": 1598827811959, + "properties": { + "testKey": "testValue" + } + }, + { + "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1.mq.us-west-2.amazonaws.com-37557-1234520418293-4:1:1:1:1", + "messageType": "jms/text-message", + "data": "eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ==", + "connectionId": "myJMSCoID2", + "redelivered": false, + "destination": { + "physicalName": "testQueue" + }, + "timestamp": 1598827811958, + "brokerInTime": 1598827811958, + "brokerOutTime": 1598827811959, + "properties": { + "testKey": "testValue" + } + + }, + { + "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1.mq.us-west-2.amazonaws.com-37557-1234520418293-4:1:1:1:1", + "messageType": "jms/bytes-message", + "data": "3DTOOW7crj51prgVLQaGQ82S48k=", + "connectionId": "myJMSCoID1", + "persistent": false, + "destination": { + "physicalName": "testQueue" + }, + "timestamp": 1598827811958, + "brokerInTime": 1598827811958, + "brokerOutTime": 1598827811959, + "properties": { + "testKey": "testValue" + } + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/albEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/albEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..9328cb39e1235efffd1dbd146da6ddb669ae8204 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/albEvent.json @@ -0,0 +1,28 @@ +{ + "requestContext": { + "elb": { + "targetGroupArn": "arn:aws:elasticloadbalancing:us-east-2:123456789012:targetgroup/lambda-279XGJDqGZ5rsrHC2Fjr/49e9d65c45c6791a" + } + }, + "httpMethod": "GET", + "path": "/lambda", + "queryStringParameters": { + "query": "1234ABCD" + }, + "headers": { + "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8", + "accept-encoding": "gzip", + "accept-language": "en-US,en;q=0.9", + "connection": "keep-alive", + "host": "lambda-alb-123578498.us-east-2.elb.amazonaws.com", + "upgrade-insecure-requests": "1", + "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36", + "x-amzn-trace-id": "Root=1-5c536348-3d683b8b04734faae651f476", + "x-forwarded-for": "72.12.164.125", + "x-forwarded-port": "80", + "x-forwarded-proto": "http", + "x-imforwards": "20" + }, + "body": "Test", + "isBase64Encoded": false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/albEventPathTrailingSlash.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/albEventPathTrailingSlash.json new file mode 100644 index 0000000000000000000000000000000000000000..c517a3f6b04f0dae70a5d20c854cd764006e91da --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/albEventPathTrailingSlash.json @@ -0,0 +1,28 @@ +{ + "requestContext": { + "elb": { + "targetGroupArn": "arn:aws:elasticloadbalancing:us-east-2:123456789012:targetgroup/lambda-279XGJDqGZ5rsrHC2Fjr/49e9d65c45c6791a" + } + }, + "httpMethod": "GET", + "path": "/lambda/", + "queryStringParameters": { + "query": "1234ABCD" + }, + "headers": { + "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8", + "accept-encoding": "gzip", + "accept-language": "en-US,en;q=0.9", + "connection": "keep-alive", + "host": "lambda-alb-123578498.us-east-2.elb.amazonaws.com", + "upgrade-insecure-requests": "1", + "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36", + "x-amzn-trace-id": "Root=1-5c536348-3d683b8b04734faae651f476", + "x-forwarded-for": "72.12.164.125", + "x-forwarded-port": "80", + "x-forwarded-proto": "http", + "x-imforwards": "20" + }, + "body": "Test", + "isBase64Encoded": false + } \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/albMultiValueHeadersEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/albMultiValueHeadersEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..6b34709605ca98d282d9b2fbd1ab9ddb7a7fc365 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/albMultiValueHeadersEvent.json @@ -0,0 +1,35 @@ +{ + "requestContext": { + "elb": { + "targetGroupArn": "arn:aws:elasticloadbalancing:eu-central-1:1234567890:targetgroup/alb-c-Targe-11GDXTPQ7663S/804a67588bfdc10f" + } + }, + "httpMethod": "GET", + "path": "/todos", + "multiValueQueryStringParameters": {}, + "multiValueHeaders": { + "accept": [ + "*/*" + ], + "host": [ + "alb-c-LoadB-14POFKYCLBNSF-1815800096.eu-central-1.elb.amazonaws.com" + ], + "user-agent": [ + "curl/7.79.1" + ], + "x-amzn-trace-id": [ + "Root=1-62fa9327-21cdd4da4c6db451490a5fb7" + ], + "x-forwarded-for": [ + "123.123.123.123" + ], + "x-forwarded-port": [ + "80" + ], + "x-forwarded-proto": [ + "http" + ] + }, + "body": "", + "isBase64Encoded": false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/albMultiValueQueryStringEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/albMultiValueQueryStringEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..d5cdf18f02378e5e41a556b29ba3f04191573c04 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/albMultiValueQueryStringEvent.json @@ -0,0 +1,45 @@ +{ + "requestContext": { + "elb": { + "targetGroupArn": "arn:aws:elasticloadbalancing:eu-central-1:1234567890:targetgroup/alb-c-Targe-11GDXTPQ7663S/804a67588bfdc10f" + } + }, + "httpMethod": "GET", + "path": "/todos", + "multiValueQueryStringParameters": { + "parameter1": ["value1","value2"], + "parameter2": ["value"] + }, + "multiValueHeaders": { + "accept": [ + "*/*" + ], + "header2": [ + "value1", + "value2" + ], + "header1": [ + "value1" + ], + "host": [ + "alb-c-LoadB-14POFKYCLBNSF-1815800096.eu-central-1.elb.amazonaws.com" + ], + "user-agent": [ + "curl/7.79.1" + ], + "x-amzn-trace-id": [ + "Root=1-62fa9327-21cdd4da4c6db451490a5fb7" + ], + "x-forwarded-for": [ + "123.123.123.123" + ], + "x-forwarded-port": [ + "80" + ], + "x-forwarded-proto": [ + "http" + ] + }, + "body": "", + "isBase64Encoded": false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerRequestEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerRequestEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..908c7118c06e4c917712d4bd9f69ce40e3b78662 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerRequestEvent.json @@ -0,0 +1,81 @@ +{ + "version": "1.0", + "type": "REQUEST", + "methodArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request", + "identitySource": "user1,123", + "authorizationToken": "user1,123", + "resource": "/request", + "path": "/request", + "httpMethod": "GET", + "headers": { + "X-AMZ-Date": "20170718T062915Z", + "Accept": "*/*", + "HeaderAuth1": "headerValue1", + "CloudFront-Viewer-Country": "US", + "CloudFront-Forwarded-Proto": "https", + "CloudFront-Is-Tablet-Viewer": "false", + "CloudFront-Is-Mobile-Viewer": "false", + "User-Agent": "..." + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Origin": [ + "https://aws.amazon.com" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "QueryString1": "queryValue1" + }, + "pathParameters": {}, + "stageVariables": { + "StageVar1": "stageValue1" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "abcdef123", + "domainName": "3npb9j1tlk.execute-api.us-west-1.amazonaws.com", + "domainPrefix": "3npb9j1tlk", + "extendedRequestId": "EXqgWgXxSK4EJug=", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAmr": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "apiKey": "...", + "sourceIp": "test-invoke-source-ip", + "user": null, + "userAgent": "PostmanRuntime/7.28.3", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/request", + "protocol": "HTTP/1.1", + "requestId": "EXqgWgXxSK4EJug=", + "requestTime": "20/Aug/2021:14:36:50 +0000", + "requestTimeEpoch": 1629470210043, + "resourceId": "ANY /request", + "resourcePath": "/request", + "stage": "test" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerTokenEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerTokenEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..f30f360f6d81de7291cd113b0a329b5f5f8fdc43 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerTokenEvent.json @@ -0,0 +1,5 @@ +{ + "type": "TOKEN", + "authorizationToken": "allow", + "methodArn": "arn:aws:execute-api:us-west-2:123456789012:ymy8tbxw7b/*/GET/" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerV2Event.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerV2Event.json new file mode 100644 index 0000000000000000000000000000000000000000..83c3c9d8d61a7c4df96f379816c636f5b744b4c4 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayAuthorizerV2Event.json @@ -0,0 +1,52 @@ +{ + "version": "2.0", + "type": "REQUEST", + "routeArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request", + "identitySource": ["user1", "123"], + "routeKey": "GET /merchants", + "rawPath": "/merchants", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": ["cookie1", "cookie2"], + "headers": { + "x-amzn-trace-id": "Root=1-611cc4a7-0746ebee281cfd967db97b64", + "Header1": "value1", + "Header2": "value2", + "Authorization": "value" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "api-id", + "authentication": { + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "http": { + "method": "POST", + "path": "/merchants", + "protocol": "HTTP/1.1", + "sourceIp": "10.10.10.10", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "GET /merchants", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "pathParameters": { "parameter1": "value1" }, + "stageVariables": { "stageVariable1": "value1", "stageVariable2": "value2" } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..07dd89c2673a6edaf2eab8129d0f81cd85c1f000 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEvent.json @@ -0,0 +1,84 @@ +{ + "version": "1.0", + "resource": "/my/path", + "path": "/my/path", + "httpMethod": "GET", + "headers": { + "Header1": "value1", + "Header2": "value2", + "Origin": "https://aws.amazon.com" + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Origin": [ + "https://aws.amazon.com" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": "value1", + "parameter2": "value" + }, + "multiValueQueryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "id", + "authorizer": { + "claims": null, + "scopes": null + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "extendedRequestId": "request-id", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "sourceIp": "192.168.0.1/32", + "user": null, + "userAgent": "user-agent", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/my/path", + "protocol": "HTTP/1.1", + "requestId": "id=", + "requestTime": "04/Mar/2020:19:15:17 +0000", + "requestTimeEpoch": 1583349317135, + "resourceId": null, + "resourcePath": "/my/path", + "stage": "$default" + }, + "pathParameters": null, + "stageVariables": null, + "body": "Hello from Lambda!", + "isBase64Encoded": false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventAnotherPath.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventAnotherPath.json new file mode 100644 index 0000000000000000000000000000000000000000..d8f43e4626658a5ed1ad6f2e6d297d72c56d8929 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventAnotherPath.json @@ -0,0 +1,80 @@ +{ + "version": "1.0", + "resource": "/my/anotherPath", + "path": "/my/anotherPath", + "httpMethod": "GET", + "headers": { + "Header1": "value1", + "Header2": "value2" + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": "value1", + "parameter2": "value" + }, + "multiValueQueryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "id", + "authorizer": { + "claims": null, + "scopes": null + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "extendedRequestId": "request-id", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "sourceIp": "192.168.0.1/32", + "user": null, + "userAgent": "user-agent", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/my/anotherPath", + "protocol": "HTTP/1.1", + "requestId": "id=", + "requestTime": "04/Mar/2020:19:15:17 +0000", + "requestTimeEpoch": 1583349317135, + "resourceId": null, + "resourcePath": "/my/anotherPath", + "stage": "$default" + }, + "pathParameters": null, + "stageVariables": null, + "body": "Hello from Lambda!", + "isBase64Encoded": true +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventNoOrigin.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventNoOrigin.json new file mode 100644 index 0000000000000000000000000000000000000000..666022723ad35e815cbd02bdd42e5f70ea6d5f13 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventNoOrigin.json @@ -0,0 +1,80 @@ +{ + "version": "1.0", + "resource": "/my/path", + "path": "/my/path", + "httpMethod": "GET", + "headers": { + "Header1": "value1", + "Header2": "value2" + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": "value1", + "parameter2": "value" + }, + "multiValueQueryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "id", + "authorizer": { + "claims": null, + "scopes": null + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "extendedRequestId": "request-id", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "sourceIp": "192.168.0.1/32", + "user": null, + "userAgent": "user-agent", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/my/path", + "protocol": "HTTP/1.1", + "requestId": "id=", + "requestTime": "04/Mar/2020:19:15:17 +0000", + "requestTimeEpoch": 1583349317135, + "resourceId": null, + "resourcePath": "/my/path", + "stage": "$default" + }, + "pathParameters": null, + "stageVariables": null, + "body": "Hello from Lambda!", + "isBase64Encoded": false +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventPathTrailingSlash.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventPathTrailingSlash.json new file mode 100644 index 0000000000000000000000000000000000000000..8a321d96c8c552628006232daff6f3910d8cb7b7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventPathTrailingSlash.json @@ -0,0 +1,80 @@ +{ + "version": "1.0", + "resource": "/my/path", + "path": "/my/path/", + "httpMethod": "GET", + "headers": { + "Header1": "value1", + "Header2": "value2" + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": "value1", + "parameter2": "value" + }, + "multiValueQueryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "id", + "authorizer": { + "claims": null, + "scopes": null + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "extendedRequestId": "request-id", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "sourceIp": "192.168.0.1/32", + "user": null, + "userAgent": "user-agent", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/my/path", + "protocol": "HTTP/1.1", + "requestId": "id=", + "requestTime": "04/Mar/2020:19:15:17 +0000", + "requestTimeEpoch": 1583349317135, + "resourceId": null, + "resourcePath": "/my/path", + "stage": "$default" + }, + "pathParameters": null, + "stageVariables": null, + "body": "Hello from Lambda!", + "isBase64Encoded": true + } \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventPrincipalId.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventPrincipalId.json new file mode 100644 index 0000000000000000000000000000000000000000..f18a2a44bbd166eaed06c2215600eacb065c46bd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEventPrincipalId.json @@ -0,0 +1,13 @@ +{ + "resource": "/trip", + "path": "/trip", + "httpMethod": "POST", + "requestContext": { + "requestId": "34972478-2843-4ced-a657-253108738274", + "authorizer": { + "user_id": "fake_username", + "principalId": "fake", + "integrationLatency": 451 + } + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEvent_noVersionAuth.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEvent_noVersionAuth.json new file mode 100644 index 0000000000000000000000000000000000000000..055301f8f15454f7447e1c1243c6c7ca4c0c8d1f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyEvent_noVersionAuth.json @@ -0,0 +1,75 @@ +{ + "resource": "/my/path", + "path": "/my/path", + "httpMethod": "GET", + "headers": { + "Header1": "value1", + "Header2": "value2" + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": "value1", + "parameter2": "value" + }, + "multiValueQueryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "id", + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "extendedRequestId": "request-id", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "sourceIp": "192.168.0.1/32", + "user": null, + "userAgent": "user-agent", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/my/path", + "protocol": "HTTP/1.1", + "requestId": "id=", + "requestTime": "04/Mar/2020:19:15:17 +0000", + "requestTimeEpoch": 1583349317135, + "resourceId": null, + "resourcePath": "/my/path", + "stage": "$default" + }, + "pathParameters": null, + "stageVariables": null, + "body": "Hello from Lambda!", + "isBase64Encoded": true +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyOtherEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyOtherEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..5b9d09844abb8b203c8a81f735d3d13635f11c12 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyOtherEvent.json @@ -0,0 +1,81 @@ +{ + "version": "1.0", + "resource": "/other/path", + "path": "/other/path", + "httpMethod": "GET", + "headers": { + "Header1": "value1", + "Header2": "value2", + "Origin": "https://aws.amazon.com" + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": "value1", + "parameter2": "value" + }, + "multiValueQueryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "id", + "authorizer": { + "claims": null, + "scopes": null + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "extendedRequestId": "request-id", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "sourceIp": "192.168.0.1/32", + "user": null, + "userAgent": "user-agent", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/other/path", + "protocol": "HTTP/1.1", + "requestId": "id=", + "requestTime": "04/Mar/2020:19:15:17 +0000", + "requestTimeEpoch": 1583349317135, + "resourceId": null, + "resourcePath": "/other/path", + "stage": "$default" + }, + "pathParameters": null, + "stageVariables": null, + "body": "Hello from Lambda!", + "isBase64Encoded": false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2Event.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2Event.json new file mode 100644 index 0000000000000000000000000000000000000000..9de632b8e3df14eed14facd6f71e6653be76ca96 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2Event.json @@ -0,0 +1,69 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "Header1": "value1", + "Header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "api-id", + "authentication": { + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "authorizer": { + "jwt": { + "claims": { + "claim1": "value1", + "claim2": "value2" + }, + "scopes": [ + "scope1", + "scope2" + ] + } + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "http": { + "method": "POST", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "192.168.0.1/32", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "body": "{\"message\": \"hello world\", \"username\": \"tom\"}", + "pathParameters": { + "parameter1": "value1" + }, + "isBase64Encoded": false, + "stageVariables": { + "stageVariable1": "value1", + "stageVariable2": "value2" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2EventPathTrailingSlash.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2EventPathTrailingSlash.json new file mode 100644 index 0000000000000000000000000000000000000000..dfb0d98f2e16f3afe9c99a46f493369f52c5179c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2EventPathTrailingSlash.json @@ -0,0 +1,69 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path/", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "Header1": "value1", + "Header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "api-id", + "authentication": { + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "authorizer": { + "jwt": { + "claims": { + "claim1": "value1", + "claim2": "value2" + }, + "scopes": [ + "scope1", + "scope2" + ] + } + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "http": { + "method": "POST", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "192.168.0.1/32", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "body": "{\"message\": \"hello world\", \"username\": \"tom\"}", + "pathParameters": { + "parameter1": "value1" + }, + "isBase64Encoded": false, + "stageVariables": { + "stageVariable1": "value1", + "stageVariable2": "value2" + } + } \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2Event_GET.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2Event_GET.json new file mode 100644 index 0000000000000000000000000000000000000000..f411ea655d082622b3de077cebc2cd7ab1d3af8b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2Event_GET.json @@ -0,0 +1,68 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "Header1": "value1", + "Header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "api-id", + "authentication": { + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "authorizer": { + "jwt": { + "claims": { + "claim1": "value1", + "claim2": "value2" + }, + "scopes": [ + "scope1", + "scope2" + ] + } + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "http": { + "method": "GET", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "192.168.0.1/32", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "pathParameters": { + "parameter1": "value1" + }, + "isBase64Encoded": false, + "stageVariables": { + "stageVariable1": "value1", + "stageVariable2": "value2" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2IamEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2IamEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..43f33e1678daee107b3240831baf7b9c79ed1c49 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2IamEvent.json @@ -0,0 +1,62 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "Header1": "value1", + "Header2": "value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "pathParameters": { + "proxy": "hello/world" + }, + "requestContext": { + "routeKey": "$default", + "accountId": "123456789012", + "stage": "$default", + "requestId": "id", + "authorizer": { + "iam": { + "accessKey": "ARIA2ZJZYVUEREEIHAKY", + "accountId": "1234567890", + "callerId": "AROA7ZJZYVRE7C3DUXHH6:CognitoIdentityCredentials", + "cognitoIdentity": { + "amr": [ + "foo" + ], + "identityId": "us-east-1:3f291106-8703-466b-8f2b-3ecee1ca56ce", + "identityPoolId": "us-east-1:4f291106-8703-466b-8f2b-3ecee1ca56ce" + }, + "principalOrgId": "AwsOrgId", + "userArn": "arn:aws:iam::1234567890:user/Admin", + "userId": "AROA2ZJZYVRE7Y3TUXHH6" + } + }, + "apiId": "api-id", + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "time": "12/Mar/2020:19:03:58+0000", + "timeEpoch": 1583348638390, + "http": { + "method": "GET", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "192.168.0.1/32", + "userAgent": "agent" + } + }, + "stageVariables": { + "stageVariable1": "value1", + "stageVariable2": "value2" + }, + "body": "{\r\n\t\"a\": 1\r\n}", + "isBase64Encoded": false +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2LambdaAuthorizerEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2LambdaAuthorizerEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..63fd226c7304e42c3784c1ccadfa2ec88e4e5a87 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2LambdaAuthorizerEvent.json @@ -0,0 +1,59 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "Header1": "value1", + "Header2": "value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "pathParameters": { + "proxy": "hello/world" + }, + "requestContext": { + "routeKey": "$default", + "accountId": "123456789012", + "stage": "$default", + "requestId": "id", + "authorizer": { + "jwt": { + "claims": { + "claim1": "value1" + }, + "scopes": [ + "scope1", + "scope2" + ] + }, + "lambda": { + "tenantId": "123-456-789-012" + } + }, + "apiId": "api-id", + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "time": "12/Mar/2020:19:03:58+0000", + "timeEpoch": 1583348638390, + "http": { + "method": "GET", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "192.168.0.1/32", + "userAgent": "agent" + } + }, + "stageVariables": { + "stageVariable1": "value1", + "stageVariable2": "value2" + }, + "body": "{\r\n\t\"a\": 1\r\n}", + "isBase64Encoded": false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2OtherGetEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2OtherGetEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..b9bd88f1c2e46d2929843f617f6bfc83584f2017 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2OtherGetEvent.json @@ -0,0 +1,68 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/other/path", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "Header1": "value1", + "Header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "api-id", + "authentication": { + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "authorizer": { + "jwt": { + "claims": { + "claim1": "value1", + "claim2": "value2" + }, + "scopes": [ + "scope1", + "scope2" + ] + } + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "http": { + "method": "GET", + "path": "/other/path", + "protocol": "HTTP/1.1", + "sourceIp": "192.168.0.1/32", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "pathParameters": { + "parameter1": "value1" + }, + "isBase64Encoded": false, + "stageVariables": { + "stageVariable1": "value1", + "stageVariable2": "value2" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2SchemaMiddlwareInvalidEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2SchemaMiddlwareInvalidEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..d2f4c404c7913e9443c24c9fae30a3ff7afbfa6f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2SchemaMiddlwareInvalidEvent.json @@ -0,0 +1,69 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "Header1": "value1", + "Header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "api-id", + "authentication": { + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "authorizer": { + "jwt": { + "claims": { + "claim1": "value1", + "claim2": "value2" + }, + "scopes": [ + "scope1", + "scope2" + ] + } + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "http": { + "method": "POST", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "192.168.0.1/32", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "body": "{\"username\": \"lessa\"}", + "pathParameters": { + "parameter1": "value1" + }, + "isBase64Encoded": false, + "stageVariables": { + "stageVariable1": "value1", + "stageVariable2": "value2" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2SchemaMiddlwareValidEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2SchemaMiddlwareValidEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..7be3d1194d27c8d099edc56d09cf7983cec71897 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apiGatewayProxyV2SchemaMiddlwareValidEvent.json @@ -0,0 +1,69 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "Header1": "value1", + "Header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "api-id", + "authentication": { + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "authorizer": { + "jwt": { + "claims": { + "claim1": "value1", + "claim2": "value2" + }, + "scopes": [ + "scope1", + "scope2" + ] + } + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "http": { + "method": "POST", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "192.168.0.1/32", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "body": "{\"message\": \"hello world\", \"username\": \"lessa\"}", + "pathParameters": { + "parameter1": "value1" + }, + "isBase64Encoded": false, + "stageVariables": { + "stageVariable1": "value1", + "stageVariable2": "value2" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apigatewayeSchemaMiddlwareInvalidEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apigatewayeSchemaMiddlwareInvalidEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..13d810870e10fb228f487a3d8e9971780d91343e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apigatewayeSchemaMiddlwareInvalidEvent.json @@ -0,0 +1,81 @@ +{ + "version": "1.0", + "resource": "/my/path", + "path": "/my/path", + "httpMethod": "POST", + "headers": { + "Header1": "value1", + "Header2": "value2", + "Origin": "https://aws.amazon.com" + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": "value1", + "parameter2": "value" + }, + "multiValueQueryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "id", + "authorizer": { + "claims": null, + "scopes": null + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "extendedRequestId": "request-id", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "sourceIp": "192.168.0.1/32", + "user": null, + "userAgent": "user-agent", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/my/path", + "protocol": "HTTP/1.1", + "requestId": "id=", + "requestTime": "04/Mar/2020:19:15:17 +0000", + "requestTimeEpoch": 1583349317135, + "resourceId": null, + "resourcePath": "/my/path", + "stage": "$default" + }, + "pathParameters": null, + "stageVariables": null, + "body": "{\"username\": \"lessa\"}", + "isBase64Encoded": false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/apigatewayeSchemaMiddlwareValidEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/apigatewayeSchemaMiddlwareValidEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..454465b9a4539477a34ca8dcdcda2732b060a2c9 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/apigatewayeSchemaMiddlwareValidEvent.json @@ -0,0 +1,81 @@ +{ + "version": "1.0", + "resource": "/my/path", + "path": "/my/path", + "httpMethod": "POST", + "headers": { + "Header1": "value1", + "Header2": "value2", + "Origin": "https://aws.amazon.com" + }, + "multiValueHeaders": { + "Header1": [ + "value1" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": "value1", + "parameter2": "value" + }, + "multiValueQueryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "id", + "authorizer": { + "claims": null, + "scopes": null + }, + "domainName": "id.execute-api.us-east-1.amazonaws.com", + "domainPrefix": "id", + "extendedRequestId": "request-id", + "httpMethod": "GET", + "identity": { + "accessKey": null, + "accountId": null, + "caller": null, + "cognitoAuthenticationProvider": null, + "cognitoAuthenticationType": null, + "cognitoIdentityId": null, + "cognitoIdentityPoolId": null, + "principalOrgId": null, + "sourceIp": "192.168.0.1/32", + "user": null, + "userAgent": "user-agent", + "userArn": null, + "clientCert": { + "clientCertPem": "CERT_CONTENT", + "subjectDN": "www.example.com", + "issuerDN": "Example issuer", + "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1", + "validity": { + "notBefore": "May 28 12:30:02 2019 GMT", + "notAfter": "Aug 5 09:36:04 2021 GMT" + } + } + }, + "path": "/my/path", + "protocol": "HTTP/1.1", + "requestId": "id=", + "requestTime": "04/Mar/2020:19:15:17 +0000", + "requestTimeEpoch": 1583349317135, + "resourceId": null, + "resourcePath": "/my/path", + "stage": "$default" + }, + "pathParameters": null, + "stageVariables": null, + "body": "{\"message\": \"hello world\", \"username\": \"lessa\"}", + "isBase64Encoded": false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncAuthorizerEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncAuthorizerEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..a8264569bfcaaad1e2d6514c2c33d24feb5e1d2a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncAuthorizerEvent.json @@ -0,0 +1,13 @@ +{ + "authorizationToken": "BE9DC5E3-D410-4733-AF76-70178092E681", + "requestContext": { + "apiId": "giy7kumfmvcqvbedntjwjvagii", + "accountId": "254688921111", + "requestId": "b80ed838-14c6-4500-b4c3-b694c7bef086", + "queryString": "mutation MyNewTask($desc: String!) {\n createTask(description: $desc, owner: \"ccc\", taskStatus: \"cc\", title: \"ccc\") {\n id\n }\n}\n", + "operationName": "MyNewTask", + "variables": { + "desc": "Foo" + } + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncAuthorizerResponse.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncAuthorizerResponse.json new file mode 100644 index 0000000000000000000000000000000000000000..7dd8234d2eff25e5c99bd858d7f088ed7dbe529d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncAuthorizerResponse.json @@ -0,0 +1,9 @@ +{ + "isAuthorized": true, + "resolverContext": { + "name": "Foo Man", + "balance": 100 + }, + "deniedFields": ["Mutation.createEvent"], + "ttlOverride": 15 +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncBatchEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncBatchEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..49f98eecc55280abbdccbfb88f8ff7937bb7668b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncBatchEvent.json @@ -0,0 +1,46 @@ +[ + { + "arguments": { + "user_id": "1" + }, + "identity": { + "sub": "192879fc-a240-4bf1-ab5a-d6a00f3063f9", + "username": "jdoe" + }, + "prev": null, + "info": { + "selectionSetList": [ + "id", + "field1", + "field2" + ], + "selectionSetGraphQL": "{\n id\n field1\n field2\n}", + "parentTypeName": "Mutation", + "fieldName": "createSomething", + "variables": {} + }, + "stash": {} + }, + { + "arguments": { + "user_id": "2" + }, + "identity": { + "sub": "192879fc-a240-4bf1-ab5a-d6a00f3063f9", + "username": "jdoe" + }, + "prev": null, + "info": { + "selectionSetList": [ + "id", + "field1", + "field2" + ], + "selectionSetGraphQL": "{\n id\n field1\n field2\n}", + "parentTypeName": "Mutation", + "fieldName": "createSomething", + "variables": {} + }, + "stash": {} + } +] diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncDirectResolver.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncDirectResolver.json new file mode 100644 index 0000000000000000000000000000000000000000..08c3d00b203654e3847b8d4315bc602523883354 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncDirectResolver.json @@ -0,0 +1,74 @@ +{ + "arguments": { + "id": "my identifier" + }, + "identity": { + "claims": { + "sub": "192879fc-a240-4bf1-ab5a-d6a00f3063f9", + "email_verified": true, + "iss": "https://cognito-idp.us-west-2.amazonaws.com/us-west-xxxxxxxxxxx", + "phone_number_verified": false, + "cognito:username": "jdoe", + "aud": "7471s60os7h0uu77i1tk27sp9n", + "event_id": "bc334ed8-a938-4474-b644-9547e304e606", + "token_use": "id", + "auth_time": 1599154213, + "phone_number": "+19999999999", + "exp": 1599157813, + "iat": 1599154213, + "email": "jdoe@email.com" + }, + "defaultAuthStrategy": "ALLOW", + "groups": null, + "issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-xxxxxxxxxxx", + "sourceIp": [ + "1.1.1.1" + ], + "sub": "192879fc-a240-4bf1-ab5a-d6a00f3063f9", + "username": "jdoe" + }, + "source": null, + "request": { + "headers": { + "x-forwarded-for": "1.1.1.1, 2.2.2.2", + "cloudfront-viewer-country": "US", + "cloudfront-is-tablet-viewer": "false", + "via": "2.0 xxxxxxxxxxxxxxxx.cloudfront.net (CloudFront)", + "cloudfront-forwarded-proto": "https", + "origin": "https://us-west-1.console.aws.amazon.com", + "content-length": "217", + "accept-language": "en-US,en;q=0.9", + "host": "xxxxxxxxxxxxxxxx.appsync-api.us-west-1.amazonaws.com", + "x-forwarded-proto": "https", + "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36", + "accept": "*/*", + "cloudfront-is-mobile-viewer": "false", + "cloudfront-is-smarttv-viewer": "false", + "accept-encoding": "gzip, deflate, br", + "referer": "https://us-west-1.console.aws.amazon.com/appsync/home?region=us-west-1", + "content-type": "application/json", + "sec-fetch-mode": "cors", + "x-amz-cf-id": "3aykhqlUwQeANU-HGY7E_guV5EkNeMMtwyOgiA==", + "x-amzn-trace-id": "Root=1-5f512f51-fac632066c5e848ae714", + "authorization": "eyJraWQiOiJScWFCSlJqYVJlM0hrSnBTUFpIcVRXazNOW...", + "sec-fetch-dest": "empty", + "x-amz-user-agent": "AWS-Console-AppSync/", + "cloudfront-is-desktop-viewer": "true", + "sec-fetch-site": "cross-site", + "x-forwarded-port": "443" + } + }, + "prev": null, + "info": { + "selectionSetList": [ + "id", + "field1", + "field2" + ], + "selectionSetGraphQL": "{\n id\n field1\n field2\n}", + "parentTypeName": "Mutation", + "fieldName": "createSomething", + "variables": {} + }, + "stash": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncResolverEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncResolverEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..84ac71951c6e93038d11eb59c63400b9aa2bd918 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/appSyncResolverEvent.json @@ -0,0 +1,71 @@ +{ + "typeName": "Merchant", + "fieldName": "locations", + "arguments": { + "page": 2, + "size": 1, + "name": "value" + }, + "identity": { + "claims": { + "sub": "07920713-4526-4642-9c88-2953512de441", + "iss": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_POOL_ID", + "aud": "58rc9bf5kkti90ctmvioppukm9", + "event_id": "7f4c9383-abf6-48b7-b821-91643968b755", + "token_use": "id", + "auth_time": 1615366261, + "name": "Michael Brewer", + "exp": 1615369861, + "iat": 1615366261 + }, + "defaultAuthStrategy": "ALLOW", + "groups": null, + "issuer": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_POOL_ID", + "sourceIp": [ + "11.215.2.22" + ], + "sub": "07920713-4526-4642-9c88-2953512de441", + "username": "mike" + }, + "source": { + "name": "Value", + "nested": { + "name": "value", + "list": [] + } + }, + "request": { + "headers": { + "x-forwarded-for": "11.215.2.22, 64.44.173.11", + "cloudfront-viewer-country": "US", + "cloudfront-is-tablet-viewer": "false", + "via": "2.0 SOMETHING.cloudfront.net (CloudFront)", + "cloudfront-forwarded-proto": "https", + "origin": "https://console.aws.amazon.com", + "content-length": "156", + "accept-language": "en-US,en;q=0.9", + "host": "SOMETHING.appsync-api.us-east-1.amazonaws.com", + "x-forwarded-proto": "https", + "sec-gpc": "1", + "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) etc.", + "accept": "*/*", + "cloudfront-is-mobile-viewer": "false", + "cloudfront-is-smarttv-viewer": "false", + "accept-encoding": "gzip, deflate, br", + "referer": "https://console.aws.amazon.com/", + "content-type": "application/json", + "sec-fetch-mode": "cors", + "x-amz-cf-id": "Fo5VIuvP6V6anIEt62WzFDCK45mzM4yEdpt5BYxOl9OFqafd-WR0cA==", + "x-amzn-trace-id": "Root=1-60488877-0b0c4e6727ab2a1c545babd0", + "authorization": "AUTH-HEADER", + "sec-fetch-dest": "empty", + "x-amz-user-agent": "AWS-Console-AppSync/", + "cloudfront-is-desktop-viewer": "true", + "sec-fetch-site": "cross-site", + "x-forwarded-port": "443" + } + }, + "prev": { + "result": {} + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleConfigurationChanged.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleConfigurationChanged.json new file mode 100644 index 0000000000000000000000000000000000000000..cbf7abf67aa6d1e8bd2eb671303d4b79186b51bb --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleConfigurationChanged.json @@ -0,0 +1,13 @@ +{ + "version":"1.0", + "invokingEvent":"{\"configurationItemDiff\":{\"changedProperties\":{\"Configuration.InstanceType\":{\"previousValue\":\"t2.micro\",\"updatedValue\":\"t2.medium\",\"changeType\":\"UPDATE\"},\"Configuration.State.Name\":{\"previousValue\":\"running\",\"updatedValue\":\"stopped\",\"changeType\":\"UPDATE\"},\"Configuration.StateTransitionReason\":{\"previousValue\":\"\",\"updatedValue\":\"User initiated (2023-04-27 15:01:07 GMT)\",\"changeType\":\"UPDATE\"},\"Configuration.StateReason\":{\"previousValue\":null,\"updatedValue\":{\"code\":\"Client.UserInitiatedShutdown\",\"message\":\"Client.UserInitiatedShutdown: User initiated shutdown\"},\"changeType\":\"CREATE\"},\"Configuration.CpuOptions.CoreCount\":{\"previousValue\":1,\"updatedValue\":2,\"changeType\":\"UPDATE\"}},\"changeType\":\"UPDATE\"},\"configurationItem\":{\"relatedEvents\":[],\"relationships\":[{\"resourceId\":\"eipalloc-0ebb4367662263cc1\",\"resourceName\":null,\"resourceType\":\"AWS::EC2::EIP\",\"name\":\"Is attached to ElasticIp\"},{\"resourceId\":\"eni-034dd31c4b17ada8c\",\"resourceName\":null,\"resourceType\":\"AWS::EC2::NetworkInterface\",\"name\":\"Contains NetworkInterface\"},{\"resourceId\":\"eni-09a604c0ec356b06f\",\"resourceName\":null,\"resourceType\":\"AWS::EC2::NetworkInterface\",\"name\":\"Contains NetworkInterface\"},{\"resourceId\":\"sg-0fb295a327d9b4835\",\"resourceName\":null,\"resourceType\":\"AWS::EC2::SecurityGroup\",\"name\":\"Is associated with SecurityGroup\"},{\"resourceId\":\"subnet-cad1f2f4\",\"resourceName\":null,\"resourceType\":\"AWS::EC2::Subnet\",\"name\":\"Is contained in Subnet\"},{\"resourceId\":\"vol-0a288b5eb9fea4b30\",\"resourceName\":null,\"resourceType\":\"AWS::EC2::Volume\",\"name\":\"Is attached to Volume\"},{\"resourceId\":\"vpc-2d96be57\",\"resourceName\":null,\"resourceType\":\"AWS::EC2::VPC\",\"name\":\"Is contained in Vpc\"}],\"configuration\":{\"amiLaunchIndex\":0,\"imageId\":\"ami-09d95fab7fff3776c\",\"instanceId\":\"i-042dd005362091826\",\"instanceType\":\"t2.medium\",\"kernelId\":null,\"keyName\":\"mihaec2\",\"launchTime\":\"2023-04-27T14:57:16.000Z\",\"monitoring\":{\"state\":\"disabled\"},\"placement\":{\"availabilityZone\":\"us-east-1e\",\"affinity\":null,\"groupName\":\"\",\"partitionNumber\":null,\"hostId\":null,\"tenancy\":\"default\",\"spreadDomain\":null,\"hostResourceGroupArn\":null},\"platform\":null,\"privateDnsName\":\"ip-172-31-78-41.ec2.internal\",\"privateIpAddress\":\"172.31.78.41\",\"productCodes\":[],\"publicDnsName\":\"ec2-3-232-229-57.compute-1.amazonaws.com\",\"publicIpAddress\":\"3.232.229.57\",\"ramdiskId\":null,\"state\":{\"code\":80,\"name\":\"stopped\"},\"stateTransitionReason\":\"User initiated (2023-04-27 15:01:07 GMT)\",\"subnetId\":\"subnet-cad1f2f4\",\"vpcId\":\"vpc-2d96be57\",\"architecture\":\"x86_64\",\"blockDeviceMappings\":[{\"deviceName\":\"/dev/xvda\",\"ebs\":{\"attachTime\":\"2020-05-30T15:21:58.000Z\",\"deleteOnTermination\":true,\"status\":\"attached\",\"volumeId\":\"vol-0a288b5eb9fea4b30\"}}],\"clientToken\":\"\",\"ebsOptimized\":false,\"enaSupport\":true,\"hypervisor\":\"xen\",\"iamInstanceProfile\":{\"arn\":\"arn:aws:iam::0123456789012:instance-profile/AmazonSSMRoleForInstancesQuickSetup\",\"id\":\"AIPAS5S4WFUBL72S3QXW5\"},\"instanceLifecycle\":null,\"elasticGpuAssociations\":[],\"elasticInferenceAcceleratorAssociations\":[],\"networkInterfaces\":[{\"association\":{\"carrierIp\":null,\"ipOwnerId\":\"0123456789012\",\"publicDnsName\":\"ec2-3-232-229-57.compute-1.amazonaws.com\",\"publicIp\":\"3.232.229.57\"},\"attachment\":{\"attachTime\":\"2020-05-30T15:21:57.000Z\",\"attachmentId\":\"eni-attach-0a7e75dc9c1c291a0\",\"deleteOnTermination\":true,\"deviceIndex\":0,\"status\":\"attached\",\"networkCardIndex\":0},\"description\":\"\",\"groups\":[{\"groupName\":\"minhaec2\",\"groupId\":\"sg-0fb295a327d9b4835\"}],\"ipv6Addresses\":[],\"macAddress\":\"06:cf:00:c2:17:db\",\"networkInterfaceId\":\"eni-034dd31c4b17ada8c\",\"ownerId\":\"0123456789012\",\"privateDnsName\":\"ip-172-31-78-41.ec2.internal\",\"privateIpAddress\":\"172.31.78.41\",\"privateIpAddresses\":[{\"association\":{\"carrierIp\":null,\"ipOwnerId\":\"0123456789012\",\"publicDnsName\":\"ec2-3-232-229-57.compute-1.amazonaws.com\",\"publicIp\":\"3.232.229.57\"},\"primary\":true,\"privateDnsName\":\"ip-172-31-78-41.ec2.internal\",\"privateIpAddress\":\"172.31.78.41\"}],\"sourceDestCheck\":true,\"status\":\"in-use\",\"subnetId\":\"subnet-cad1f2f4\",\"vpcId\":\"vpc-2d96be57\",\"interfaceType\":\"interface\"},{\"association\":null,\"attachment\":{\"attachTime\":\"2020-11-26T23:46:04.000Z\",\"attachmentId\":\"eni-attach-0e6d150ebbd19966e\",\"deleteOnTermination\":false,\"deviceIndex\":1,\"status\":\"attached\",\"networkCardIndex\":0},\"description\":\"MINHAEC2AAAAAA\",\"groups\":[{\"groupName\":\"minhaec2\",\"groupId\":\"sg-0fb295a327d9b4835\"},{\"groupName\":\"default\",\"groupId\":\"sg-88105fa0\"}],\"ipv6Addresses\":[],\"macAddress\":\"06:0a:62:00:64:5f\",\"networkInterfaceId\":\"eni-09a604c0ec356b06f\",\"ownerId\":\"0123456789012\",\"privateDnsName\":\"ip-172-31-70-9.ec2.internal\",\"privateIpAddress\":\"172.31.70.9\",\"privateIpAddresses\":[{\"association\":null,\"primary\":true,\"privateDnsName\":\"ip-172-31-70-9.ec2.internal\",\"privateIpAddress\":\"172.31.70.9\"}],\"sourceDestCheck\":true,\"status\":\"in-use\",\"subnetId\":\"subnet-cad1f2f4\",\"vpcId\":\"vpc-2d96be57\",\"interfaceType\":\"interface\"}],\"outpostArn\":null,\"rootDeviceName\":\"/dev/xvda\",\"rootDeviceType\":\"ebs\",\"securityGroups\":[{\"groupName\":\"minhaec2\",\"groupId\":\"sg-0fb295a327d9b4835\"}],\"sourceDestCheck\":true,\"spotInstanceRequestId\":null,\"sriovNetSupport\":null,\"stateReason\":{\"code\":\"Client.UserInitiatedShutdown\",\"message\":\"Client.UserInitiatedShutdown: User initiated shutdown\"},\"tags\":[{\"key\":\"projeto\",\"value\":\"meetup\"},{\"key\":\"Name\",\"value\":\"Minha\"},{\"key\":\"CentroCusto\",\"value\":\"TI\"},{\"key\":\"Setor\",\"value\":\"Desenvolvimento\"}],\"virtualizationType\":\"hvm\",\"cpuOptions\":{\"coreCount\":2,\"threadsPerCore\":1},\"capacityReservationId\":null,\"capacityReservationSpecification\":{\"capacityReservationPreference\":\"open\",\"capacityReservationTarget\":null},\"hibernationOptions\":{\"configured\":false},\"licenses\":[],\"metadataOptions\":{\"state\":\"applied\",\"httpTokens\":\"optional\",\"httpPutResponseHopLimit\":1,\"httpEndpoint\":\"enabled\"},\"enclaveOptions\":{\"enabled\":false},\"bootMode\":null},\"supplementaryConfiguration\":{},\"tags\":{\"projeto\":\"meetup\",\"Setor\":\"Desenvolvimento\",\"CentroCusto\":\"TI\",\"Name\":\"Minha\"},\"configurationItemVersion\":\"1.3\",\"configurationItemCaptureTime\":\"2023-04-27T15:03:11.636Z\",\"configurationStateId\":1682607791636,\"awsAccountId\":\"0123456789012\",\"configurationItemStatus\":\"OK\",\"resourceType\":\"AWS::EC2::Instance\",\"resourceId\":\"i-042dd005362091826\",\"resourceName\":null,\"ARN\":\"arn:aws:ec2:us-east-1:0123456789012:instance/i-042dd005362091826\",\"awsRegion\":\"us-east-1\",\"availabilityZone\":\"us-east-1e\",\"configurationStateMd5Hash\":\"\",\"resourceCreationTime\":\"2023-04-27T14:57:16.000Z\"},\"notificationCreationTime\":\"2023-04-27T15:03:13.332Z\",\"messageType\":\"ConfigurationItemChangeNotification\",\"recordVersion\":\"1.3\"}", + "ruleParameters":"{\"desiredInstanceType\": \"t2.micro\"}", + "resultToken":"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", + "eventLeftScope":false, + "executionRoleArn":"arn:aws:iam::0123456789012:role/aws-service-role/config.amazonaws.com/AWSServiceRoleForConfig", + "configRuleArn":"arn:aws:config:us-east-1:0123456789012:config-rule/config-rule-i9y8j9", + "configRuleName":"MyRule", + "configRuleId":"config-rule-i9y8j9", + "accountId":"0123456789012", + "evaluationMode":"DETECTIVE" + } diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleOversizedConfiguration.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleOversizedConfiguration.json new file mode 100644 index 0000000000000000000000000000000000000000..5eaef4e0015e001878edc6ef38e787f2ef9b7df8 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleOversizedConfiguration.json @@ -0,0 +1,12 @@ +{ + "invokingEvent": "{\"configurationItemSummary\": {\"changeType\": \"UPDATE\",\"configurationItemVersion\": \"1.2\",\"configurationItemCaptureTime\":\"2016-10-06T16:46:16.261Z\",\"configurationStateId\": 0,\"awsAccountId\":\"123456789012\",\"configurationItemStatus\": \"OK\",\"resourceType\": \"AWS::EC2::Instance\",\"resourceId\":\"i-00000000\",\"resourceName\":null,\"ARN\":\"arn:aws:ec2:us-west-2:123456789012:instance/i-00000000\",\"awsRegion\": \"us-west-2\",\"availabilityZone\":\"us-west-2a\",\"configurationStateMd5Hash\":\"8f1ee69b287895a0f8bc5753eca68e96\",\"resourceCreationTime\":\"2016-10-06T16:46:10.489Z\"},\"messageType\":\"OversizedConfigurationItemChangeNotification\", \"notificationCreationTime\": \"2016-10-06T16:46:16.261Z\", \"recordVersion\": \"1.0\"}", + "ruleParameters": "{\"myParameterKey\":\"myParameterValue\"}", + "resultToken": "myResultToken", + "eventLeftScope": false, + "executionRoleArn": "arn:aws:iam::123456789012:role/config-role", + "configRuleArn": "arn:aws:config:us-east-2:123456789012:config-rule/config-rule-ec2-managed-instance-inventory", + "configRuleName": "change-triggered-config-rule", + "configRuleId": "config-rule-0123456", + "accountId": "123456789012", + "version": "1.0" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleScheduled.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleScheduled.json new file mode 100644 index 0000000000000000000000000000000000000000..02ce2a0700c32f623279de85a22ef8ae8a7f2892 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/awsConfigRuleScheduled.json @@ -0,0 +1,13 @@ +{ + "version":"1.0", + "invokingEvent":"{\"awsAccountId\":\"0123456789012\",\"notificationCreationTime\":\"2023-04-27T13:26:17.741Z\",\"messageType\":\"ScheduledNotification\",\"recordVersion\":\"1.0\"}", + "ruleParameters":"{\"test\":\"x\"}", + "resultToken":"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", + "eventLeftScope":false, + "executionRoleArn":"arn:aws:iam::0123456789012:role/aws-service-role/config.amazonaws.com/AWSServiceRoleForConfig", + "configRuleArn":"arn:aws:config:us-east-1:0123456789012:config-rule/config-rule-pdmyw1", + "configRuleName":"rule-ec2-test", + "configRuleId":"config-rule-pdmyw1", + "accountId":"0123456789012", + "evaluationMode":"DETECTIVE" + } diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..b7ad75b3c43c1424ed0af1786afff0dafe01bdf6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentEvent.json @@ -0,0 +1,16 @@ +{ + "actionGroup": "ClaimManagementActionGroup", + "messageVersion": "1.0", + "sessionId": "12345678912345", + "sessionAttributes": {}, + "promptSessionAttributes": {}, + "inputText": "I want to claim my insurance", + "agent": { + "alias": "TSTALIASID", + "name": "test", + "version": "DRAFT", + "id": "8ZXY0W8P1H" + }, + "httpMethod": "GET", + "apiPath": "/claims" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentEventWithPathParams.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentEventWithPathParams.json new file mode 100644 index 0000000000000000000000000000000000000000..c7ce8ccaf54ccd1b0366dbd2ce48317d35ee2422 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentEventWithPathParams.json @@ -0,0 +1,23 @@ +{ + "actionGroup": "ClaimManagementActionGroup", + "messageVersion": "1.0", + "sessionId": "12345678912345", + "sessionAttributes": {}, + "promptSessionAttributes": {}, + "inputText": "I want to claim my insurance", + "agent": { + "alias": "TSTALIASID", + "name": "test", + "version": "DRAFT", + "id": "8ZXY0W8P1H" + }, + "parameters": [ + { + "type": "string", + "name": "claim_id", + "value": "123" + } + ], + "httpMethod": "GET", + "apiPath": "/claims/" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentPostEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentPostEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..f223bfcd516f8805a256ec60cbcd944be2137bf8 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/bedrockAgentPostEvent.json @@ -0,0 +1,35 @@ +{ + "actionGroup": "ClaimManagementActionGroup", + "messageVersion": "1.0", + "sessionId": "12345678912345", + "sessionAttributes": {}, + "promptSessionAttributes": {}, + "inputText": "Send reminders to all pending documents", + "agent": { + "alias": "TSTALIASID", + "name": "test", + "version": "DRAFT", + "id": "8ZXY0W8P1H" + }, + "httpMethod": "POST", + "apiPath": "/send-reminders", + "requestBody": { + "content": { + "application/json": { + "properties": [ + { + "name": "claimId", + "type": "string", + "value": "20" + }, + { + "name": "pendingDocuments", + "type": "string", + "value": "social number and vat" + } + ] + } + } + }, + "parameters": [] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchAlarmEventCompositeMetric.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchAlarmEventCompositeMetric.json new file mode 100644 index 0000000000000000000000000000000000000000..67200c10edb3dabda9cb21268a70dd9e41382017 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchAlarmEventCompositeMetric.json @@ -0,0 +1,30 @@ +{ + "source":"aws.cloudwatch", + "alarmArn":"arn:aws:cloudwatch:us-east-1:111122223333:alarm:SuppressionDemo.Main", + "accountId":"111122223333", + "time":"2023-08-04T12:56:46.138+0000", + "region":"us-east-1", + "alarmData":{ + "alarmName":"CompositeDemo.Main", + "state":{ + "value":"ALARM", + "reason":"arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild transitioned to ALARM at Friday 04 August, 2023 12:54:46 UTC", + "reasonData":"{\"triggeringAlarms\":[{\"arn\":\"arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild\",\"state\":{\"value\":\"ALARM\",\"timestamp\":\"2023-08-04T12:54:46.138+0000\"}}]}", + "timestamp":"2023-08-04T12:56:46.138+0000" + }, + "previousState":{ + "value":"ALARM", + "reason":"arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild transitioned to ALARM at Friday 04 August, 2023 12:54:46 UTC", + "reasonData":"{\"triggeringAlarms\":[{\"arn\":\"arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild\",\"state\":{\"value\":\"ALARM\",\"timestamp\":\"2023-08-04T12:54:46.138+0000\"}}]}", + "timestamp":"2023-08-04T12:54:46.138+0000", + "actionsSuppressedBy":"WaitPeriod", + "actionsSuppressedReason":"Actions suppressed by WaitPeriod" + }, + "configuration":{ + "alarmRule":"ALARM(CompositeDemo.FirstChild) OR ALARM(CompositeDemo.SecondChild)", + "actionsSuppressor":"CompositeDemo.ActionsSuppressor", + "actionsSuppressorWaitPeriod":120, + "actionsSuppressorExtensionPeriod":180 + } + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchAlarmEventSingleMetric.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchAlarmEventSingleMetric.json new file mode 100644 index 0000000000000000000000000000000000000000..fa5089cd6b51981c1e5f5f3a1d0b5218a8a9c155 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchAlarmEventSingleMetric.json @@ -0,0 +1,59 @@ +{ + "source": "aws.cloudwatch", + "alarmArn": "arn:aws:cloudwatch:eu-west-1:912397435824:alarm:test_alarm", + "accountId": "123456789012", + "time": "2024-02-17T11:53:08.431+0000", + "region": "eu-west-1", + "alarmData": { + "alarmName": "Test alert", + "state": { + "value": "ALARM", + "reason": "Threshold Crossed: 1 out of the last 1 datapoints [1.0 (17/02/24 11:51:00)] was less than the threshold (10.0) (minimum 1 datapoint for OK -> ALARM transition).", + "reasonData": "{\"version\":\"1.0\",\"queryDate\":\"2024-02-17T11:53:08.423+0000\",\"startDate\":\"2024-02-17T11:51:00.000+0000\",\"statistic\":\"SampleCount\",\"period\":60,\"recentDatapoints\":[1.0],\"threshold\":10.0,\"evaluatedDatapoints\":[{\"timestamp\":\"2024-02-17T11:51:00.000+0000\",\"sampleCount\":1.0,\"value\":1.0}]}", + "timestamp": "2024-02-17T11:53:08.431+0000" + }, + "previousState": { + "value": "OK", + "reason": "Threshold Crossed: 1 out of the last 1 datapoints [1.0 (17/02/24 11:50:00)] was not greater than the threshold (10.0) (minimum 1 datapoint for ALARM -> OK transition).", + "reasonData": "{\"version\":\"1.0\",\"queryDate\":\"2024-02-17T11:51:31.460+0000\",\"startDate\":\"2024-02-17T11:50:00.000+0000\",\"statistic\":\"SampleCount\",\"period\":60,\"recentDatapoints\":[1.0],\"threshold\":10.0,\"evaluatedDatapoints\":[{\"timestamp\":\"2024-02-17T11:50:00.000+0000\",\"sampleCount\":1.0,\"value\":1.0}]}", + "timestamp": "2024-02-17T11:51:31.462+0000" + }, + "configuration": { + "description": "This is description **here**", + "metrics": [ + { + "id": "e1", + "expression": "m1/m2", + "label": "Expression1", + "returnData": true + }, + { + "id": "m1", + "metricStat": { + "metric": { + "namespace": "AWS/Lambda", + "name": "Invocations", + "dimensions": {} + }, + "period": 60, + "stat": "SampleCount" + }, + "returnData": false + }, + { + "id": "m2", + "metricStat": { + "metric": { + "namespace": "AWS/Lambda", + "name": "Duration", + "dimensions": {} + }, + "period": 60, + "stat": "SampleCount" + }, + "returnData": false + } + ] + } + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchDashboardEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchDashboardEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..fd2d3be62d6b556a5436d66efe4c683622fcc3ef --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchDashboardEvent.json @@ -0,0 +1,38 @@ +{ + "original": "param-to-widget", + "widgetContext": { + "dashboardName": "Name-of-current-dashboard", + "widgetId": "widget-16", + "domain": "https://us-east-1.console.aws.amazon.com", + "accountId": "123456789123", + "locale": "en", + "timezone": { + "label": "UTC", + "offsetISO": "+00:00", + "offsetInMinutes": 0 + }, + "period": 300, + "isAutoPeriod": true, + "timeRange": { + "mode": "relative", + "start": 1627236199729, + "end": 1627322599729, + "relativeStart": 86400012, + "zoom": { + "start": 1627276030434, + "end": 1627282956521 + } + }, + "theme": "light", + "linkCharts": true, + "title": "Tweets for Amazon website problem", + "forms": { + "all": {} + }, + "params": { + "original": "param-to-widget" + }, + "width": 588, + "height": 369 + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchLogEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchLogEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..aa184c1d01314a9f62eda70edf4244e7ac0fef89 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchLogEvent.json @@ -0,0 +1,5 @@ +{ + "awslogs": { + "data": "H4sIAAAAAAAAAHWPwQqCQBCGX0Xm7EFtK+smZBEUgXoLCdMhFtKV3akI8d0bLYmibvPPN3wz00CJxmQnTO41whwWQRIctmEcB6sQbFC3CjW3XW8kxpOpP+OC22d1Wml1qZkQGtoMsScxaczKN3plG8zlaHIta5KqWsozoTYw3/djzwhpLwivWFGHGpAFe7DL68JlBUk+l7KSN7tCOEJ4M3/qOI49vMHj+zCKdlFqLaU2ZHV2a4Ct/an0/ivdX8oYc1UVX860fQDQiMdxRQEAAA==" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchLogEventWithPolicyLevel.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchLogEventWithPolicyLevel.json new file mode 100644 index 0000000000000000000000000000000000000000..4b29acab1d6c75e377fd9a2a266589285a22a360 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudWatchLogEventWithPolicyLevel.json @@ -0,0 +1,5 @@ +{ + "awslogs": { + "data": "eNqFj0+LwjAQxe9+ipCzh7Yb1z+30o0ixO3SdhdEpNR2kEDblCTuIuJ33yS1i4dFL0Nmfi/vzVxGCOEGlCqOkJ07wAuE38IszDc0TcMVxWMrED8tSIv84IVMXqezuXn0qBbHlRSnzlINSrOhH2iqJRTNHb4NHFengyol7zQX7ZLXGqQyyp2T9j3eD0b0G1rtsBkgdHHVIF5Zc7B0XfnO1801N3fporGr+YR4hATz2dTzvD/F7W77fUeTJE72aMml0sjGo4E69XX8IDR4Huo/Ck2hFG31X6qp/f2dqHl5ZiawxgscRlH8+Z7ljH5Rln/EbB1t8ej6C87if5I=" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceCreate.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceCreate.json new file mode 100644 index 0000000000000000000000000000000000000000..5c32d8c7aa1bce152f80e2b882f1b8b55849c3c1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceCreate.json @@ -0,0 +1,13 @@ +{ + "RequestType": "Create", + "ServiceToken": "arn:aws:lambda:us-east-1:xxx:function:xxxx-CrbuiltinfunctionidProvi-2vKAalSppmKe", + "ResponseURL": "https://cloudformation-custom-resource-response-useast1.s3.amazonaws.com/7F%7Cb1f50fdfc25f3b", + "StackId": "arn:aws:cloudformation:us-east-1:xxxx:stack/xxxx/271845b0-f2e8-11ed-90ac-0eeb25b8ae21", + "RequestId": "xxxxx-d2a0-4dfb-ab1f-xxxxxx", + "LogicalResourceId": "xxxxxxxxx", + "ResourceType": "Custom::MyType", + "ResourceProperties": { + "ServiceToken": "arn:aws:lambda:us-east-1:xxxxx:function:xxxxx", + "MyProps": "ss" + } +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceDelete.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceDelete.json new file mode 100644 index 0000000000000000000000000000000000000000..ddf433978d24625a602cae03eee7a60e5ccc426f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceDelete.json @@ -0,0 +1,14 @@ +{ + "RequestType": "Delete", + "ServiceToken": "arn:aws:lambda:us-east-1:xxx:function:xxxx-CrbuiltinfunctionidProvi-2vKAalSppmKe", + "ResponseURL": "https://cloudformation-custom-resource-response-useast1.s3.amazonaws.com/7F%7Cb1f50fdfc25f3b", + "StackId": "arn:aws:cloudformation:us-east-1:xxxx:stack/xxxx/271845b0-f2e8-11ed-90ac-0eeb25b8ae21", + "RequestId": "xxxxx-d2a0-4dfb-ab1f-xxxxxx", + "LogicalResourceId": "xxxxxxxxx", + "PhysicalResourceId": "xxxxxxxxx", + "ResourceType": "Custom::MyType", + "ResourceProperties": { + "ServiceToken": "arn:aws:lambda:us-east-1:xxxxx:function:xxxxx", + "MyProps": "ss" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceUpdate.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceUpdate.json new file mode 100644 index 0000000000000000000000000000000000000000..c997d8d9d60c099b00130d8df2ec5fa08ceb1253 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cloudformationCustomResourceUpdate.json @@ -0,0 +1,18 @@ +{ + "RequestType": "Update", + "ServiceToken": "arn:aws:lambda:us-east-1:xxx:function:xxxx-CrbuiltinfunctionidProvi-2vKAalSppmKe", + "ResponseURL": "https://cloudformation-custom-resource-response-useast1.s3.amazonaws.com/7F%7Cb1f50fdfc25f3b", + "StackId": "arn:aws:cloudformation:us-east-1:xxxx:stack/xxxx/271845b0-f2e8-11ed-90ac-0eeb25b8ae21", + "RequestId": "xxxxx-d2a0-4dfb-ab1f-xxxxxx", + "LogicalResourceId": "xxxxxxxxx", + "PhysicalResourceId": "xxxxxxxxx", + "ResourceType": "Custom::MyType", + "ResourceProperties": { + "ServiceToken": "arn:aws:lambda:us-east-1:xxxxx:function:xxxxx", + "MyProps": "new" + }, + "OldResourceProperties": { + "ServiceToken": "arn:aws:lambda:us-east-1:xxxxx:function:xxxxx-xxxx-xxx", + "MyProps": "old" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/codeDeployLifecycleHookEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/codeDeployLifecycleHookEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..6e422a2d5051122b604bf2774c88ad89f61935bd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/codeDeployLifecycleHookEvent.json @@ -0,0 +1,4 @@ +{ + "DeploymentId": "d-ABCDEF", + "LifecycleEventHookExecutionId": "xxxxxxxxxxxxxxxxxxxxxxxx" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..d7abe51346843ecbacf32ceadb5cc7200d561d42 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEvent.json @@ -0,0 +1,34 @@ +{ + "CodePipeline.job": { + "id": "11111111-abcd-1111-abcd-111111abcdef", + "accountId": "111111111111", + "data": { + "actionConfiguration": { + "configuration": { + "FunctionName": "MyLambdaFunctionForAWSCodePipeline", + "UserParameters": "some-input-such-as-a-URL" + } + }, + "inputArtifacts": [ + { + "name": "ArtifactName", + "revision": null, + "location": { + "type": "S3", + "s3Location": { + "bucketName": "the name of the bucket configured as the pipeline artifact store in Amazon S3, for example codepipeline-us-east-2-1234567890", + "objectKey": "the name of the application, for example CodePipelineDemoApplication.zip" + } + } + } + ], + "outputArtifacts": [], + "artifactCredentials": { + "accessKeyId": "AKIAIOSFODNN7EXAMPLE", + "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", + "sessionToken": "MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auNKyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6GuoEDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=" + }, + "continuationToken": "A continuation token if continuing job" + } + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventData.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventData.json new file mode 100644 index 0000000000000000000000000000000000000000..3635312c38bd3a460aa2731e1c280927ab184eba --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventData.json @@ -0,0 +1,50 @@ +{ + "CodePipeline.job": { + "id": "c0d76431-b0e7-xmpl-97e3-e8ee786eb6f6", + "accountId": "123456789012", + "data": { + "actionConfiguration": { + "configuration": { + "FunctionName": "my-function", + "UserParameters": "{\"KEY\": \"VALUE\"}" + } + }, + "inputArtifacts": [ + { + "name": "my-pipeline-SourceArtifact", + "revision": "e0c7xmpl2308ca3071aa7bab414de234ab52eea", + "location": { + "type": "S3", + "s3Location": { + "bucketName": "us-west-2-123456789012-my-pipeline", + "objectKey": "my-pipeline/test-api-2/TdOSFRV" + } + } + } + ], + "outputArtifacts": [ + { + "name": "invokeOutput", + "revision": null, + "location": { + "type": "S3", + "s3Location": { + "bucketName": "us-west-2-123456789012-my-pipeline", + "objectKey": "my-pipeline/invokeOutp/D0YHsJn" + } + } + } + ], + "artifactCredentials": { + "accessKeyId": "AKIAIOSFODNN7EXAMPLE", + "secretAccessKey": "6CGtmAa3lzWtV7a...", + "sessionToken": "IQoJb3JpZ2luX2VjEA...", + "expirationTime": 1575493418000 + }, + "encryptionKey": { + "id": "someKey", + "type": "KMS" + } + } + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventEmptyUserParameters.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventEmptyUserParameters.json new file mode 100644 index 0000000000000000000000000000000000000000..1a0dec6a15e05a7abb7dd4b8d4de904b95752383 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventEmptyUserParameters.json @@ -0,0 +1,32 @@ +{ + "CodePipeline.job": { + "id": "11111111-abcd-1111-abcd-111111abcdef", + "accountId": "111111111111", + "data": { + "actionConfiguration": { + "configuration": { + "FunctionName": "MyLambdaFunctionForAWSCodePipeline" + } + }, + "inputArtifacts": [ + { + "name": "ArtifactName", + "revision": null, + "location": { + "type": "S3", + "s3Location": { + "bucketName": "the name of the bucket configured as the pipeline artifact store in Amazon S3, for example codepipeline-us-east-2-1234567890", + "objectKey": "the name of the application, for example CodePipelineDemoApplication.zip" + } + } + } + ], + "outputArtifacts": [], + "artifactCredentials": { + "accessKeyId": "AKIAIOSFODNN7EXAMPLE", + "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", + "sessionToken": "MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auNKyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6GuoEDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=" + } + } + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventWithEncryptionKey.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventWithEncryptionKey.json new file mode 100644 index 0000000000000000000000000000000000000000..e4a8528e148ad48925c6b4f265f99f34a1585aac --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/codePipelineEventWithEncryptionKey.json @@ -0,0 +1,38 @@ +{ + "CodePipeline.job": { + "id": "11111111-abcd-1111-abcd-111111abcdef", + "accountId": "111111111111", + "data": { + "actionConfiguration": { + "configuration": { + "FunctionName": "MyLambdaFunctionForAWSCodePipeline", + "UserParameters": "some-input-such-as-a-URL" + } + }, + "inputArtifacts": [ + { + "name": "ArtifactName", + "revision": null, + "location": { + "type": "S3", + "s3Location": { + "bucketName": "the name of the bucket configured as the pipeline artifact store in Amazon S3, for example codepipeline-us-east-2-1234567890", + "objectKey": "the name of the application, for example CodePipelineDemoApplication.zip" + } + } + } + ], + "outputArtifacts": [], + "artifactCredentials": { + "accessKeyId": "AKIAIOSFODNN7EXAMPLE", + "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", + "sessionToken": "MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auNKyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6GuoEDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=" + }, + "continuationToken": "A continuation token if continuing job", + "encryptionKey": { + "id": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab", + "type": "KMS" + } + } + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCreateAuthChallengeEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCreateAuthChallengeEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..ad018ae0829e9fe83aaf97b5acdbf992dc8c4673 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCreateAuthChallengeEvent.json @@ -0,0 +1,29 @@ +{ + "version": "1", + "region": "us-east-1", + "userPoolId": "us-east-1_example", + "userName": "UserName", + "callerContext": { + "awsSdkVersion": "awsSdkVersion", + "clientId": "clientId" + }, + "triggerSource": "CreateAuthChallenge_Authentication", + "request": { + "userAttributes": { + "sub": "4A709A36-7D63-4785-829D-4198EF10EBDA", + "email_verified": "true", + "name": "First Last", + "email": "create-auth@mail.com" + }, + "challengeName": "PASSWORD_VERIFIER", + "session" : [ + { + "challengeName": "CUSTOM_CHALLENGE", + "challengeResult": true, + "challengeMetadata": "CAPTCHA_CHALLENGE" + } + ], + "userNotFound": false + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomEmailSenderEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomEmailSenderEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..c65e304d036c22d91109167c0df7f481c13bb5bf --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomEmailSenderEvent.json @@ -0,0 +1,19 @@ +{ + "version": "1", + "triggerSource": "CustomEmailSender_SignUp", + "region": "region", + "userPoolId": "userPoolId", + "userName": "userName", + "callerContext": { + "awsSdk": "awsSdkVersion", + "clientId": "clientId" + }, + "request": { + "userAttributes": { + "phone_number_verified": false, + "email_verified": true + }, + "type": "customEmailSenderRequestV1", + "code": "someCode" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomMessageEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomMessageEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..658cd302961977450af6b4c5ed1a3945d7418a61 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomMessageEvent.json @@ -0,0 +1,21 @@ +{ + "version": "1", + "triggerSource": "CustomMessage_AdminCreateUser", + "region": "region", + "userPoolId": "userPoolId", + "userName": "userName", + "callerContext": { + "awsSdk": "awsSdkVersion", + "clientId": "clientId" + }, + "request": { + "userAttributes": { + "phone_number_verified": false, + "email_verified": true + }, + "codeParameter": "####", + "linkParameter": "{##Click Here##}", + "usernameParameter": "username" + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomSMSSenderEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomSMSSenderEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..d2ca1b218c0ced26c433aec50ae061403fe5633c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoCustomSMSSenderEvent.json @@ -0,0 +1,19 @@ +{ + "version": "1", + "triggerSource": "CustomSMSSender_SignUp", + "region": "region", + "userPoolId": "userPoolId", + "userName": "userName", + "callerContext": { + "awsSdk": "awsSdkVersion", + "clientId": "clientId" + }, + "request": { + "userAttributes": { + "phone_number_verified": false, + "email_verified": true + }, + "type": "customEmailSenderRequestV1", + "code": "someCode" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoDefineAuthChallengeEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoDefineAuthChallengeEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..80ea5ac2d983d08e624ce5ccbe0811a258e88bf2 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoDefineAuthChallengeEvent.json @@ -0,0 +1,32 @@ +{ + "version": "1", + "region": "us-east-1", + "userPoolId": "us-east-1_example", + "userName": "UserName", + "callerContext": { + "awsSdkVersion": "awsSdkVersion", + "clientId": "clientId" + }, + "triggerSource": "DefineAuthChallenge_Authentication", + "request": { + "userAttributes": { + "sub": "4A709A36-7D63-4785-829D-4198EF10EBDA", + "email_verified": "true", + "name": "First Last", + "email": "define-auth@mail.com" + }, + "session" : [ + { + "challengeName": "PASSWORD_VERIFIER", + "challengeResult": true + }, + { + "challengeName": "CUSTOM_CHALLENGE", + "challengeResult": true, + "challengeMetadata": "CAPTCHA_CHALLENGE" + } + ], + "userNotFound": true + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPostAuthenticationEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPostAuthenticationEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..d34b18eebaba6746d15558381d94178d523b37ba --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPostAuthenticationEvent.json @@ -0,0 +1,18 @@ +{ + "version": "1", + "region": "us-east-1", + "userPoolId": "us-east-1_example", + "userName": "UserName", + "callerContext": { + "awsSdkVersion": "awsSdkVersion", + "clientId": "clientId" + }, + "triggerSource": "PostAuthentication_Authentication", + "request": { + "newDeviceUsed": true, + "userAttributes": { + "email": "post-auth@mail.com" + } + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPostConfirmationEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPostConfirmationEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..e88f98150ca33dbf4c731dfcff6ebf8ccc06057f --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPostConfirmationEvent.json @@ -0,0 +1,18 @@ +{ + "version": "string", + "triggerSource": "PostConfirmation_ConfirmSignUp", + "region": "us-east-1", + "userPoolId": "string", + "userName": "userName", + "callerContext": { + "awsSdkVersion": "awsSdkVersion", + "clientId": "clientId" + }, + "request": { + "userAttributes": { + "email": "user@example.com", + "email_verified": true + } + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreAuthenticationEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreAuthenticationEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..661fea6372e835e5363549944f788fffeabe51ca --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreAuthenticationEvent.json @@ -0,0 +1,20 @@ +{ + "version": "1", + "region": "us-east-1", + "userPoolId": "us-east-1_example", + "userName": "UserName", + "callerContext": { + "awsSdkVersion": "awsSdkVersion", + "clientId": "clientId" + }, + "triggerSource": "PreAuthentication_Authentication", + "request": { + "userAttributes": { + "sub": "4A709A36-7D63-4785-829D-4198EF10EBDA", + "email_verified": "true", + "name": "First Last", + "email": "pre-auth@mail.com" + } + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreSignUpEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreSignUpEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..feb4eba25ddeec97039ce1def366297d356901dd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreSignUpEvent.json @@ -0,0 +1,18 @@ +{ + "version": "string", + "triggerSource": "PreSignUp_SignUp", + "region": "us-east-1", + "userPoolId": "string", + "userName": "userName", + "callerContext": { + "awsSdkVersion": "awsSdkVersion", + "clientId": "clientId" + }, + "request": { + "userAttributes": { + "email": "user@example.com", + "phone_number": "+12065550100" + } + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreTokenGenerationEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreTokenGenerationEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..f5ee69e0d2df87b3054526d70eb1356d95462b1e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreTokenGenerationEvent.json @@ -0,0 +1,25 @@ +{ + "version": "1", + "triggerSource": "TokenGeneration_Authentication", + "region": "us-west-2", + "userPoolId": "us-west-2_example", + "userName": "testqq", + "callerContext": { + "awsSdkVersion": "aws-sdk-unknown-unknown", + "clientId": "71ghuul37mresr7h373b704tua" + }, + "request": { + "userAttributes": { + "sub": "0b0a57c5-f013-426a-81a1-f8ffbfba21f0", + "email_verified": "true", + "cognito:user_status": "CONFIRMED", + "email": "test@mail.com" + }, + "groupConfiguration": { + "groupsToOverride": [], + "iamRolesToOverride": [], + "preferredRole": null + } + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreTokenV2GenerationEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreTokenV2GenerationEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..c17f26c943a3420c98cc808da56f3e06bfeddf6a --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoPreTokenV2GenerationEvent.json @@ -0,0 +1,28 @@ +{ + "version": "1", + "triggerSource": "TokenGeneration_Authentication", + "region": "us-west-2", + "userPoolId": "us-west-2_example", + "userName": "testqq", + "callerContext": { + "awsSdkVersion": "aws-sdk-unknown-unknown", + "clientId": "clientId" + }, + "request": { + "userAttributes": { + "sub": "0b0a57c5-f013-426a-81a1-f8ffbfba21f0", + "email_verified": "true", + "cognito:user_status": "CONFIRMED", + "email": "test@mail.com" + }, + "groupConfiguration": { + "groupsToOverride": [], + "iamRolesToOverride": [], + "preferredRole": null + }, + "scopes": [ + "aws.cognito.signin.user.admin" + ] + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoUserMigrationEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoUserMigrationEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..2eae4e66189590bbfb890c49c395fc4823b12502 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoUserMigrationEvent.json @@ -0,0 +1,15 @@ +{ + "version": "string", + "triggerSource": "UserMigration_Authentication", + "region": "us-east-1", + "userPoolId": "string", + "userName": "userName", + "callerContext": { + "awsSdkVersion": "awsSdkVersion", + "clientId": "clientId" + }, + "request": { + "password": "password" + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoVerifyAuthChallengeResponseEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoVerifyAuthChallengeResponseEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..2ebcdb5c278bb6c681674dfd66d850fb6cc47765 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/cognitoVerifyAuthChallengeResponseEvent.json @@ -0,0 +1,28 @@ +{ + "version": "1", + "region": "us-east-1", + "userPoolId": "us-east-1_example", + "userName": "UserName", + "callerContext": { + "awsSdkVersion": "awsSdkVersion", + "clientId": "clientId" + }, + "triggerSource": "VerifyAuthChallengeResponse_Authentication", + "request": { + "userAttributes": { + "sub": "4A709A36-7D63-4785-829D-4198EF10EBDA", + "email_verified": "true", + "name": "First Last", + "email": "verify-auth@mail.com" + }, + "privateChallengeParameters": { + "answer": "challengeAnswer" + }, + "clientMetadata" : { + "foo": "value" + }, + "challengeAnswer": "challengeAnswer", + "userNotFound": true + }, + "response": {} +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/connectContactFlowEventAll.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/connectContactFlowEventAll.json new file mode 100644 index 0000000000000000000000000000000000000000..5850649b6eb60379c1236d8dd54a4cab35ae90fd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/connectContactFlowEventAll.json @@ -0,0 +1,41 @@ +{ + "Name": "ContactFlowEvent", + "Details": { + "ContactData": { + "Attributes": { + "Language": "en-US" + }, + "Channel": "VOICE", + "ContactId": "5ca32fbd-8f92-46af-92a5-6b0f970f0efe", + "CustomerEndpoint": { + "Address": "+11234567890", + "Type": "TELEPHONE_NUMBER" + }, + "InitialContactId": "5ca32fbd-8f92-46af-92a5-6b0f970f0efe", + "InitiationMethod": "API", + "InstanceARN": "arn:aws:connect:eu-central-1:123456789012:instance/9308c2a1-9bc6-4cea-8290-6c0b4a6d38fa", + "MediaStreams": { + "Customer": { + "Audio": { + "StartFragmentNumber": "91343852333181432392682062622220590765191907586", + "StartTimestamp": "1565781909613", + "StreamARN": "arn:aws:kinesisvideo:eu-central-1:123456789012:stream/connect-contact-a3d73b84-ce0e-479a-a9dc-5637c9d30ac9/1565272947806" + } + } + }, + "PreviousContactId": "5ca32fbd-8f92-46af-92a5-6b0f970f0efe", + "Queue": { + "ARN": "arn:aws:connect:eu-central-1:123456789012:instance/9308c2a1-9bc6-4cea-8290-6c0b4a6d38fa/queue/5cba7cbf-1ecb-4b6d-b8bd-fe91079b3fc8", + "Name": "QueueOne" + }, + "SystemEndpoint": { + "Address": "+11234567890", + "Type": "TELEPHONE_NUMBER" + } + }, + "Parameters": { + "ParameterOne": "One", + "ParameterTwo": "Two" + } + } +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/connectContactFlowEventMin.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/connectContactFlowEventMin.json new file mode 100644 index 0000000000000000000000000000000000000000..9cc22d59c3fb64a79642231a481ef3786153b7e1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/connectContactFlowEventMin.json @@ -0,0 +1,27 @@ +{ + "Name": "ContactFlowEvent", + "Details": { + "ContactData": { + "Attributes": {}, + "Channel": "VOICE", + "ContactId": "5ca32fbd-8f92-46af-92a5-6b0f970f0efe", + "CustomerEndpoint": null, + "InitialContactId": "5ca32fbd-8f92-46af-92a5-6b0f970f0efe", + "InitiationMethod": "API", + "InstanceARN": "arn:aws:connect:eu-central-1:123456789012:instance/9308c2a1-9bc6-4cea-8290-6c0b4a6d38fa", + "MediaStreams": { + "Customer": { + "Audio": { + "StartFragmentNumber": null, + "StartTimestamp": null, + "StreamARN": null + } + } + }, + "PreviousContactId": "5ca32fbd-8f92-46af-92a5-6b0f970f0efe", + "Queue": null, + "SystemEndpoint": null + }, + "Parameters": {} + } +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/dynamoStreamEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/dynamoStreamEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..16009a7a956ba539f755d65f39627d8aa4969906 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/dynamoStreamEvent.json @@ -0,0 +1,65 @@ +{ + "Records": [ + { + "eventID": "1", + "eventVersion": "1.0", + "dynamodb": { + "ApproximateCreationDateTime": 1693997155.0, + "Keys": { + "Id": { + "N": "101" + } + }, + "NewImage": { + "Message": { + "S": "New item!" + }, + "Id": { + "N": "101" + } + }, + "StreamViewType": "NEW_AND_OLD_IMAGES", + "SequenceNumber": "111", + "SizeBytes": 26 + }, + "awsRegion": "us-west-2", + "eventName": "INSERT", + "eventSourceARN": "eventsource_arn", + "eventSource": "aws:dynamodb" + }, + { + "eventID": "2", + "eventVersion": "1.0", + "dynamodb": { + "OldImage": { + "Message": { + "S": "New item!" + }, + "Id": { + "N": "101" + } + }, + "SequenceNumber": "222", + "Keys": { + "Id": { + "N": "101" + } + }, + "SizeBytes": 59, + "NewImage": { + "Message": { + "S": "This item has changed" + }, + "Id": { + "N": "101" + } + }, + "StreamViewType": "NEW_AND_OLD_IMAGES" + }, + "awsRegion": "us-west-2", + "eventName": "MODIFY", + "eventSourceARN": "source_arn", + "eventSource": "aws:dynamodb" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/eventBridgeEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/eventBridgeEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..65872cf9a34dc42832ef5cc13dcf00afff0cd413 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/eventBridgeEvent.json @@ -0,0 +1,17 @@ +{ + "version": "0", + "id": "6a7e8feb-b491-4cf7-a9f1-bf3703467718", + "detail-type": "EC2 Instance State-change Notification", + "source": "aws.ec2", + "account": "111122223333", + "time": "2017-12-22T18:43:48Z", + "region": "us-west-1", + "resources": [ + "arn:aws:ec2:us-west-1:123456789012:instance/i-1234567890abcdef0" + ], + "detail": { + "instance_id": "i-1234567890abcdef0", + "state": "terminated" + }, + "replay-name": "replay_archive" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/kafkaEventMsk.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/kafkaEventMsk.json new file mode 100644 index 0000000000000000000000000000000000000000..5a35b89680ad803d9037b7fb87ea85e7000af8e6 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/kafkaEventMsk.json @@ -0,0 +1,35 @@ +{ + "eventSource":"aws:kafka", + "eventSourceArn":"arn:aws:kafka:us-east-1:0123456789019:cluster/SalesCluster/abcd1234-abcd-cafe-abab-9876543210ab-4", + "bootstrapServers":"b-2.demo-cluster-1.a1bcde.c1.kafka.us-east-1.amazonaws.com:9092,b-1.demo-cluster-1.a1bcde.c1.kafka.us-east-1.amazonaws.com:9092", + "records":{ + "mytopic-0":[ + { + "topic":"mytopic", + "partition":0, + "offset":15, + "timestamp":1545084650987, + "timestampType":"CREATE_TIME", + "key":"cmVjb3JkS2V5", + "value":"eyJrZXkiOiJ2YWx1ZSJ9", + "headers":[ + { + "headerKey":[ + 104, + 101, + 97, + 100, + 101, + 114, + 86, + 97, + 108, + 117, + 101 + ] + } + ] + } + ] + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/kafkaEventSelfManaged.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/kafkaEventSelfManaged.json new file mode 100644 index 0000000000000000000000000000000000000000..eaf0bf34cae613f7003fb86e9c29b03d1f8e1211 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/kafkaEventSelfManaged.json @@ -0,0 +1,34 @@ +{ + "eventSource": "SelfManagedKafka", + "bootstrapServers": "b-2.demo-cluster-1.a1bcde.c1.kafka.us-east-1.amazonaws.com:9092,b-1.demo-cluster-1.a1bcde.c1.kafka.us-east-1.amazonaws.com:9092", + "records": { + "mytopic-0": [ + { + "topic": "mytopic", + "partition": 0, + "offset": 15, + "timestamp": 1545084650987, + "timestampType": "CREATE_TIME", + "key": "cmVjb3JkS2V5", + "value": "eyJrZXkiOiJ2YWx1ZSJ9", + "headers": [ + { + "headerKey": [ + 104, + 101, + 97, + 100, + 101, + 114, + 86, + 97, + 108, + 117, + 101 + ] + } + ] + } + ] + } +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehoseKinesisEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehoseKinesisEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..6cdd8e8a5b4275265eb4adad6b29d426db3b815e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehoseKinesisEvent.json @@ -0,0 +1,32 @@ +{ + "invocationId": "2b4d1ad9-2f48-94bd-a088-767c317e994a", + "sourceKinesisStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/kinesis-source", + "deliveryStreamArn": "arn:aws:firehose:us-east-2:123456789012:deliverystream/delivery-stream-name", + "region": "us-east-2", + "records": [ + { + "data": "SGVsbG8gV29ybGQ=", + "recordId": "record1", + "approximateArrivalTimestamp": 1664028820148, + "kinesisRecordMetadata": { + "shardId": "shardId-000000000000", + "partitionKey": "4d1ad2b9-24f8-4b9d-a088-76e9947c317a", + "approximateArrivalTimestamp": 1664028820148, + "sequenceNumber": "49546986683135544286507457936321625675700192471156785154", + "subsequenceNumber": 0 + } + }, + { + "data": "eyJIZWxsbyI6ICJXb3JsZCJ9", + "recordId": "record2", + "approximateArrivalTimestamp": 1664028793294, + "kinesisRecordMetadata": { + "shardId": "shardId-000000000001", + "partitionKey": "4d1ad2b9-24f8-4b9d-a088-76e9947c318a", + "approximateArrivalTimestamp": 1664028793294, + "sequenceNumber": "49546986683135544286507457936321625675700192471156785155", + "subsequenceNumber": 0 + } + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehosePutEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehosePutEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..f3e07190710190c0a1fa378dddfb92fe4cf3390d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehosePutEvent.json @@ -0,0 +1,17 @@ +{ + "invocationId": "2b4d1ad9-2f48-94bd-a088-767c317e994a", + "deliveryStreamArn": "arn:aws:firehose:us-east-2:123456789012:deliverystream/delivery-stream-name", + "region": "us-east-2", + "records": [ + { + "recordId": "record1", + "approximateArrivalTimestamp": 1664029185290, + "data": "SGVsbG8gV29ybGQ=" + }, + { + "recordId": "record2", + "approximateArrivalTimestamp": 1664029186945, + "data": "eyJIZWxsbyI6ICJXb3JsZCJ9" + } + ] + } diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehoseSQSEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehoseSQSEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..bea267c4206b1cbed686f5593501085d522f8466 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisFirehoseSQSEvent.json @@ -0,0 +1,12 @@ +{ + "invocationId": "556b67a3-48fc-4385-af49-e133aade9cb9", + "deliveryStreamArn": "arn:aws:firehose:us-east-1:123456789012:deliverystream/PUT-S3-tdyyE", + "region": "us-east-1", + "records": [ + { + "recordId": "49640912821178817833517986466168945147170627572855734274000000", + "approximateArrivalTimestamp": 1684864917398, + "data": "eyJtZXNzYWdlSWQiOiI1YWI4MDdkNC01NjQ0LTRjNTUtOTdhMy00NzM5NjYzNWFjNzQiLCJyZWNlaXB0SGFuZGxlIjoiQVFFQndKbkt5ckhpZ1VNWmo2cllpZ0NneGxhUzNTTHkwYS4uLiIsImJvZHkiOiJUZXN0IG1lc3NhZ2UuIiwiYXR0cmlidXRlcyI6eyJBcHByb3hpbWF0ZVJlY2VpdmVDb3VudCI6IjEiLCJTZW50VGltZXN0YW1wIjoiMTY4NDg2NDg1MjQ5MSIsIlNlbmRlcklkIjoiQUlEQUlFTlFaSk9MTzIzWVZKNFZPIiwiQXBwcm94aW1hdGVGaXJzdFJlY2VpdmVUaW1lc3RhbXAiOiIxNjg0ODY0ODcyNDkxIn0sIm1lc3NhZ2VBdHRyaWJ1dGVzIjp7fSwibWQ1T2ZNZXNzYWdlQXR0cmlidXRlcyI6bnVsbCwibWQ1T2ZCb2R5IjoiYzhiNmJjNjBjOGI4YjNhOTA0ZTQ1YzFmYWJkZjUyM2QiLCJldmVudFNvdXJjZSI6ImF3czpzcXMiLCJldmVudFNvdXJjZUFSTiI6ImFybjphd3M6c3FzOnVzLWVhc3QtMToyMDA5ODQxMTIzODY6U05TIiwiYXdzUmVnaW9uIjoidXMtZWFzdC0xIn0K" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamCloudWatchLogsEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamCloudWatchLogsEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..a9a6959f9078b8e449fc235fe4a79821343b79df --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamCloudWatchLogsEvent.json @@ -0,0 +1,36 @@ +{ + "Records": [ + { + "kinesis": { + "kinesisSchemaVersion": "1.0", + "partitionKey": "da10bf66b1f54bff5d96eae99149ad1f", + "sequenceNumber": "49635052289529725553291405521504870233219489715332317186", + "data": "H4sIAAAAAAAAAK2Sa2vbMBSG/4ox+xg3Oror39IlvaztVmJv7WjCUGwl8+ZLZstts5L/vuOsZYUyWGEgJHiP9J7nvOghLF3b2rVLthsXjsLJOBl/uZjG8fh4Gg7C+q5yDcqUAWcSONHEoFzU6+Om7jZYGdq7dljYcpnZ4cZHwLWOJl1Zbs/r9cR6e9RVqc/rKlpXV9eXt+fy27vt8W+L2DfOlr07oXQIMAQyvHlzPk6mcbKgciktF5lQfMU5dZZqzrShLF2uFC60aLtlmzb5prc/ygvvmjYc3YRPFG+LusuurE+/Ikqb1Gd55dq8jV+8isT6+317Rk42J5PTcLFnm966yvd2D2GeISJTYIwCJSQ1BE9OtWZCABWaKMIJAMdDMyU5MYZLhmkxBhQxfY4Re1tiWiAlBsgIVQTE4Cl6tI+T8SwJZu5Hh1dPs1FApOMSDI9WVKmIC+4irTMWQZYpx7QkztrgE06MU4yCx9DmVbgbvABmQJTGtkYAB0NwEwyYQUBpqEFuSbkGrThTRKi/AlP+HHj6fvJa3P9Ap/+Rbja9/PD6POd+0jXW7xM1B8CDsp37w7woXBb8qQDZ6xeurJttEOc/HWpUBxeHKNr74LHwsXXYlsm9flrl/rmFIQeS7m3m1fVs/DlIGpu6nhMiyWQGXNKIMbcCIgkhElKbaZnZpYJUz33s1iV+z/6+StMlR3yphHNcCyxiNEXf2zed6xuEu8XuF2wb6krnAwAA", + "approximateArrivalTimestamp": 1668093033.744 + }, + "eventSource": "aws:kinesis", + "eventVersion": "1.0", + "eventID": "shardId-000000000000:49635052289529725553291405521504870233219489715332317186", + "eventName": "aws:kinesis:record", + "invokeIdentityArn": "arn:aws:iam::231436140809:role/pt-1488-CloudWatchKinesisLogsFunctionRole-1M4G2TIWIE49", + "awsRegion": "eu-west-1", + "eventSourceARN": "arn:aws:kinesis:eu-west-1:231436140809:stream/pt-1488-KinesisStreamCloudWatchLogs-D8tHs0im0aJG" + }, + { + "kinesis": { + "kinesisSchemaVersion": "1.0", + "partitionKey": "cf4c4c2c9a49bdfaf58d7dbbc2b06081", + "sequenceNumber": "49635052289529725553291405520881064510298312199003701250", + "data": "H4sIAAAAAAAAAK2SW2/TQBCF/4pl8ViTvc7u5i0laVraQhUbWtREaG1PgsGXYK/bhqr/nXVoBRIgUYnXc2bPfHO092GFXWc3mOy2GI7D6SSZfDyfxfFkPgsPwua2xtbLjFPBgQqiifFy2WzmbdNvvTOyt92otFWa29HWRVRoHU37qtqdNZupdfaorzNXNHW0qS+vLm7O4PPr3fxHROxatNWQThgbUTqiZHT94mySzOJkBUqYLOWY8ZQLbaTRkEvDciUYzWzKfETXp13WFtsh/qgoHbZdOL4OnyhelU2fX1qXffIoXdKcFjV2RRf/9iqSmy933Sk53h5PT8LVnm12g7Ub4u7DIveIXFFjFNGUKUlAaMY0EUJKLjkQbxhKGCWeknMKoAGUkYoJ7TFd4St2tvJtDRYxDAg3VB08Ve/j42SySIIFfu396Ek+DkS+xkwAiYhM00isgUV6jXmEMrM5EmMsh+C9v9hfMQ4eS1vW4cPBH4CZVpoTJkEIAp5RUMo8vGFae3JNCCdUccMVgPw7sP4VePZm+lzc/0AH/0i3mF28fX6fSzftW+v2jZKXRgVVt3SHRVliHvx06F4+x6ppd0FcfEMvMR2cH3rR3gWPxrsO/Vau9vqyvlpMPgRJazMcYGgEHHLKBhLGJaBA0JLxNc0JppoS9Cwxbir/B4d5QDBAQSnfFFGp8aa/vxw2uLbHYUH4sHr4Dj5RJxfMAwAA", + "approximateArrivalTimestamp": 1668092612.992 + }, + "eventSource": "aws:kinesis", + "eventVersion": "1.0", + "eventID": "shardId-000000000000:49635052289529725553291405520881064510298312199003701250", + "eventName": "aws:kinesis:record", + "invokeIdentityArn": "arn:aws:iam::231436140809:role/pt-1488-CloudWatchKinesisLogsFunctionRole-1M4G2TIWIE49", + "awsRegion": "eu-west-1", + "eventSourceARN": "arn:aws:kinesis:eu-west-1:231436140809:stream/pt-1488-KinesisStreamCloudWatchLogs-D8tHs0im0aJG" + } + ] +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..ef8e20963880cd773826162443db0c10daee36d3 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamEvent.json @@ -0,0 +1,36 @@ +{ + "Records": [ + { + "kinesis": { + "kinesisSchemaVersion": "1.0", + "partitionKey": "1", + "sequenceNumber": "49590338271490256608559692538361571095921575989136588898", + "data": "SGVsbG8sIHRoaXMgaXMgYSB0ZXN0Lg==", + "approximateArrivalTimestamp": 1545084650.987 + }, + "eventSource": "aws:kinesis", + "eventVersion": "1.0", + "eventID": "shardId-000000000006:49590338271490256608559692538361571095921575989136588898", + "eventName": "aws:kinesis:record", + "invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role", + "awsRegion": "us-east-2", + "eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream" + }, + { + "kinesis": { + "kinesisSchemaVersion": "1.0", + "partitionKey": "1", + "sequenceNumber": "49590338271490256608559692540925702759324208523137515618", + "data": "VGhpcyBpcyBvbmx5IGEgdGVzdC4=", + "approximateArrivalTimestamp": 1545084711.166 + }, + "eventSource": "aws:kinesis", + "eventVersion": "1.0", + "eventID": "shardId-000000000006:49590338271490256608559692540925702759324208523137515618", + "eventName": "aws:kinesis:record", + "invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role", + "awsRegion": "us-east-2", + "eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamEventOneRecord.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamEventOneRecord.json new file mode 100644 index 0000000000000000000000000000000000000000..05fe2d297a963788351a01f306f9fd1eecbfcd44 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/kinesisStreamEventOneRecord.json @@ -0,0 +1,20 @@ +{ + "Records": [ + { + "kinesis": { + "kinesisSchemaVersion": "1.0", + "partitionKey": "1", + "sequenceNumber": "49590338271490256608559692538361571095921575989136588898", + "data": "eyJtZXNzYWdlIjogInRlc3QgbWVzc2FnZSIsICJ1c2VybmFtZSI6ICJ0ZXN0In0=", + "approximateArrivalTimestamp": 1545084650.987 + }, + "eventSource": "aws:kinesis", + "eventVersion": "1.0", + "eventID": "shardId-000000000006:49590338271490256608559692538361571095921575989136588898", + "eventName": "aws:kinesis:record", + "invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role", + "awsRegion": "us-east-2", + "eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..da5c133e6f8392b8da442204e9e0fc38fe180e27 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEvent.json @@ -0,0 +1,47 @@ +{ + "version":"2.0", + "routeKey":"$default", + "rawPath":"/", + "rawQueryString":"", + "headers":{ + "sec-fetch-mode":"navigate", + "x-amzn-tls-version":"TLSv1.2", + "sec-fetch-site":"cross-site", + "accept-language":"pt-BR,pt;q=0.9", + "x-forwarded-proto":"https", + "x-forwarded-port":"443", + "x-forwarded-for":"123.123.123.123", + "sec-fetch-user":"?1", + "accept":"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", + "x-amzn-tls-cipher-suite":"ECDHE-RSA-AES128-GCM-SHA256", + "sec-ch-ua":"\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"102\", \"Google Chrome\";v=\"102\"", + "sec-ch-ua-mobile":"?0", + "x-amzn-trace-id":"Root=1-62ecd163-5f302e550dcde3b12402207d", + "sec-ch-ua-platform":"\"Linux\"", + "host":".lambda-url.us-east-1.on.aws", + "upgrade-insecure-requests":"1", + "cache-control":"max-age=0", + "accept-encoding":"gzip, deflate, br", + "sec-fetch-dest":"document", + "user-agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36" + }, + "requestContext":{ + "accountId":"anonymous", + "apiId":"", + "domainName":".lambda-url.us-east-1.on.aws", + "domainPrefix":"", + "http":{ + "method":"GET", + "path":"/", + "protocol":"HTTP/1.1", + "sourceIp":"123.123.123.123", + "userAgent":"agent" + }, + "requestId":"id", + "routeKey":"$default", + "stage":"$default", + "time":"05/Aug/2022:08:14:39 +0000", + "timeEpoch":1659687279885 + }, + "isBase64Encoded":false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEventPathTrailingSlash.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEventPathTrailingSlash.json new file mode 100644 index 0000000000000000000000000000000000000000..b1f8226518700d839c101a2fa6c36d19993272b5 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEventPathTrailingSlash.json @@ -0,0 +1,52 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path/", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "header1": "value1", + "header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "", + "authentication": null, + "authorizer": { + "iam": { + "accessKey": "AKIA...", + "accountId": "111122223333", + "callerId": "AIDA...", + "cognitoIdentity": null, + "principalOrgId": null, + "userArn": "arn:aws:iam::111122223333:user/example-user", + "userId": "AIDA..." + } + }, + "domainName": ".lambda-url.us-west-2.on.aws", + "domainPrefix": "", + "http": { + "method": "POST", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "123.123.123.123", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "body": "Hello from client!", + "pathParameters": null, + "isBase64Encoded": false, + "stageVariables": null + } \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEventWithHeaders.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEventWithHeaders.json new file mode 100644 index 0000000000000000000000000000000000000000..d1cc50630a864442e8eb941ec7f9e5349b2b8a7c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlEventWithHeaders.json @@ -0,0 +1,53 @@ +{ + "version":"2.0", + "routeKey":"$default", + "rawPath":"/", + "rawQueryString":"", + "headers":{ + "sec-fetch-mode":"navigate", + "x-amzn-tls-version":"TLSv1.2", + "sec-fetch-site":"cross-site", + "accept-language":"pt-BR,pt;q=0.9", + "x-forwarded-proto":"https", + "x-forwarded-port":"443", + "x-forwarded-for":"123.123.123.123", + "sec-fetch-user":"?1", + "accept":"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", + "x-amzn-tls-cipher-suite":"ECDHE-RSA-AES128-GCM-SHA256", + "sec-ch-ua":"\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"102\", \"Google Chrome\";v=\"102\"", + "sec-ch-ua-mobile":"?0", + "x-amzn-trace-id":"Root=1-62ecd163-5f302e550dcde3b12402207d", + "sec-ch-ua-platform":"\"Linux\"", + "host":".lambda-url.us-east-1.on.aws", + "upgrade-insecure-requests":"1", + "cache-control":"max-age=0", + "accept-encoding":"gzip, deflate, br", + "sec-fetch-dest":"document", + "user-agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36", + "header1": "value1", + "header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext":{ + "accountId":"anonymous", + "apiId":"", + "domainName":".lambda-url.us-east-1.on.aws", + "domainPrefix":"", + "http":{ + "method":"GET", + "path":"/", + "protocol":"HTTP/1.1", + "sourceIp":"123.123.123.123", + "userAgent":"agent" + }, + "requestId":"id", + "routeKey":"$default", + "stage":"$default", + "time":"05/Aug/2022:08:14:39 +0000", + "timeEpoch":1659687279885 + }, + "isBase64Encoded":false +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlIAMEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlIAMEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..bf52342b66df518af04e8e2dc59903046a3bb914 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/lambdaFunctionUrlIAMEvent.json @@ -0,0 +1,52 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/my/path", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": [ + "cookie1", + "cookie2" + ], + "headers": { + "header1": "value1", + "header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "", + "authentication": null, + "authorizer": { + "iam": { + "accessKey": "AKIA...", + "accountId": "111122223333", + "callerId": "AIDA...", + "cognitoIdentity": null, + "principalOrgId": null, + "userArn": "arn:aws:iam::111122223333:user/example-user", + "userId": "AIDA..." + } + }, + "domainName": ".lambda-url.us-west-2.on.aws", + "domainPrefix": "", + "http": { + "method": "POST", + "path": "/my/path", + "protocol": "HTTP/1.1", + "sourceIp": "123.123.123.123", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "body": "Hello from client!", + "pathParameters": null, + "isBase64Encoded": false, + "stageVariables": null +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/rabbitMQEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/rabbitMQEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..e4259555a8be4fe94b8a04734bb315af2d5e4325 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/rabbitMQEvent.json @@ -0,0 +1,51 @@ +{ + "eventSource": "aws:rmq", + "eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:pizzaBroker:b-9bcfa592-423a-4942-879d-eb284b418fc8", + "rmqMessagesByQueue": { + "pizzaQueue::/": [ + { + "basicProperties": { + "contentType": "text/plain", + "contentEncoding": null, + "headers": { + "header1": { + "bytes": [ + 118, + 97, + 108, + 117, + 101, + 49 + ] + }, + "header2": { + "bytes": [ + 118, + 97, + 108, + 117, + 101, + 50 + ] + }, + "numberInHeader": 10 + }, + "deliveryMode": 1, + "priority": 34, + "correlationId": null, + "replyTo": null, + "expiration": "60000", + "messageId": null, + "timestamp": "Jan 1, 1970, 12:33:41 AM", + "type": null, + "userId": "AIDACKCEVSQ6C2EXAMPLE", + "appId": null, + "clusterId": null, + "bodySize": 80 + }, + "redelivered": false, + "data": "eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ==" + } + ] + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3BatchOperationEventSchemaV1.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3BatchOperationEventSchemaV1.json new file mode 100644 index 0000000000000000000000000000000000000000..8a7bcabf590e971f601caa132fda62fc6ca17c1e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3BatchOperationEventSchemaV1.json @@ -0,0 +1,15 @@ +{ + "invocationSchemaVersion": "1.0", + "invocationId": "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo", + "job": { + "id": "f3cc4f60-61f6-4a2b-8a21-d07600c373ce" + }, + "tasks": [ + { + "taskId": "dGFza2lkZ29lc2hlcmUK", + "s3Key": "prefix/dataset/dataset.20231222.json.gz", + "s3VersionId": "1", + "s3BucketArn": "arn:aws:s3:::powertools-dataset" + } + ] +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3BatchOperationEventSchemaV2.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3BatchOperationEventSchemaV2.json new file mode 100644 index 0000000000000000000000000000000000000000..720dd1f0cf037bc38aed3660fdcec8d2cb6e81eb --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3BatchOperationEventSchemaV2.json @@ -0,0 +1,19 @@ +{ + "invocationSchemaVersion": "2.0", + "invocationId": "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo", + "job": { + "id": "f3cc4f60-61f6-4a2b-8a21-d07600c373ce", + "userArguments": { + "k1": "v1", + "k2": "v2" + } + }, + "tasks": [ + { + "taskId": "dGFza2lkZ29lc2hlcmUK", + "s3Key": "prefix/dataset/dataset.20231222.json.gz", + "s3VersionId": null, + "s3Bucket": "powertools-dataset" + } + ] +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3Event.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3Event.json new file mode 100644 index 0000000000000000000000000000000000000000..4558dc3c9e1e795dcc1ae48328296cdbc193e496 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3Event.json @@ -0,0 +1,38 @@ +{ + "Records": [ + { + "eventVersion": "2.1", + "eventSource": "aws:s3", + "awsRegion": "us-east-2", + "eventTime": "2019-09-03T19:37:27.192Z", + "eventName": "ObjectCreated:Put", + "userIdentity": { + "principalId": "AWS:AIDAINPONIXQXHT3IKHL2" + }, + "requestParameters": { + "sourceIPAddress": "205.255.255.255" + }, + "responseElements": { + "x-amz-request-id": "D82B88E5F771F645", + "x-amz-id-2": "vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo=" + }, + "s3": { + "s3SchemaVersion": "1.0", + "configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1", + "bucket": { + "name": "lambda-artifacts-deafc19498e3f2df", + "ownerIdentity": { + "principalId": "A3I5XTEXAMAI3E" + }, + "arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df" + }, + "object": { + "key": "b21b84d653bb07b05b1e6b33684dc11b", + "size": 1305107, + "eTag": "b21b84d653bb07b05b1e6b33684dc11b", + "sequencer": "0C0F6F405D6ED209E1" + } + } + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectCreatedEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectCreatedEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..5cc8f2f402f5da8bdfd6cbb5ad7b7c1674fcda25 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectCreatedEvent.json @@ -0,0 +1,28 @@ +{ + "version": "0", + "id": "f5f1e65c-dc3a-93ca-6c1e-b1647eac7963", + "detail-type": "Object Created", + "source": "aws.s3", + "account": "123456789012", + "time": "2023-03-08T17:50:14Z", + "region": "eu-west-1", + "resources": [ + "arn:aws:s3:::example-bucket" + ], + "detail": { + "version": "0", + "bucket": { + "name": "example-bucket" + }, + "object": { + "key": "IMG_m7fzo3.jpg", + "size": 184662, + "etag": "4e68adba0abe2dc8653dc3354e14c01d", + "sequencer": "006408CAD69598B05E" + }, + "request-id": "57H08PA84AB1JZW0", + "requester": "123456789012", + "source-ip-address": "34.252.34.74", + "reason": "PutObject" + } +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectDeletedEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectDeletedEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..7c0995338a851cd1d0c281680b5130407fd0264b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectDeletedEvent.json @@ -0,0 +1,27 @@ +{ + "version": "0", + "id": "2ee9cc15-d022-99ea-1fb8-1b1bac4850f9", + "detail-type": "Object Deleted", + "source": "aws.s3", + "account": "111122223333", + "time": "2021-11-12T00:00:00Z", + "region": "ca-central-1", + "resources": [ + "arn:aws:s3:::example-bucket" + ], + "detail": { + "version": "0", + "bucket": { + "name": "example-bucket" + }, + "object": { + "key": "IMG_m7fzo3.jpg", + "sequencer": "006408CAD69598B05E" + }, + "request-id": "0BH729840619AG5K", + "requester": "123456789012", + "source-ip-address": "34.252.34.74", + "reason": "DeleteObject", + "deletion-type": "Delete Marker Created" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectExpiredEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectExpiredEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..ef506cc355688a22720c70d13dd21f91ae0ca9f3 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectExpiredEvent.json @@ -0,0 +1,28 @@ +{ + "version": "0", + "id": "ad1de317-e409-eba2-9552-30113f8d88e3", + "detail-type": "Object Deleted", + "source": "aws.s3", + "account": "111122223333", + "time": "2021-11-12T00:00:00Z", + "region": "ca-central-1", + "resources": [ + "arn:aws:s3:::example-bucket" + ], + "detail": { + "version": "0", + "bucket": { + "name": "example-bucket" + }, + "object": { + "key": "IMG_m7fzo3.jpg", + "size": 184662, + "etag": "4e68adba0abe2dc8653dc3354e14c01d", + "sequencer": "006408CAD69598B05E" + }, + "request-id": "20EB74C14654DC47", + "requester": "s3.amazonaws.com", + "reason": "Lifecycle Expiration", + "deletion-type": "Delete Marker Created" + } +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectRestoreCompletedEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectRestoreCompletedEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..5a2e6a4f9ec3c5ff9bcfb0be83015a7a32c3cf2e --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventBridgeNotificationObjectRestoreCompletedEvent.json @@ -0,0 +1,28 @@ +{ + "version": "0", + "id": "6924de0d-13e2-6bbf-c0c1-b903b753565e", + "detail-type": "Object Restore Completed", + "source": "aws.s3", + "account": "111122223333", + "time": "2021-11-12T00:00:00Z", + "region": "ca-central-1", + "resources": [ + "arn:aws:s3:::example-bucket" + ], + "detail": { + "version": "0", + "bucket": { + "name": "example-bucket" + }, + "object": { + "key": "IMG_m7fzo3.jpg", + "size": 184662, + "etag": "4e68adba0abe2dc8653dc3354e14c01d", + "sequencer": "006408CAD69598B05E" + }, + "request-id": "189F19CB7FB1B6A4", + "requester": "s3.amazonaws.com", + "restore-expiry-time": "2021-11-13T00:00:00Z", + "source-storage-class": "GLACIER" + } +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventDecodedKey.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventDecodedKey.json new file mode 100644 index 0000000000000000000000000000000000000000..05f5ab5c4bd98b3c1778276e12207bc158dda70c --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventDecodedKey.json @@ -0,0 +1,40 @@ +{ + "Records": [ + { + "eventVersion": "2.0", + "eventSource": "aws:s3", + "awsRegion": "us-east-1", + "eventTime": "1970-01-01T00:00:00.123Z", + "eventName": "ObjectCreated:Put", + "userIdentity": { + "principalId": "EXAMPLE" + }, + "requestParameters": { + "sourceIPAddress": "127.0.0.1" + }, + "responseElements": { + "x-amz-request-id": "C3D13FE58DE4C810", + "x-amz-id-2": "FMyUVURIY8/IgAtTv8xRjskZQpcIZ9KG4V5Wp6S7S/JRWeUWerMUE5JgHvANOjpD" + }, + "s3": { + "s3SchemaVersion": "1.0", + "configurationId": "testConfigRule", + "bucket": { + "name": "sourcebucket", + "ownerIdentity": { + "principalId": "EXAMPLE" + }, + "arn": "arn:aws:s3:::mybucket" + }, + "object": { + "key": "Happy%20Face.jpg", + "urlDecodedKey": "Happy Face.jpg", + "size": 1024, + "versionId": "version", + "eTag": "d41d8cd98f00b204e9800998ecf8427e", + "sequencer": "Happy Sequencer" + } + } + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventDeleteObject.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventDeleteObject.json new file mode 100644 index 0000000000000000000000000000000000000000..3a607242f00ee6ec015d305def55a47cfb34630b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventDeleteObject.json @@ -0,0 +1,36 @@ +{ + "Records": [ + { + "eventVersion": "2.1", + "eventSource": "aws:s3", + "awsRegion": "us-east-2", + "eventTime": "2019-09-03T19:37:27.192Z", + "eventName": "ObjectRemoved:Delete", + "userIdentity": { + "principalId": "AWS:AIDAINPONIXQXHT3IKHL2" + }, + "requestParameters": { + "sourceIPAddress": "205.255.255.255" + }, + "responseElements": { + "x-amz-request-id": "D82B88E5F771F645", + "x-amz-id-2": "vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo=" + }, + "s3": { + "s3SchemaVersion": "1.0", + "configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1", + "bucket": { + "name": "lambda-artifacts-deafc19498e3f2df", + "ownerIdentity": { + "principalId": "A3I5XTEXAMAI3E" + }, + "arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df" + }, + "object": { + "key": "b21b84d653bb07b05b1e6b33684dc11b", + "sequencer": "0C0F6F405D6ED209E1" + } + } + } + ] +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventGlacier.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventGlacier.json new file mode 100644 index 0000000000000000000000000000000000000000..2fbc447b308d05d8feddb4f5e7753eda0e6c42ca --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3EventGlacier.json @@ -0,0 +1,44 @@ +{ + "Records": [ + { + "eventVersion": "2.1", + "eventSource": "aws:s3", + "awsRegion": "us-east-2", + "eventTime": "2019-09-03T19:37:27.192Z", + "eventName": "ObjectCreated:Put", + "userIdentity": { + "principalId": "AWS:AIDAINPONIXQXHT3IKHL2" + }, + "requestParameters": { + "sourceIPAddress": "205.255.255.255" + }, + "responseElements": { + "x-amz-request-id": "D82B88E5F771F645", + "x-amz-id-2": "vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo=" + }, + "s3": { + "s3SchemaVersion": "1.0", + "configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1", + "bucket": { + "name": "lambda-artifacts-deafc19498e3f2df", + "ownerIdentity": { + "principalId": "A3I5XTEXAMAI3E" + }, + "arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df" + }, + "object": { + "key": "b21b84d653bb07b05b1e6b33684dc11b", + "size": 1305107, + "eTag": "b21b84d653bb07b05b1e6b33684dc11b", + "sequencer": "0C0F6F405D6ED209E1" + } + }, + "glacierEventData": { + "restoreEventData": { + "lifecycleRestorationExpiryTime": "1970-01-01T00:01:00.000Z", + "lifecycleRestoreStorageClass": "standard" + } + } + } + ] +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3ObjectEventIAMUser.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3ObjectEventIAMUser.json new file mode 100644 index 0000000000000000000000000000000000000000..6be41c4352bfaf7451142e3f9bece6bc456d2e38 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3ObjectEventIAMUser.json @@ -0,0 +1,30 @@ +{ + "xAmzRequestId": "1a5ed718-5f53-471d-b6fe-5cf62d88d02a", + "getObjectContext": { + "inputS3Url": "https://myap-123412341234.s3-accesspoint.us-east-1.amazonaws.com/s3.txt?X-Amz-Security-Token=...", + "outputRoute": "io-iad-cell001", + "outputToken": "..." + }, + "configuration": { + "accessPointArn": "arn:aws:s3-object-lambda:us-east-1:123412341234:accesspoint/myolap", + "supportingAccessPointArn": "arn:aws:s3:us-east-1:123412341234:accesspoint/myap", + "payload": "test" + }, + "userRequest": { + "url": "/s3.txt", + "headers": { + "Host": "myolap-123412341234.s3-object-lambda.us-east-1.amazonaws.com", + "Accept-Encoding": "identity", + "X-Amz-Content-SHA256": "e3b0c44297fc1c149afbf4c8995fb92427ae41e4649b934ca495991b7852b855" + } + }, + "userIdentity": { + "type": "IAMUser", + "principalId": "...", + "arn": "arn:aws:iam::123412341234:user/myuser", + "accountId": "123412341234", + "accessKeyId": "...", + "userName": "Alice" + }, + "protocolVersion": "1.00" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3ObjectEventTempCredentials.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3ObjectEventTempCredentials.json new file mode 100644 index 0000000000000000000000000000000000000000..30c70fe6df9a9a22d6643f57b9199540d299aafd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3ObjectEventTempCredentials.json @@ -0,0 +1,42 @@ +{ + "xAmzRequestId": "requestId", + "getObjectContext": { + "inputS3Url": "https://my-s3-ap-111122223333.s3-accesspoint.us-east-1.amazonaws.com/example?X-Amz-Security-Token=", + "outputRoute": "io-use1-001", + "outputToken": "OutputToken" + }, + "configuration": { + "accessPointArn": "arn:aws:s3-object-lambda:us-east-1:111122223333:accesspoint/example-object-lambda-ap", + "supportingAccessPointArn": "arn:aws:s3:us-east-1:111122223333:accesspoint/example-ap", + "payload": "{}" + }, + "userRequest": { + "url": "https://object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com/example", + "headers": { + "Host": "object-lambda-111122223333.s3-object-lambda.us-east-1.amazonaws.com", + "Accept-Encoding": "identity", + "X-Amz-Content-SHA256": "e3b0c44298fc1example" + } + }, + "userIdentity": { + "type": "AssumedRole", + "principalId": "principalId", + "arn": "arn:aws:sts::111122223333:assumed-role/Admin/example", + "accountId": "111122223333", + "accessKeyId": "accessKeyId", + "sessionContext": { + "attributes": { + "mfaAuthenticated": "false", + "creationDate": "Wed Mar 10 23:41:52 UTC 2021" + }, + "sessionIssuer": { + "type": "Role", + "principalId": "principalId", + "arn": "arn:aws:iam::111122223333:role/Admin", + "accountId": "111122223333", + "userName": "Admin" + } + } + }, + "protocolVersion": "1.00" +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/s3SqsEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3SqsEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..55863af12b08c2adf9e67ad381248436e9a93f51 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/s3SqsEvent.json @@ -0,0 +1,22 @@ +{ + "Records":[ + { + "messageId":"ca3e7a89-c358-40e5-8aa0-5da01403c267", + "receiptHandle":"AQEBE7XoI7IQRLF7SrpiW9W4BanmOWe8UtVDbv6/CEZYKf/OktSNIb4j689tQfR4k44V/LY20lZ5VpxYt2GTYCsSLKTcBalTJaRX9CKu/hVqy/23sSNiKxnP56D+VLSn+hU275+AP1h4pUL0d9gLdRB2haX8xiM+LcGfis5Jl8BBXtoxKRF60O87O9/NvCmmXLeqkJuexfyEZNyed0fFCRXFXSjbmThG0OIQgcrGI8glBRGPA8htns58VtXFsSaPYNoqP3p5n6+ewKKVLD0lfm+0DlnLKRa+mjvFBaSer9KK1ff+Aq6zJ6HynPwADj+aF70Hwimc2zImYe51SLEF/E2csYlMNZYI/2qXW0m9R7wJ/XDTV4g2+h+BMTxsKnJQ6NQd", + "body":"{\"Records\":[{\"eventVersion\":\"2.1\",\"eventSource\":\"aws:s3\",\"awsRegion\":\"us-east-1\",\"eventTime\":\"2023-04-12T20:43:38.021Z\",\"eventName\":\"ObjectCreated:Put\",\"userIdentity\":{\"principalId\":\"A1YQ72UWCM96UF\"},\"requestParameters\":{\"sourceIPAddress\":\"93.108.161.96\"},\"responseElements\":{\"x-amz-request-id\":\"YMSSR8BZJ2Y99K6P\",\"x-amz-id-2\":\"6ASrUfj5xpn859fIq+6FXflOex/SKl/rjfiMd7wRzMg/zkHKR22PDpnh7KD3uq//cuOTbdX4DInN5eIs+cR0dY1z2Mc5NDP/\"},\"s3\":{\"s3SchemaVersion\":\"1.0\",\"configurationId\":\"SNS\",\"bucket\":{\"name\":\"xxx\",\"ownerIdentity\":{\"principalId\":\"A1YQ72UWCM96UF\"},\"arn\":\"arn:aws:s3:::xxx\"},\"object\":{\"key\":\"test.pdf\",\"size\":104681,\"eTag\":\"2e3ad1e983318bbd8e73b080e2997980\",\"versionId\":\"yd3d4HaWOT2zguDLvIQLU6ptDTwKBnQV\",\"sequencer\":\"00643717F9F8B85354\"}}}]}", + "attributes":{ + "ApproximateReceiveCount":"1", + "SentTimestamp":"1681332219270", + "SenderId":"AIDAJHIPRHEMV73VRJEBU", + "ApproximateFirstReceiveTimestamp":"1681332239270" + }, + "messageAttributes":{ + + }, + "md5OfBody":"16f4460f4477d8d693a5abe94fdbbd73", + "eventSource":"aws:sqs", + "eventSourceARN":"arn:aws:sqs:us-east-1:123456789012:SQS", + "awsRegion":"us-east-1" + } + ] + } diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/secretsManagerEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/secretsManagerEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..f07ea1e0b0329bd4c4ec0500c832f7c15b1d2dcd --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/secretsManagerEvent.json @@ -0,0 +1,5 @@ +{ + "SecretId":"arn:aws:secretsmanager:us-west-2:123456789012:secret:MyTestDatabaseSecret-a1b2c3", + "ClientRequestToken":"550e8400-e29b-41d4-a716-446655440000", + "Step":"createSecret" +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/sesEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/sesEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..636ecad687f7c05dc2dd4b23318b4618b865735d --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/sesEvent.json @@ -0,0 +1,101 @@ +{ + "Records": [ + { + "eventVersion": "1.0", + "ses": { + "mail": { + "commonHeaders": { + "from": [ + "Jane Doe " + ], + "to": [ + "johndoe@example.com" + ], + "returnPath": "janedoe@example.com", + "messageId": "<0123456789example.com>", + "date": "Wed, 7 Oct 2015 12:34:56 -0700", + "subject": "Test Subject" + }, + "source": "janedoe@example.com", + "timestamp": "1970-01-01T00:00:00.000Z", + "destination": [ + "johndoe@example.com" + ], + "headers": [ + { + "name": "Return-Path", + "value": "" + }, + { + "name": "Received", + "value": "from mailer.example.com (mailer.example.com [203.0.113.1]) by ..." + }, + { + "name": "DKIM-Signature", + "value": "v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; s=example; ..." + }, + { + "name": "MIME-Version", + "value": "1.0" + }, + { + "name": "From", + "value": "Jane Doe " + }, + { + "name": "Date", + "value": "Wed, 7 Oct 2015 12:34:56 -0700" + }, + { + "name": "Message-ID", + "value": "<0123456789example.com>" + }, + { + "name": "Subject", + "value": "Test Subject" + }, + { + "name": "To", + "value": "johndoe@example.com" + }, + { + "name": "Content-Type", + "value": "text/plain; charset=UTF-8" + } + ], + "headersTruncated": false, + "messageId": "o3vrnil0e2ic28tr" + }, + "receipt": { + "recipients": [ + "johndoe@example.com" + ], + "timestamp": "1970-01-01T00:00:00.000Z", + "spamVerdict": { + "status": "PASS" + }, + "dkimVerdict": { + "status": "PASS" + }, + "dmarcPolicy": "reject", + "processingTimeMillis": 574, + "action": { + "type": "Lambda", + "invocationType": "Event", + "functionArn": "arn:aws:lambda:us-west-2:012345678912:function:Example" + }, + "dmarcVerdict": { + "status": "PASS" + }, + "spfVerdict": { + "status": "PASS" + }, + "virusVerdict": { + "status": "PASS" + } + } + }, + "eventSource": "aws:ses" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/snsEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/snsEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..3d8a8ed443c6255f0bc25594af51b67ce3935397 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/snsEvent.json @@ -0,0 +1,31 @@ +{ + "Records": [ + { + "EventVersion": "1.0", + "EventSubscriptionArn": "arn:aws:sns:us-east-2:123456789012:sns-la ...", + "EventSource": "aws:sns", + "Sns": { + "SignatureVersion": "1", + "Timestamp": "2019-01-02T12:45:07.000Z", + "Signature": "tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==", + "SigningCertUrl": "https://sns.us-east-2.amazonaws.com/SimpleNotification", + "MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e", + "Message": "Hello from SNS!", + "MessageAttributes": { + "Test": { + "Type": "String", + "Value": "TestString" + }, + "TestBinary": { + "Type": "Binary", + "Value": "TestBinary" + } + }, + "Type": "Notification", + "UnsubscribeUrl": "https://sns.us-east-2.amazonaws.com/?Action=Unsubscribe", + "TopicArn": "arn:aws:sns:us-east-2:123456789012:sns-lambda", + "Subject": "TestInvoke" + } + } + ] +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/snsSqsEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/snsSqsEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..ee440fc29620ed25e6bbc1413e205b567a08a735 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/snsSqsEvent.json @@ -0,0 +1,20 @@ +{ + "Records": [ + { + "messageId": "79406a00-bf15-46ca-978c-22c3613fcb30", + "receiptHandle": "AQEB3fkqlBqq239bMCAHIr5mZkxJYKtxsTTy1lMImmpY7zqpQdfcAE8zFiuRh7X5ciROy24taT2rRXfuJFN/yEUVcQ6d5CIOCEK4htmRJJOHIyGdZPAm2NUUG5nNn2aEzgfzVvrkPBsrCbr7XTzK5s6eUZNH/Nn9AJtHKHpzweRK34Bon9OU/mvyIT7EJbwHPsdhL14NrCp8pLWBiIhkaJkG2G6gPO89dwHtGVUARJL+zP70AuIu/f7QgmPtY2eeE4AVbcUT1qaIlSGHUXxoHq/VMHLd/c4zWl0EXQOo/90DbyCUMejTIKL7N15YfkHoQDHprvMiAr9S75cdMiNOduiHzZLg/qVcv4kxsksKLFMKjwlzmYuQYy2KslVGwoHMd4PD", + "body": "{\n \"Type\" : \"Notification\",\n \"MessageId\" : \"d88d4479-6ec0-54fe-b63f-1cf9df4bb16e\",\n \"TopicArn\" : \"arn:aws:sns:eu-west-1:231436140809:powertools265\",\n \"Message\" : \"{\\\"message\\\": \\\"hello world\\\", \\\"username\\\": \\\"lessa\\\"}\",\n \"Timestamp\" : \"2021-01-19T10:07:07.287Z\",\n \"SignatureVersion\" : \"1\",\n \"Signature\" : \"tEo2i6Lw6/Dr7Jdlulh0sXgnkF0idd3hqs8QZCorQpzkIWVOuu583NT0Gv0epuZD1Bo+tex6NgP5p6415yNVujGHJKnkrA9ztzXaVgFiol8rf8AFGQbmb7RsM9BqATQUJeg9nCTe0jksmWXmjxEFr8XKyyRuQBwSlRTngAvOw8jUnCe1vyYD5xPec1xpfOEGLi5BqSog+6tBtsry3oAtcENX8SV1tVuMpp6D+UrrU8xNT/5D70uRDppkPE3vq+t7rR0fVSdQRdUV9KmQD2bflA1Dyb2y37EzwJOMHDDQ82aOhj/JmPxvEAlV8RkZl6J0HIveraRy9wbNLbI7jpiOCw==\",\n \"SigningCertURL\" : \"https://sns.eu-west-1.amazonaws.com/SimpleNotificationService-010a507c1833636cd94bdb98bd93083a.pem\",\n \"UnsubscribeURL\" : \"https://sns.eu-west-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:eu-west-1:231436140809:powertools265:15189ad7-870e-40e5-a7dd-a48898cd9f86\"\n}", + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1611050827340", + "SenderId": "AIDAISMY7JYY5F7RTT6AO", + "ApproximateFirstReceiveTimestamp": "1611050827344" + }, + "messageAttributes": {}, + "md5OfBody": "8910bdaaf9a30a607f7891037d4af0b0", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:eu-west-1:231436140809:powertools265", + "awsRegion": "eu-west-1" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/snsSqsFifoEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/snsSqsFifoEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..6c23ef629454781cf705726698583d7685be9557 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/snsSqsFifoEvent.json @@ -0,0 +1,23 @@ +{ + "Records": [ + { + "messageId": "69bc4bbd-ed69-4325-a434-85c3b428ceab", + "receiptHandle": "AQEBbfAqjhrgIdW3HGWYPz57mdDatG/dT9LZhRPAsNQ1pJmw495w4esDc8ZSbOwMZuPBol7wtiNWug8U25GpSQDDLY1qv//8/lfmdzXOiprG6xRVeiXSHj0j731rJQ3xo+GPdGjOzjIxI09CrE3HtZ4lpXY9NjjHzP8hdxkCLlbttumc8hDBUR365/Tk+GfV2nNP9qvZtLGEbKCdTm/GYdTSoAr+ML9HnnGrS9T25Md71ASiZMI4DZqptN6g7CYYojFPs1LVM9o1258ferA72zbNoQ==", + "body": "{\n \"Type\" : \"Notification\",\n \"MessageId\" : \"a7c9d2fa-77fa-5184-9de9-89391027cc7d\",\n \"SequenceNumber\" : \"10000000000000004000\",\n \"TopicArn\" : \"arn:aws:sns:eu-west-1:231436140809:Test.fifo\",\n \"Message\" : \"{\\\"message\\\": \\\"hello world\\\", \\\"username\\\": \\\"lessa\\\"}\",\n \"Timestamp\" : \"2022-10-14T13:35:25.419Z\",\n \"UnsubscribeURL\" : \"https://sns.eu-west-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:eu-west-1:231436140809:Test.fifo:bb81d3de-a0f9-46e4-b619-d3152a4d545f\"\n}", + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1665754525442", + "SequenceNumber": "18873177232222703872", + "MessageGroupId": "powertools-test", + "SenderId": "AIDAWYJAWPFU7SUQGUJC6", + "MessageDeduplicationId": "4e0a0f61eed277a4b9e4c01d5722b07b0725e42fe782102abee5711adfac701f", + "ApproximateFirstReceiveTimestamp": "1665754525442" + }, + "messageAttributes": {}, + "md5OfBody": "f3c788e623445e3feb263e80c1bffc0b", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:eu-west-1:231436140809:Test.fifo", + "awsRegion": "eu-west-1" + } + ] +} \ No newline at end of file diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/sqsDlqTriggerEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/sqsDlqTriggerEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..c47ee95aeef8e5a06a45377eca5a8f03b45c4e40 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/sqsDlqTriggerEvent.json @@ -0,0 +1,21 @@ +{ + "Records": [ + { + "messageId": "db37cc61-1bb0-4e77-b6f3-7cf87f44a72a", + "receiptHandle": "AQEBl1pqxv+ZHkarVAWZUyWgj2mmqJGLBTo6YFOi/bw1QpBTpJBGJPLOTZrjKztKIbAB8EXkG7zHlbkn+Ze/AHMKKuhST9azHu8LyF4Ffu9uPkZc5xzggXlfFBWH3TUKyV+F5Obaj3esyX8YfM/zfgjbRuu5nc2tfPhvaSYEaTZsdMpzIB5tyKvHxAltLxK7upRHeoT768M9UrFYswarFTBn8piDbnsPsUhi8Q9G4Q4xSI0fLQANmryBsRJIzGQTVxenDad+MJ7XEL+hD3p2DmW+ycvv6WD7bdedqQuroQG8+ca1Dz7s3CBbXw9ZZnUziPa7LH1j1Lky5bAxpNF+BlurRS9pFBnomhwpylrGxtGfaEmUW1G7jnrG97sZNOLOFUykbQgroZPXmjzMBdvtgq9ZmQfCch3LOXN267+PKc56VR4=", + "body": "hello world", + "attributes": { + "DeadLetterQueueSourceArn": "arn:aws:sqs:eu-central-1:123456789012:sqs-redrive-SampleQueue-RNvLCpwGmLi7", + "ApproximateReceiveCount": "2", + "SentTimestamp": "1713185156609", + "SenderId": "AMCXIENQZJOLO23YVJ4VO", + "ApproximateFirstReceiveTimestamp": "1713185156612" + }, + "messageAttributes": {}, + "md5OfBody": "6a204bd89f3c8348afd5c77c717a097a", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:eu-central-1:123456789012:sqs-redrive-SampleDLQ-Emgp9MFSLBZm", + "awsRegion": "eu-central-1" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/sqsEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/sqsEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..2bfcd1c7b8fcae28616f18852f49c1955c736198 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/sqsEvent.json @@ -0,0 +1,42 @@ +{ + "Records": [ + { + "messageId": "059f36b4-87a3-44ab-83d2-661975830a7d", + "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...", + "body": "Test message.", + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1545082649183", + "SenderId": "AIDAIENQZJOLO23YVJ4VO", + "ApproximateFirstReceiveTimestamp": "1545082649185" + }, + "messageAttributes": { + "testAttr": { + "stringValue": "100", + "binaryValue": "base64Str", + "dataType": "Number" + } + }, + "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue", + "awsRegion": "us-east-2" + }, + { + "messageId": "2e1424d4-f796-459a-8184-9c92662be6da", + "receiptHandle": "AQEBzWwaftRI0KuVm4tP+/7q1rGgNqicHq...", + "body": "{\"message\": \"foo1\"}", + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1545082650636", + "SenderId": "AIDAIENQZJOLO23YVJ4VO", + "ApproximateFirstReceiveTimestamp": "1545082650649" + }, + "messageAttributes": {}, + "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue", + "awsRegion": "us-east-2" + } + ] +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEvent.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEvent.json new file mode 100644 index 0000000000000000000000000000000000000000..fa9031f7dc49f3d349d1778a9e9fd8192eccdbe4 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEvent.json @@ -0,0 +1,17 @@ +{ + "raw_path": "/testpath", + "method": "GET", + "headers": { + "user_agent": "curl/7.64.1", + "x-forwarded-for": "10.213.229.10", + "host": "test-lambda-service-3908sdf9u3u.dkfjd93.vpc-lattice-svcs.us-east-2.on.aws", + "accept": "*/*", + "header1": "value1", + "header2": "value1,value2" + }, + "query_string_parameters": { + "order-id": "1" + }, + "body": "eyJ0ZXN0IjogImV2ZW50In0=", + "is_base64_encoded": true +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEventPathTrailingSlash.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEventPathTrailingSlash.json new file mode 100644 index 0000000000000000000000000000000000000000..7f6c0cfd9af97ceff93db7c1fb139932cee05996 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEventPathTrailingSlash.json @@ -0,0 +1,15 @@ +{ + "raw_path": "/testpath/", + "method": "GET", + "headers": { + "user_agent": "curl/7.64.1", + "x-forwarded-for": "10.213.229.10", + "host": "test-lambda-service-3908sdf9u3u.dkfjd93.vpc-lattice-svcs.us-east-2.on.aws", + "accept": "*/*" + }, + "query_string_parameters": { + "order-id": "1" + }, + "body": "eyJ0ZXN0IjogImV2ZW50In0=", + "is_base64_encoded": true +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEventV2PathTrailingSlash.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEventV2PathTrailingSlash.json new file mode 100644 index 0000000000000000000000000000000000000000..5f5fa7edd72a9067f31187fe302ca22e86766a28 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeEventV2PathTrailingSlash.json @@ -0,0 +1,30 @@ +{ + "version": "2.0", + "path": "/newpath/", + "method": "GET", + "headers": { + "user_agent": "curl/7.64.1", + "x-forwarded-for": "10.213.229.10", + "host": "test-lambda-service-3908sdf9u3u.dkfjd93.vpc-lattice-svcs.us-east-2.on.aws", + "accept": "*/*" + }, + "query_string_parameters": { + "order-id": "1" + }, + "body": "{\"message\": \"Hello from Lambda!\"}", + "isBase64Encoded": false, + "requestContext": { + "serviceNetworkArn": "arn:aws:vpc-lattice:us-east-2:123456789012:servicenetwork/sn-0bf3f2882e9cc805a", + "serviceArn": "arn:aws:vpc-lattice:us-east-2:123456789012:service/svc-0a40eebed65f8d69c", + "targetGroupArn": "arn:aws:vpc-lattice:us-east-2:123456789012:targetgroup/tg-6d0ecf831eec9f09", + "identity": { + "sourceVpcArn": "arn:aws:ec2:region:123456789012:vpc/vpc-0b8276c84697e7339", + "type" : "AWS_IAM", + "principal": "arn:aws:sts::123456789012:assumed-role/example-role/057d00f8b51257ba3c853a0f248943cf", + "sessionName": "057d00f8b51257ba3c853a0f248943cf", + "x509SanDns": "example.com" + }, + "region": "us-east-2", + "timeEpoch": "1696331543569073" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeV2Event.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeV2Event.json new file mode 100644 index 0000000000000000000000000000000000000000..fe10d83a3af8d594cdea03a9b97b1e4689732d0b --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeV2Event.json @@ -0,0 +1,30 @@ +{ + "version": "2.0", + "path": "/newpath", + "method": "GET", + "headers": { + "user_agent": "curl/7.64.1", + "x-forwarded-for": "10.213.229.10", + "host": "test-lambda-service-3908sdf9u3u.dkfjd93.vpc-lattice-svcs.us-east-2.on.aws", + "accept": "*/*" + }, + "queryStringParameters": { + "order-id": "1" + }, + "body": "{\"message\": \"Hello from Lambda!\"}", + "isBase64Encoded": false, + "requestContext": { + "serviceNetworkArn": "arn:aws:vpc-lattice:us-east-2:123456789012:servicenetwork/sn-0bf3f2882e9cc805a", + "serviceArn": "arn:aws:vpc-lattice:us-east-2:123456789012:service/svc-0a40eebed65f8d69c", + "targetGroupArn": "arn:aws:vpc-lattice:us-east-2:123456789012:targetgroup/tg-6d0ecf831eec9f09", + "identity": { + "sourceVpcArn": "arn:aws:ec2:region:123456789012:vpc/vpc-0b8276c84697e7339", + "type" : "AWS_IAM", + "principal": "arn:aws:sts::123456789012:assumed-role/example-role/057d00f8b51257ba3c853a0f248943cf", + "sessionName": "057d00f8b51257ba3c853a0f248943cf", + "x509SanDns": "example.com" + }, + "region": "us-east-2", + "timeEpoch": "1696331543569073" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeV2EventWithHeaders.json b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeV2EventWithHeaders.json new file mode 100644 index 0000000000000000000000000000000000000000..fdaf7dc789195f1b70dc04d5c11d0516fde0ebe1 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/events/vpcLatticeV2EventWithHeaders.json @@ -0,0 +1,55 @@ +{ + "version": "2.0", + "path": "/newpath", + "method": "GET", + "headers":{ + "user-agent":[ + "curl/8.3.0" + ], + "accept":[ + "*/*" + ], + "powertools":[ + "a", + "b" + ], + "x-forwarded-for":[ + "172.31.40.143" + ], + "host":[ + "lattice-svc-027b423199122da5f.7d67968.vpc-lattice-svcs.us-east-1.on.aws" + ], + "Header1": [ + "value1" + ], + "Header2": [ + "value1", + "value2" + ] + }, + "queryStringParameters": { + "parameter1": [ + "value1", + "value2" + ], + "parameter2": [ + "value" + ] + }, + "body": "{\"message\": \"Hello from Lambda!\"}", + "isBase64Encoded": false, + "requestContext": { + "serviceNetworkArn": "arn:aws:vpc-lattice:us-east-2:123456789012:servicenetwork/sn-0bf3f2882e9cc805a", + "serviceArn": "arn:aws:vpc-lattice:us-east-2:123456789012:service/svc-0a40eebed65f8d69c", + "targetGroupArn": "arn:aws:vpc-lattice:us-east-2:123456789012:targetgroup/tg-6d0ecf831eec9f09", + "identity": { + "sourceVpcArn": "arn:aws:ec2:region:123456789012:vpc/vpc-0b8276c84697e7339", + "type" : "AWS_IAM", + "principal": "arn:aws:sts::123456789012:assumed-role/example-role/057d00f8b51257ba3c853a0f248943cf", + "sessionName": "057d00f8b51257ba3c853a0f248943cf", + "x509SanDns": "example.com" + }, + "region": "us-east-2", + "timeEpoch": "1696331543569073" + } +} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/_pydantic/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/_pydantic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/_pydantic/sample_models.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/_pydantic/sample_models.py new file mode 100644 index 0000000000000000000000000000000000000000..c2912b3f8a38266e54b27a03e749e31893a51909 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/_pydantic/sample_models.py @@ -0,0 +1,52 @@ +import json +from typing import Dict, Optional + +from pydantic import field_validator + +from aws_lambda_powertools.utilities.parser import BaseModel +from aws_lambda_powertools.utilities.parser.models import ( + DynamoDBStreamChangedRecordModel, + DynamoDBStreamRecordModel, + KinesisDataStreamRecord, + KinesisDataStreamRecordPayload, + SqsRecordModel, +) +from aws_lambda_powertools.utilities.parser.types import Json, Literal + + +class Order(BaseModel): + item: dict + + +class OrderSqs(SqsRecordModel): + body: Json[Order] + + +class OrderKinesisPayloadRecord(KinesisDataStreamRecordPayload): + data: Json[Order] + + +class OrderKinesisRecord(KinesisDataStreamRecord): + kinesis: OrderKinesisPayloadRecord + + +class OrderDynamoDB(BaseModel): + Message: Order + + # auto transform json string + # so Pydantic can auto-initialize nested Order model + @field_validator("Message", mode="before") + def transform_message_to_dict(cls, value: Dict[Literal["S"], str]): + try: + return json.loads(value) + except TypeError: + raise ValueError + + +class OrderDynamoDBChangeRecord(DynamoDBStreamChangedRecordModel): + NewImage: Optional[OrderDynamoDB] = None + OldImage: Optional[OrderDynamoDB] = None + + +class OrderDynamoDBRecord(DynamoDBStreamRecordModel): + dynamodb: OrderDynamoDBChangeRecord diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/_pydantic/test_utilities_batch_pydantic.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/_pydantic/test_utilities_batch_pydantic.py new file mode 100644 index 0000000000000000000000000000000000000000..382cbdb0335b8bb5d5727867ae7d868197d9a460 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/_pydantic/test_utilities_batch_pydantic.py @@ -0,0 +1,641 @@ +import json +import uuid +from random import randint +from typing import Any, Awaitable, Callable, Dict, Optional + +import pytest +from pydantic import BaseModel, field_validator + +from aws_lambda_powertools.utilities.batch import ( + AsyncBatchProcessor, + BatchProcessor, + EventType, + SqsFifoPartialProcessor, + batch_processor, +) +from aws_lambda_powertools.utilities.data_classes.dynamo_db_stream_event import ( + DynamoDBRecord, +) +from aws_lambda_powertools.utilities.data_classes.kinesis_stream_event import ( + KinesisStreamRecord, +) +from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord +from aws_lambda_powertools.utilities.parser.models import ( + DynamoDBStreamChangedRecordModel, + DynamoDBStreamRecordModel, + SqsRecordModel, +) +from aws_lambda_powertools.utilities.parser.types import Literal +from tests.functional.batch._pydantic.sample_models import ( + OrderDynamoDBRecord, + OrderKinesisRecord, + OrderSqs, +) +from tests.functional.utils import b64_to_str, str_to_b64 + + +@pytest.fixture(scope="module") +def sqs_event_fifo_factory() -> Callable: + def factory(body: str, message_group_id: str = ""): + return { + "messageId": f"{uuid.uuid4()}", + "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a", + "body": body, + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1703675223472", + "SequenceNumber": "18882884930918384133", + "MessageGroupId": message_group_id, + "SenderId": "SenderId", + "MessageDeduplicationId": "1eea03c3f7e782c7bdc2f2a917f40389314733ff39f5ab16219580c0109ade98", + "ApproximateFirstReceiveTimestamp": "1703675223484", + }, + "messageAttributes": {}, + "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue", + "awsRegion": "us-east-1", + } + + return factory + + +@pytest.fixture(scope="module") +def sqs_event_factory() -> Callable: + def factory(body: str): + return { + "messageId": f"{uuid.uuid4()}", + "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a", + "body": body, + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1545082649183", + "SenderId": "SenderId", + "ApproximateFirstReceiveTimestamp": "1545082649185", + }, + "messageAttributes": {}, + "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue", + "awsRegion": "us-east-1", + } + + return factory + + +@pytest.fixture(scope="module") +def kinesis_event_factory() -> Callable: + def factory(body: str): + seq = "".join(str(randint(0, 9)) for _ in range(52)) + return { + "kinesis": { + "kinesisSchemaVersion": "1.0", + "partitionKey": "1", + "sequenceNumber": seq, + "data": str_to_b64(body), + "approximateArrivalTimestamp": 1545084650.987, + }, + "eventSource": "aws:kinesis", + "eventVersion": "1.0", + "eventID": f"shardId-000000000006:{seq}", + "eventName": "aws:kinesis:record", + "invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role", + "awsRegion": "us-east-2", + "eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream", + } + + return factory + + +@pytest.fixture(scope="module") +def dynamodb_event_factory() -> Callable: + def factory(body: str): + seq = "".join(str(randint(0, 9)) for _ in range(10)) + return { + "eventID": "1", + "eventVersion": "1.0", + "dynamodb": { + "Keys": {"Id": {"N": "101"}}, + "NewImage": {"Message": {"S": body}}, + "StreamViewType": "NEW_AND_OLD_IMAGES", + "SequenceNumber": seq, + "SizeBytes": 26, + }, + "awsRegion": "us-west-2", + "eventName": "INSERT", + "eventSourceARN": "eventsource_arn", + "eventSource": "aws:dynamodb", + } + + return factory + + +@pytest.fixture(scope="module") +def record_handler() -> Callable: + def handler(record): + body = record["body"] + if "fail" in body: + raise Exception("Failed to process record.") + return body + + return handler + + +@pytest.fixture(scope="module") +def record_handler_model() -> Callable: + def record_handler(record: OrderSqs): + if "fail" in record.body.item["type"]: + raise Exception("Failed to process record.") + return record.body.item + + return record_handler + + +@pytest.fixture(scope="module") +def async_record_handler() -> Callable[..., Awaitable[Any]]: + async def handler(record): + body = record["body"] + if "fail" in body: + raise Exception("Failed to process record.") + return body + + return handler + + +@pytest.fixture(scope="module") +def async_record_handler_model() -> Callable[..., Awaitable[Any]]: + async def async_record_handler(record: OrderSqs): + if "fail" in record.body.item["type"]: + raise ValueError("Failed to process record.") + return record.body.item + + return async_record_handler + + +@pytest.fixture(scope="module") +def kinesis_record_handler() -> Callable: + def handler(record: KinesisStreamRecord): + body = b64_to_str(record.kinesis.data) + if "fail" in body: + raise Exception("Failed to process record.") + return body + + return handler + + +@pytest.fixture(scope="module") +def kinesis_record_handler_model() -> Callable: + def record_handler(record: OrderKinesisRecord): + if "fail" in record.kinesis.data.item["type"]: + raise ValueError("Failed to process record.") + return record.kinesis.data.item + + return record_handler + + +@pytest.fixture(scope="module") +def async_kinesis_record_handler_model() -> Callable[..., Awaitable[Any]]: + async def record_handler(record: OrderKinesisRecord): + if "fail" in record.kinesis.data.item["type"]: + raise Exception("Failed to process record.") + return record.kinesis.data.item + + return record_handler + + +@pytest.fixture(scope="module") +def dynamodb_record_handler() -> Callable: + def handler(record: DynamoDBRecord): + body = record.dynamodb.new_image.get("Message") + if "fail" in body: + raise ValueError("Failed to process record.") + return body + + return handler + + +@pytest.fixture(scope="module") +def dynamodb_record_handler_model() -> Callable: + def record_handler(record: OrderDynamoDBRecord): + if "fail" in record.dynamodb.NewImage.Message.item["type"]: + raise ValueError("Failed to process record.") + return record.dynamodb.NewImage.Message.item + + return record_handler + + +@pytest.fixture(scope="module") +def async_dynamodb_record_handler() -> Callable[..., Awaitable[Any]]: + async def record_handler(record: OrderDynamoDBRecord): + if "fail" in record.dynamodb.NewImage.Message.item["type"]: + raise ValueError("Failed to process record.") + return record.dynamodb.NewImage.Message.item + + return record_handler + + +@pytest.fixture(scope="module") +def order_event_factory() -> Callable: + def factory(item: Dict) -> str: + return json.dumps({"item": item}) + + return factory + + +def test_batch_processor_context_model(sqs_event_factory, order_event_factory): + # GIVEN + def record_handler(record: OrderSqs): + return record.body.item + + order_event = order_event_factory({"type": "success"}) + first_record = sqs_event_factory(order_event) + second_record = sqs_event_factory(order_event) + records = [first_record, second_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.SQS, model=OrderSqs) + with processor(records, record_handler) as batch: + processed_messages = batch.process() + + # THEN + order_item = json.loads(order_event)["item"] + assert processed_messages == [ + ("success", order_item, first_record), + ("success", order_item, second_record), + ] + + assert batch.response() == {"batchItemFailures": []} + + +def test_batch_processor_context_model_with_failure(sqs_event_factory, order_event_factory): + # GIVEN + def record_handler(record: OrderSqs): + if "fail" in record.body.item["type"]: + raise Exception("Failed to process record.") + return record.body.item + + order_event = order_event_factory({"type": "success"}) + order_event_fail = order_event_factory({"type": "fail"}) + first_record = sqs_event_factory(order_event_fail) + third_record = sqs_event_factory(order_event_fail) + second_record = sqs_event_factory(order_event) + records = [first_record, second_record, third_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.SQS, model=OrderSqs) + with processor(records, record_handler) as batch: + batch.process() + + # THEN + assert len(batch.fail_messages) == 2 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": first_record["messageId"]}, + {"itemIdentifier": third_record["messageId"]}, + ], + } + + +def test_batch_processor_dynamodb_context_model(dynamodb_event_factory, order_event_factory): + # GIVEN + class Order(BaseModel): + item: dict + + class OrderDynamoDB(BaseModel): + Message: Order + + # auto transform json string + # so Pydantic can auto-initialize nested Order model + @field_validator("Message", mode="before") + def transform_message_to_dict(cls, value: Dict[Literal["S"], str]): + return json.loads(value) + + class OrderDynamoDBChangeRecord(DynamoDBStreamChangedRecordModel): + NewImage: Optional[OrderDynamoDB] = None + OldImage: Optional[OrderDynamoDB] = None + + class OrderDynamoDBRecord(DynamoDBStreamRecordModel): + dynamodb: OrderDynamoDBChangeRecord + + def record_handler(record: OrderDynamoDBRecord): + return record.dynamodb.NewImage.Message.item + + order_event = order_event_factory({"type": "success"}) + first_record = dynamodb_event_factory(order_event) + second_record = dynamodb_event_factory(order_event) + records = [first_record, second_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.DynamoDBStreams, model=OrderDynamoDBRecord) + with processor(records, record_handler) as batch: + processed_messages = batch.process() + + # THEN + order_item = json.loads(order_event)["item"] + assert processed_messages == [ + ("success", order_item, first_record), + ("success", order_item, second_record), + ] + + assert batch.response() == {"batchItemFailures": []} + + +def test_batch_processor_dynamodb_context_model_with_failure(dynamodb_event_factory, order_event_factory): + # GIVEN + class Order(BaseModel): + item: dict + + class OrderDynamoDB(BaseModel): + Message: Order + + # auto transform json string + # so Pydantic can auto-initialize nested Order model + @field_validator("Message", mode="before") + def transform_message_to_dict(cls, value: Dict[Literal["S"], str]): + return json.loads(value) + + class OrderDynamoDBChangeRecord(DynamoDBStreamChangedRecordModel): + NewImage: Optional[OrderDynamoDB] = None + OldImage: Optional[OrderDynamoDB] = None + + class OrderDynamoDBRecord(DynamoDBStreamRecordModel): + dynamodb: OrderDynamoDBChangeRecord + + def record_handler(record: OrderDynamoDBRecord): + if "fail" in record.dynamodb.NewImage.Message.item["type"]: + raise Exception("Failed to process record.") + return record.dynamodb.NewImage.Message.item + + order_event = order_event_factory({"type": "success"}) + order_event_fail = order_event_factory({"type": "fail"}) + first_record = dynamodb_event_factory(order_event_fail) + second_record = dynamodb_event_factory(order_event) + third_record = dynamodb_event_factory(order_event_fail) + records = [first_record, second_record, third_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.DynamoDBStreams, model=OrderDynamoDBRecord) + with processor(records, record_handler) as batch: + batch.process() + + # THEN + assert len(batch.fail_messages) == 2 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": first_record["dynamodb"]["SequenceNumber"]}, + {"itemIdentifier": third_record["dynamodb"]["SequenceNumber"]}, + ], + } + + +def test_batch_processor_kinesis_context_parser_model( + kinesis_record_handler_model: Callable, + kinesis_event_factory, + order_event_factory, +): + # GIVEN + order_event = order_event_factory({"type": "success"}) + first_record = kinesis_event_factory(order_event) + second_record = kinesis_event_factory(order_event) + records = [first_record, second_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.KinesisDataStreams, model=OrderKinesisRecord) + with processor(records, kinesis_record_handler_model) as batch: + processed_messages = batch.process() + + # THEN + order_item = json.loads(order_event)["item"] + assert processed_messages == [ + ("success", order_item, first_record), + ("success", order_item, second_record), + ] + + assert batch.response() == {"batchItemFailures": []} + + +def test_batch_processor_kinesis_context_parser_model_with_failure( + kinesis_record_handler_model: Callable, + kinesis_event_factory, + order_event_factory, +): + # GIVEN + order_event = order_event_factory({"type": "success"}) + order_event_fail = order_event_factory({"type": "fail"}) + + first_record = kinesis_event_factory(order_event_fail) + second_record = kinesis_event_factory(order_event) + third_record = kinesis_event_factory(order_event_fail) + records = [first_record, second_record, third_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.KinesisDataStreams, model=OrderKinesisRecord) + with processor(records, kinesis_record_handler_model) as batch: + batch.process() + + # THEN + assert len(batch.fail_messages) == 2 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": first_record["kinesis"]["sequenceNumber"]}, + {"itemIdentifier": third_record["kinesis"]["sequenceNumber"]}, + ], + } + + +def test_sqs_fifo_batch_processor_middleware_with_skip_group_on_error_and_model(sqs_event_fifo_factory, record_handler): + # GIVEN a batch of 5 records with 3 different MessageGroupID + first_record = SQSRecord(sqs_event_fifo_factory("success", "1")) + second_record = SQSRecord(sqs_event_fifo_factory("success", "1")) + third_record = SQSRecord(sqs_event_fifo_factory("fail", "2")) + fourth_record = SQSRecord(sqs_event_fifo_factory("success", "2")) + fifth_record = SQSRecord(sqs_event_fifo_factory("fail", "3")) + event = { + "Records": [ + first_record.raw_event, + second_record.raw_event, + third_record.raw_event, + fourth_record.raw_event, + fifth_record.raw_event, + ], + } + + class OrderSqsRecord(SqsRecordModel): + receiptHandle: str + + # WHEN the FIFO processor is set to continue processing even after encountering errors in specific MessageGroupID + # WHEN processor is using a Pydantic Model we must be able to access MessageGroupID property + processor = SqsFifoPartialProcessor(skip_group_on_error=True, model=OrderSqsRecord) + + def record_handler(record: OrderSqsRecord): + if record.body == "fail": + raise ValueError("blah") + + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + result = lambda_handler(event, {}) + + # THEN only failed messages should originate from MessageGroupID 3 + assert len(result["batchItemFailures"]) == 3 + assert result["batchItemFailures"][0]["itemIdentifier"] == third_record.message_id + assert result["batchItemFailures"][1]["itemIdentifier"] == fourth_record.message_id + assert result["batchItemFailures"][2]["itemIdentifier"] == fifth_record.message_id + + +def test_batch_processor_model_with_partial_validation_error( + record_handler_model: Callable, + sqs_event_factory, + order_event_factory, +): + # GIVEN + order_event = order_event_factory({"type": "success"}) + first_record = sqs_event_factory(order_event) + second_record = sqs_event_factory(order_event) + malformed_record = sqs_event_factory({"poison": "pill"}) + records = [first_record, malformed_record, second_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.SQS, model=OrderSqs) + with processor(records, record_handler_model) as batch: + batch.process() + + # THEN + assert len(batch.fail_messages) == 1 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": malformed_record["messageId"]}, + ], + } + + +def test_batch_processor_dynamodb_context_model_with_partial_validation_error( + dynamodb_record_handler_model: Callable, + dynamodb_event_factory, + order_event_factory, +): + # GIVEN + order_event = order_event_factory({"type": "success"}) + first_record = dynamodb_event_factory(order_event) + second_record = dynamodb_event_factory(order_event) + malformed_record = dynamodb_event_factory({"poison": "pill"}) + records = [first_record, malformed_record, second_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.DynamoDBStreams, model=OrderDynamoDBRecord) + with processor(records, dynamodb_record_handler_model) as batch: + batch.process() + + # THEN + assert len(batch.fail_messages) == 1 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": malformed_record["dynamodb"]["SequenceNumber"]}, + ], + } + + +def test_batch_processor_kinesis_context_parser_model_with_partial_validation_error( + kinesis_record_handler_model: Callable, + kinesis_event_factory, + order_event_factory, +): + # GIVEN + order_event = order_event_factory({"type": "success"}) + first_record = kinesis_event_factory(order_event) + second_record = kinesis_event_factory(order_event) + malformed_record = kinesis_event_factory('{"poison": "pill"}') + records = [first_record, malformed_record, second_record] + + # WHEN + processor = BatchProcessor(event_type=EventType.KinesisDataStreams, model=OrderKinesisRecord) + with processor(records, kinesis_record_handler_model) as batch: + batch.process() + + # THEN + assert len(batch.fail_messages) == 1 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": malformed_record["kinesis"]["sequenceNumber"]}, + ], + } + + +def test_async_batch_processor_model_with_partial_validation_error( + async_record_handler_model: Callable, + sqs_event_factory, + order_event_factory, +): + # GIVEN + order_event = order_event_factory({"type": "success"}) + first_record = sqs_event_factory(order_event) + second_record = sqs_event_factory(order_event) + malformed_record = sqs_event_factory({"poison": "pill"}) + records = [first_record, malformed_record, second_record] + + # WHEN + processor = AsyncBatchProcessor(event_type=EventType.SQS, model=OrderSqs) + with processor(records, async_record_handler_model) as batch: + batch.async_process() + + # THEN + assert len(batch.fail_messages) == 1 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": malformed_record["messageId"]}, + ], + } + + +def test_async_batch_processor_dynamodb_context_model_with_partial_validation_error( + async_dynamodb_record_handler: Callable, + dynamodb_event_factory, + order_event_factory, +): + # GIVEN + order_event = order_event_factory({"type": "success"}) + first_record = dynamodb_event_factory(order_event) + second_record = dynamodb_event_factory(order_event) + malformed_record = dynamodb_event_factory({"poison": "pill"}) + records = [first_record, malformed_record, second_record] + + # WHEN + processor = AsyncBatchProcessor(event_type=EventType.DynamoDBStreams, model=OrderDynamoDBRecord) + with processor(records, async_dynamodb_record_handler) as batch: + batch.async_process() + + # THEN + assert len(batch.fail_messages) == 1 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": malformed_record["dynamodb"]["SequenceNumber"]}, + ], + } + + +def test_async_batch_processor_kinesis_context_parser_model_with_partial_validation_error( + async_kinesis_record_handler_model: Callable, + kinesis_event_factory, + order_event_factory, +): + # GIVEN + order_event = order_event_factory({"type": "success"}) + first_record = kinesis_event_factory(order_event) + second_record = kinesis_event_factory(order_event) + malformed_record = kinesis_event_factory('{"poison": "pill"}') + records = [first_record, malformed_record, second_record] + + # WHEN + processor = AsyncBatchProcessor(event_type=EventType.KinesisDataStreams, model=OrderKinesisRecord) + with processor(records, async_kinesis_record_handler_model) as batch: + batch.async_process() + + # THEN + assert len(batch.fail_messages) == 1 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": malformed_record["kinesis"]["sequenceNumber"]}, + ], + } diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/required_dependencies/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/required_dependencies/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/required_dependencies/test_utilities_batch.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/required_dependencies/test_utilities_batch.py new file mode 100644 index 0000000000000000000000000000000000000000..9327a7d70fcb7f73c35fc259c70d7f4c25e24e60 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/batch/required_dependencies/test_utilities_batch.py @@ -0,0 +1,710 @@ +import json +import uuid +from random import randint +from typing import Any, Awaitable, Callable, Dict + +import pytest + +from aws_lambda_powertools.utilities.batch import ( + AsyncBatchProcessor, + BatchProcessor, + EventType, + SqsFifoPartialProcessor, + async_batch_processor, + async_process_partial_response, + batch_processor, + process_partial_response, +) +from aws_lambda_powertools.utilities.batch.exceptions import BatchProcessingError +from aws_lambda_powertools.utilities.data_classes.dynamo_db_stream_event import ( + DynamoDBRecord, +) +from aws_lambda_powertools.utilities.data_classes.kinesis_stream_event import ( + KinesisStreamRecord, +) +from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord +from aws_lambda_powertools.warnings import PowertoolsDeprecationWarning +from tests.functional.utils import b64_to_str, str_to_b64 + + +@pytest.fixture(scope="module") +def sqs_event_fifo_factory() -> Callable: + def factory(body: str, message_group_id: str = ""): + return { + "messageId": f"{uuid.uuid4()}", + "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a", + "body": body, + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1703675223472", + "SequenceNumber": "18882884930918384133", + "MessageGroupId": message_group_id, + "SenderId": "SenderId", + "MessageDeduplicationId": "1eea03c3f7e782c7bdc2f2a917f40389314733ff39f5ab16219580c0109ade98", + "ApproximateFirstReceiveTimestamp": "1703675223484", + }, + "messageAttributes": {}, + "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue", + "awsRegion": "us-east-1", + } + + return factory + + +@pytest.fixture(scope="module") +def sqs_event_factory() -> Callable: + def factory(body: str): + return { + "messageId": f"{uuid.uuid4()}", + "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a", + "body": body, + "attributes": { + "ApproximateReceiveCount": "1", + "SentTimestamp": "1545082649183", + "SenderId": "SenderId", + "ApproximateFirstReceiveTimestamp": "1545082649185", + }, + "messageAttributes": {}, + "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3", + "eventSource": "aws:sqs", + "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue", + "awsRegion": "us-east-1", + } + + return factory + + +@pytest.fixture(scope="module") +def kinesis_event_factory() -> Callable: + def factory(body: str): + seq = "".join(str(randint(0, 9)) for _ in range(52)) + return { + "kinesis": { + "kinesisSchemaVersion": "1.0", + "partitionKey": "1", + "sequenceNumber": seq, + "data": str_to_b64(body), + "approximateArrivalTimestamp": 1545084650.987, + }, + "eventSource": "aws:kinesis", + "eventVersion": "1.0", + "eventID": f"shardId-000000000006:{seq}", + "eventName": "aws:kinesis:record", + "invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role", + "awsRegion": "us-east-2", + "eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream", + } + + return factory + + +@pytest.fixture(scope="module") +def dynamodb_event_factory() -> Callable: + def factory(body: str): + seq = "".join(str(randint(0, 9)) for _ in range(10)) + return { + "eventID": "1", + "eventVersion": "1.0", + "dynamodb": { + "Keys": {"Id": {"N": "101"}}, + "NewImage": {"Message": {"S": body}}, + "StreamViewType": "NEW_AND_OLD_IMAGES", + "SequenceNumber": seq, + "SizeBytes": 26, + }, + "awsRegion": "us-west-2", + "eventName": "INSERT", + "eventSourceARN": "eventsource_arn", + "eventSource": "aws:dynamodb", + } + + return factory + + +@pytest.fixture(scope="module") +def record_handler() -> Callable: + def handler(record): + body = record["body"] + if "fail" in body: + raise Exception("Failed to process record.") + return body + + return handler + + +@pytest.fixture(scope="module") +def async_record_handler() -> Callable[..., Awaitable[Any]]: + async def handler(record): + body = record["body"] + if "fail" in body: + raise Exception("Failed to process record.") + return body + + return handler + + +@pytest.fixture(scope="module") +def kinesis_record_handler() -> Callable: + def handler(record: KinesisStreamRecord): + body = b64_to_str(record.kinesis.data) + if "fail" in body: + raise Exception("Failed to process record.") + return body + + return handler + + +@pytest.fixture(scope="module") +def dynamodb_record_handler() -> Callable: + def handler(record: DynamoDBRecord): + body = record.dynamodb.new_image.get("Message") + if "fail" in body: + raise ValueError("Failed to process record.") + return body + + return handler + + +@pytest.fixture(scope="module") +def order_event_factory() -> Callable: + def factory(item: Dict) -> str: + return json.dumps({"item": item}) + + return factory + + +def test_batch_processor_middleware_success_only(sqs_event_factory, record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("success")) + second_record = SQSRecord(sqs_event_factory("success")) + event = {"Records": [first_record.raw_event, second_record.raw_event]} + + processor = BatchProcessor(event_type=EventType.SQS) + + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + result = lambda_handler(event, {}) + + # THEN + assert result["batchItemFailures"] == [] + + +def test_batch_processor_middleware_with_failure(sqs_event_factory, record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("fail")) + second_record = SQSRecord(sqs_event_factory("success")) + third_record = SQSRecord(sqs_event_factory("fail")) + event = {"Records": [first_record.raw_event, second_record.raw_event, third_record.raw_event]} + + processor = BatchProcessor(event_type=EventType.SQS) + + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + result = lambda_handler(event, {}) + + # THEN + assert len(result["batchItemFailures"]) == 2 + + +def test_batch_processor_context_success_only(sqs_event_factory, record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("success")) + second_record = SQSRecord(sqs_event_factory("success")) + records = [first_record.raw_event, second_record.raw_event] + processor = BatchProcessor(event_type=EventType.SQS) + + # WHEN + with processor(records, record_handler) as batch: + processed_messages = batch.process() + + # THEN + assert processed_messages == [ + ("success", first_record.body, first_record.raw_event), + ("success", second_record.body, second_record.raw_event), + ] + + assert batch.response() == {"batchItemFailures": []} + + +def test_batch_processor_context_with_failure(sqs_event_factory, record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("failure")) + second_record = SQSRecord(sqs_event_factory("success")) + third_record = SQSRecord(sqs_event_factory("fail")) + records = [first_record.raw_event, second_record.raw_event, third_record.raw_event] + processor = BatchProcessor(event_type=EventType.SQS) + + # WHEN + with processor(records, record_handler) as batch: + processed_messages = batch.process() + + # THEN + assert processed_messages[1] == ("success", second_record.body, second_record.raw_event) + assert len(batch.fail_messages) == 2 + assert batch.response() == { + "batchItemFailures": [{"itemIdentifier": first_record.message_id}, {"itemIdentifier": third_record.message_id}], + } + + +def test_batch_processor_kinesis_context_success_only(kinesis_event_factory, kinesis_record_handler): + # GIVEN + first_record = KinesisStreamRecord(kinesis_event_factory("success")) + second_record = KinesisStreamRecord(kinesis_event_factory("success")) + + records = [first_record.raw_event, second_record.raw_event] + processor = BatchProcessor(event_type=EventType.KinesisDataStreams) + + # WHEN + with processor(records, kinesis_record_handler) as batch: + processed_messages = batch.process() + + # THEN + assert processed_messages == [ + ("success", b64_to_str(first_record.kinesis.data), first_record.raw_event), + ("success", b64_to_str(second_record.kinesis.data), second_record.raw_event), + ] + + assert batch.response() == {"batchItemFailures": []} + + +def test_batch_processor_kinesis_context_with_failure(kinesis_event_factory, kinesis_record_handler): + # GIVEN + first_record = KinesisStreamRecord(kinesis_event_factory("failure")) + second_record = KinesisStreamRecord(kinesis_event_factory("success")) + third_record = KinesisStreamRecord(kinesis_event_factory("failure")) + + records = [first_record.raw_event, second_record.raw_event, third_record.raw_event] + processor = BatchProcessor(event_type=EventType.KinesisDataStreams) + + # WHEN + with processor(records, kinesis_record_handler) as batch: + processed_messages = batch.process() + + # THEN + assert processed_messages[1] == ("success", b64_to_str(second_record.kinesis.data), second_record.raw_event) + assert len(batch.fail_messages) == 2 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": first_record.kinesis.sequence_number}, + {"itemIdentifier": third_record.kinesis.sequence_number}, + ], + } + + +def test_batch_processor_kinesis_middleware_with_failure(kinesis_event_factory, kinesis_record_handler): + # GIVEN + first_record = KinesisStreamRecord(kinesis_event_factory("failure")) + second_record = KinesisStreamRecord(kinesis_event_factory("success")) + third_record = KinesisStreamRecord(kinesis_event_factory("failure")) + event = {"Records": [first_record.raw_event, second_record.raw_event, third_record.raw_event]} + + processor = BatchProcessor(event_type=EventType.KinesisDataStreams) + + @batch_processor(record_handler=kinesis_record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + result = lambda_handler(event, {}) + + # THEN + assert len(result["batchItemFailures"]) == 2 + + +def test_batch_processor_dynamodb_context_success_only(dynamodb_event_factory, dynamodb_record_handler): + # GIVEN + first_record = dynamodb_event_factory("success") + second_record = dynamodb_event_factory("success") + records = [first_record, second_record] + processor = BatchProcessor(event_type=EventType.DynamoDBStreams) + + # WHEN + with processor(records, dynamodb_record_handler) as batch: + processed_messages = batch.process() + + # THEN + assert processed_messages == [ + ("success", first_record["dynamodb"]["NewImage"]["Message"]["S"], first_record), + ("success", second_record["dynamodb"]["NewImage"]["Message"]["S"], second_record), + ] + + assert batch.response() == {"batchItemFailures": []} + + +def test_batch_processor_dynamodb_context_with_failure(dynamodb_event_factory, dynamodb_record_handler): + # GIVEN + first_record = dynamodb_event_factory("failure") + second_record = dynamodb_event_factory("success") + third_record = dynamodb_event_factory("failure") + records = [first_record, second_record, third_record] + processor = BatchProcessor(event_type=EventType.DynamoDBStreams) + + # WHEN + with processor(records, dynamodb_record_handler) as batch: + processed_messages = batch.process() + + # THEN + assert processed_messages[1] == ("success", second_record["dynamodb"]["NewImage"]["Message"]["S"], second_record) + assert len(batch.fail_messages) == 2 + assert batch.response() == { + "batchItemFailures": [ + {"itemIdentifier": first_record["dynamodb"]["SequenceNumber"]}, + {"itemIdentifier": third_record["dynamodb"]["SequenceNumber"]}, + ], + } + + +def test_batch_processor_dynamodb_middleware_with_failure(dynamodb_event_factory, dynamodb_record_handler): + # GIVEN + first_record = dynamodb_event_factory("failure") + second_record = dynamodb_event_factory("success") + third_record = dynamodb_event_factory("failure") + event = {"Records": [first_record, second_record, third_record]} + + processor = BatchProcessor(event_type=EventType.DynamoDBStreams) + + @batch_processor(record_handler=dynamodb_record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + result = lambda_handler(event, {}) + + # THEN + assert len(result["batchItemFailures"]) == 2 + + +def test_batch_processor_error_when_entire_batch_fails(sqs_event_factory, record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("fail")) + second_record = SQSRecord(sqs_event_factory("fail")) + event = {"Records": [first_record.raw_event, second_record.raw_event]} + + processor = BatchProcessor(event_type=EventType.SQS) + + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN calling `lambda_handler` in cold start + with pytest.raises(BatchProcessingError) as e: + lambda_handler(event, {}) + + # THEN raise BatchProcessingError + assert "All records failed processing. " in str(e.value) + + # WHEN calling `lambda_handler` in warm start + with pytest.raises(BatchProcessingError) as e: + lambda_handler(event, {}) + + # THEN raise BatchProcessingError + assert "All records failed processing. " in str(e.value) + + +def test_batch_processor_not_raise_when_entire_batch_fails_sync(sqs_event_factory, record_handler): + first_record = SQSRecord(sqs_event_factory("fail")) + second_record = SQSRecord(sqs_event_factory("fail")) + event = {"Records": [first_record.raw_event, second_record.raw_event]} + + # GIVEN the BatchProcessor constructor with raise_on_entire_batch_failure False + processor = BatchProcessor(event_type=EventType.SQS, raise_on_entire_batch_failure=False) + + # WHEN processing the messages + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + response = lambda_handler(event, {}) + + # THEN assert the `itemIdentifier` of each failure matches the message ID of the corresponding record + assert len(response["batchItemFailures"]) == 2 + assert response["batchItemFailures"][0]["itemIdentifier"] == first_record.message_id + assert response["batchItemFailures"][1]["itemIdentifier"] == second_record.message_id + + +def test_batch_processor_not_raise_when_entire_batch_fails_async(sqs_event_factory, record_handler): + first_record = SQSRecord(sqs_event_factory("fail")) + second_record = SQSRecord(sqs_event_factory("fail")) + event = {"Records": [first_record.raw_event, second_record.raw_event]} + + # GIVEN the BatchProcessor constructor with raise_on_entire_batch_failure False + processor = AsyncBatchProcessor(event_type=EventType.SQS, raise_on_entire_batch_failure=False) + + # WHEN processing the messages + @async_batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + response = lambda_handler(event, {}) + + # THEN assert the `itemIdentifier` of each failure matches the message ID of the corresponding record + assert len(response["batchItemFailures"]) == 2 + assert response["batchItemFailures"][0]["itemIdentifier"] == first_record.message_id + assert response["batchItemFailures"][1]["itemIdentifier"] == second_record.message_id + + +def test_sqs_fifo_batch_processor_middleware_success_only(sqs_event_fifo_factory, record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_fifo_factory("success")) + second_record = SQSRecord(sqs_event_fifo_factory("success")) + event = {"Records": [first_record.raw_event, second_record.raw_event]} + + processor = SqsFifoPartialProcessor() + + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + result = lambda_handler(event, {}) + + # THEN + assert result["batchItemFailures"] == [] + + +def test_sqs_fifo_batch_processor_middleware_with_failure(sqs_event_fifo_factory, record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_fifo_factory("success")) + second_record = SQSRecord(sqs_event_fifo_factory("fail")) + # this would normally succeed, but since it's a FIFO queue, it will be marked as failure + third_record = SQSRecord(sqs_event_fifo_factory("success")) + event = {"Records": [first_record.raw_event, second_record.raw_event, third_record.raw_event]} + + processor = SqsFifoPartialProcessor() + + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + result = lambda_handler(event, {}) + + # THEN + assert len(result["batchItemFailures"]) == 2 + assert result["batchItemFailures"][0]["itemIdentifier"] == second_record.message_id + assert result["batchItemFailures"][1]["itemIdentifier"] == third_record.message_id + + +def test_sqs_fifo_batch_processor_middleware_with_skip_group_on_error(sqs_event_fifo_factory, record_handler): + # GIVEN a batch of 5 records with 3 different MessageGroupID + first_record = SQSRecord(sqs_event_fifo_factory("success", "1")) + second_record = SQSRecord(sqs_event_fifo_factory("success", "1")) + third_record = SQSRecord(sqs_event_fifo_factory("fail", "2")) + fourth_record = SQSRecord(sqs_event_fifo_factory("success", "2")) + fifth_record = SQSRecord(sqs_event_fifo_factory("fail", "3")) + event = { + "Records": [ + first_record.raw_event, + second_record.raw_event, + third_record.raw_event, + fourth_record.raw_event, + fifth_record.raw_event, + ], + } + + # WHEN the FIFO processor is set to continue processing even after encountering errors in specific MessageGroupID + processor = SqsFifoPartialProcessor(skip_group_on_error=True) + + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + result = lambda_handler(event, {}) + + # THEN only failed messages should originate from MessageGroupID 3 + assert len(result["batchItemFailures"]) == 3 + assert result["batchItemFailures"][0]["itemIdentifier"] == third_record.message_id + assert result["batchItemFailures"][1]["itemIdentifier"] == fourth_record.message_id + assert result["batchItemFailures"][2]["itemIdentifier"] == fifth_record.message_id + + +def test_sqs_fifo_batch_processor_middleware_with_skip_group_on_error_first_message_fail( + sqs_event_fifo_factory, + record_handler, +): + # GIVEN a batch of 5 records with 3 different MessageGroupID + first_record = SQSRecord(sqs_event_fifo_factory("fail", "1")) + second_record = SQSRecord(sqs_event_fifo_factory("success", "1")) + third_record = SQSRecord(sqs_event_fifo_factory("fail", "2")) + fourth_record = SQSRecord(sqs_event_fifo_factory("success", "2")) + fifth_record = SQSRecord(sqs_event_fifo_factory("success", "3")) + event = { + "Records": [ + first_record.raw_event, + second_record.raw_event, + third_record.raw_event, + fourth_record.raw_event, + fifth_record.raw_event, + ], + } + + # WHEN the FIFO processor is set to continue processing even after encountering errors in specific MessageGroupID + processor = SqsFifoPartialProcessor(skip_group_on_error=True) + + @batch_processor(record_handler=record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN the handler is onvoked + result = lambda_handler(event, {}) + + # THEN messages from group 1 and 2 should fail, but not group 3 + assert len(result["batchItemFailures"]) == 4 + assert result["batchItemFailures"][0]["itemIdentifier"] == first_record.message_id + assert result["batchItemFailures"][1]["itemIdentifier"] == second_record.message_id + assert result["batchItemFailures"][2]["itemIdentifier"] == third_record.message_id + assert result["batchItemFailures"][3]["itemIdentifier"] == fourth_record.message_id + + +def test_async_batch_processor_middleware_success_only(sqs_event_factory, async_record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("success")) + second_record = SQSRecord(sqs_event_factory("success")) + event = {"Records": [first_record.raw_event, second_record.raw_event]} + + processor = AsyncBatchProcessor(event_type=EventType.SQS) + + @async_batch_processor(record_handler=async_record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + with pytest.warns(PowertoolsDeprecationWarning, match="The `async_batch_processor` decorator is deprecated in V3*"): + result = lambda_handler(event, {}) + + # THEN + assert result["batchItemFailures"] == [] + + +def test_async_batch_processor_middleware_with_failure(sqs_event_factory, async_record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("fail")) + second_record = SQSRecord(sqs_event_factory("success")) + third_record = SQSRecord(sqs_event_factory("fail")) + event = {"Records": [first_record.raw_event, second_record.raw_event, third_record.raw_event]} + + processor = AsyncBatchProcessor(event_type=EventType.SQS) + + @async_batch_processor(record_handler=async_record_handler, processor=processor) + def lambda_handler(event, context): + return processor.response() + + # WHEN + with pytest.warns(PowertoolsDeprecationWarning, match="The `async_batch_processor` decorator is deprecated in V3*"): + result = lambda_handler(event, {}) + + # THEN + assert len(result["batchItemFailures"]) == 2 + + +def test_async_batch_processor_context_success_only(sqs_event_factory, async_record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("success")) + second_record = SQSRecord(sqs_event_factory("success")) + records = [first_record.raw_event, second_record.raw_event] + processor = AsyncBatchProcessor(event_type=EventType.SQS) + + # WHEN + with processor(records, async_record_handler) as batch: + processed_messages = batch.async_process() + + # THEN + assert processed_messages == [ + ("success", first_record.body, first_record.raw_event), + ("success", second_record.body, second_record.raw_event), + ] + + assert batch.response() == {"batchItemFailures": []} + + +def test_async_batch_processor_context_with_failure(sqs_event_factory, async_record_handler): + # GIVEN + first_record = SQSRecord(sqs_event_factory("failure")) + second_record = SQSRecord(sqs_event_factory("success")) + third_record = SQSRecord(sqs_event_factory("fail")) + records = [first_record.raw_event, second_record.raw_event, third_record.raw_event] + processor = AsyncBatchProcessor(event_type=EventType.SQS) + + # WHEN + with processor(records, async_record_handler) as batch: + processed_messages = batch.async_process() + + # THEN + assert processed_messages[1] == ("success", second_record.body, second_record.raw_event) + assert len(batch.fail_messages) == 2 + assert batch.response() == { + "batchItemFailures": [{"itemIdentifier": first_record.message_id}, {"itemIdentifier": third_record.message_id}], + } + + +def test_process_partial_response(sqs_event_factory, record_handler): + # GIVEN + records = [sqs_event_factory("success"), sqs_event_factory("success")] + batch = {"Records": records} + processor = BatchProcessor(event_type=EventType.SQS) + + # WHEN + ret = process_partial_response(batch, record_handler, processor) + + # THEN + assert ret == {"batchItemFailures": []} + + +@pytest.mark.parametrize( + "batch", + [ + pytest.param(123456789, id="num"), + pytest.param([], id="list"), + pytest.param(False, id="bool"), + pytest.param(object, id="object"), + pytest.param(lambda x: x, id="callable"), + ], +) +def test_process_partial_response_invalid_input(record_handler: Callable, batch: Any): + # GIVEN + processor = BatchProcessor(event_type=EventType.SQS) + + # WHEN/THEN + with pytest.raises(ValueError): + process_partial_response(batch, record_handler, processor) + + +def test_async_process_partial_response(sqs_event_factory, async_record_handler): + # GIVEN + records = [sqs_event_factory("success"), sqs_event_factory("success")] + batch = {"Records": records} + processor = AsyncBatchProcessor(event_type=EventType.SQS) + + # WHEN + ret = async_process_partial_response(batch, async_record_handler, processor) + + # THEN + assert ret == {"batchItemFailures": []} + + +@pytest.mark.parametrize( + "batch", + [ + pytest.param(123456789, id="num"), + pytest.param([], id="list"), + pytest.param(False, id="bool"), + pytest.param(object, id="object"), + pytest.param(lambda x: x, id="callable"), + ], +) +def test_async_process_partial_response_invalid_input(async_record_handler: Callable, batch: Any): + # GIVEN + processor = AsyncBatchProcessor(event_type=EventType.SQS) + + # WHEN/THEN + with pytest.raises(ValueError): + async_process_partial_response(batch, record_handler, processor) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/data_classes/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/data_classes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/data_masking/_aws_encryption_sdk/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/data_masking/_aws_encryption_sdk/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/__init__.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/conftest.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..6dd0b6d14a0306bc5286b16d7dd00c9fc62e2694 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/conftest.py @@ -0,0 +1,139 @@ +import json + +import fastjsonschema +import pytest + +from aws_lambda_powertools.event_handler.openapi.models import APIKey, APIKeyIn +from tests.functional.utils import load_event + + +@pytest.fixture +def json_dump(): + # our serializers reduce length to save on costs; fixture to replicate separators + return lambda obj: json.dumps(obj, separators=(",", ":")) + + +@pytest.fixture +def validation_schema(): + return { + "$schema": "https://json-schema.org/draft-07/schema", + "$id": "https://example.com/example.json", + "type": "object", + "title": "Sample schema", + "description": "The root schema comprises the entire JSON document.", + "examples": [{"message": "hello world", "username": "lessa"}], + "required": ["message", "username"], + "properties": { + "message": { + "$id": "#/properties/message", + "type": "string", + "title": "The message", + "examples": ["hello world"], + }, + "username": { + "$id": "#/properties/username", + "type": "string", + "title": "The username", + "examples": ["lessa"], + }, + }, + } + + +@pytest.fixture +def raw_event(): + return {"message": "hello hello", "username": "blah blah"} + + +@pytest.fixture +def gw_event(): + return load_event("apiGatewayProxyEvent.json") + + +@pytest.fixture +def gw_event_http(): + return load_event("apiGatewayProxyV2Event.json") + + +@pytest.fixture +def gw_event_alb(): + return load_event("albMultiValueQueryStringEvent.json") + + +@pytest.fixture +def gw_event_lambda_url(): + return load_event("lambdaFunctionUrlEventWithHeaders.json") + + +@pytest.fixture +def gw_event_vpc_lattice(): + return load_event("vpcLatticeV2EventWithHeaders.json") + + +@pytest.fixture +def gw_event_vpc_lattice_v1(): + return load_event("vpcLatticeEvent.json") + + +@pytest.fixture(scope="session") +def pydanticv1_only(): + from pydantic import __version__ + + version = __version__.split(".") + if version[0] != "1": + pytest.skip("pydanticv1 test only") + + +@pytest.fixture(scope="session") +def pydanticv2_only(): + from pydantic import __version__ + + version = __version__.split(".") + if version[0] != "2": + pytest.skip("pydanticv2 test only") + + +@pytest.fixture(scope="session") +def openapi30_schema(): + from urllib.request import urlopen + + f = urlopen("https://spec.openapis.org/oas/3.0/schema/2021-09-28") + data = json.loads(f.read().decode("utf-8")) + return fastjsonschema.compile( + data, + use_formats=False, + ) + + +@pytest.fixture(scope="session") +def openapi31_schema(): + from urllib.request import urlopen + + f = urlopen("https://spec.openapis.org/oas/3.1/schema/2022-10-07") + data = json.loads(f.read().decode("utf-8")) + return fastjsonschema.compile( + data, + use_formats=False, + ) + + +@pytest.fixture +def security_scheme(): + return {"apiKey": APIKey(name="X-API-KEY", description="API Key", in_=APIKeyIn.header)} + + +@pytest.fixture +def openapi_extension_integration_detail(): + return { + "type": "aws", + "httpMethod": "POST", + "uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/..integration/invocations", + "responses": {"default": {"statusCode": "200"}}, + "passthroughBehavior": "when_no_match", + "contentHandling": "CONVERT_TO_TEXT", + } + + +@pytest.fixture +def openapi_extension_validator_detail(): + return "Validate body, query string parameters, and headers" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_bedrock_agent.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_bedrock_agent.py new file mode 100644 index 0000000000000000000000000000000000000000..6dcc55c2da51b3687feafae5c5dc5d2ca0c93915 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_bedrock_agent.py @@ -0,0 +1,202 @@ +import json +from typing import Any, Dict, Optional + +import pytest +from typing_extensions import Annotated + +from aws_lambda_powertools.event_handler import BedrockAgentResolver, Response, content_types +from aws_lambda_powertools.event_handler.openapi.params import Body +from aws_lambda_powertools.utilities.data_classes import BedrockAgentEvent +from tests.functional.utils import load_event + +claims_response = "You have 3 claims" + + +def test_bedrock_agent_event(): + # GIVEN a Bedrock Agent event + app = BedrockAgentResolver() + + @app.get("/claims", description="Gets claims") + def claims() -> Dict[str, Any]: + assert isinstance(app.current_event, BedrockAgentEvent) + assert app.lambda_context == {} + return {"output": claims_response} + + # WHEN calling the event handler + result = app(load_event("bedrockAgentEvent.json"), {}) + + # THEN process event correctly + # AND set the current_event type as BedrockAgentEvent + assert result["messageVersion"] == "1.0" + assert result["response"]["apiPath"] == "/claims" + assert result["response"]["actionGroup"] == "ClaimManagementActionGroup" + assert result["response"]["httpMethod"] == "GET" + assert result["response"]["httpStatusCode"] == 200 + + body = result["response"]["responseBody"]["application/json"]["body"] + assert json.loads(body) == {"output": claims_response} + + +def test_bedrock_agent_with_path_params(): + # GIVEN a Bedrock Agent event + app = BedrockAgentResolver() + + @app.get("/claims/", description="Gets claims by ID") + def claims(claim_id: str): + assert isinstance(app.current_event, BedrockAgentEvent) + assert app.lambda_context == {} + assert claim_id == "123" + + # WHEN calling the event handler + result = app(load_event("bedrockAgentEventWithPathParams.json"), {}) + + # THEN process event correctly + # AND set the current_event type as BedrockAgentEvent + assert result["messageVersion"] == "1.0" + assert result["response"]["apiPath"] == "/claims/" + assert result["response"]["actionGroup"] == "ClaimManagementActionGroup" + assert result["response"]["httpMethod"] == "GET" + assert result["response"]["httpStatusCode"] == 200 + + +def test_bedrock_agent_event_with_response(): + # GIVEN a Bedrock Agent event + app = BedrockAgentResolver() + output = {"output": claims_response} + + @app.get("/claims", description="Gets claims") + def claims(): + assert isinstance(app.current_event, BedrockAgentEvent) + assert app.lambda_context == {} + return Response(200, content_types.APPLICATION_JSON, output) + + # WHEN calling the event handler + result = app(load_event("bedrockAgentEvent.json"), {}) + + # THEN process event correctly + # AND set the current_event type as BedrockAgentEvent + assert result["messageVersion"] == "1.0" + assert result["response"]["apiPath"] == "/claims" + assert result["response"]["actionGroup"] == "ClaimManagementActionGroup" + assert result["response"]["httpMethod"] == "GET" + assert result["response"]["httpStatusCode"] == 200 + + body = result["response"]["responseBody"]["application/json"]["body"] + assert json.loads(body) == output + + +def test_bedrock_agent_event_with_no_matches(): + # GIVEN a Bedrock Agent event + app = BedrockAgentResolver() + + @app.get("/no_match", description="Matches nothing") + def claims(): + raise RuntimeError() + + # WHEN calling the event handler + result = app(load_event("bedrockAgentEvent.json"), {}) + + # THEN process event correctly + # AND return 404 because the event doesn't match any known rule + assert result["messageVersion"] == "1.0" + assert result["response"]["apiPath"] == "/claims" + assert result["response"]["actionGroup"] == "ClaimManagementActionGroup" + assert result["response"]["httpMethod"] == "GET" + assert result["response"]["httpStatusCode"] == 404 + + +def test_bedrock_agent_event_with_validation_error(): + # GIVEN a Bedrock Agent event + app = BedrockAgentResolver() + + @app.get("/claims", description="Gets claims") + def claims() -> Dict[str, Any]: + return "oh no, this is not a dict" # type: ignore + + # WHEN calling the event handler + result = app(load_event("bedrockAgentEvent.json"), {}) + + # THEN process event correctly + # AND set the current_event type as BedrockAgentEvent + assert result["messageVersion"] == "1.0" + assert result["response"]["apiPath"] == "/claims" + assert result["response"]["actionGroup"] == "ClaimManagementActionGroup" + assert result["response"]["httpMethod"] == "GET" + assert result["response"]["httpStatusCode"] == 422 + + body = json.loads(result["response"]["responseBody"]["application/json"]["body"]) + assert body["detail"][0]["type"] == "dict_type" + + +def test_bedrock_agent_event_with_exception(): + # GIVEN a Bedrock Agent event + app = BedrockAgentResolver() + + @app.exception_handler(RuntimeError) + def handle_runtime_error(ex: RuntimeError): + return Response( + status_code=500, + content_type=content_types.TEXT_PLAIN, + body="Something went wrong", + ) + + @app.get("/claims", description="Gets claims") + def claims(): + raise RuntimeError() + + # WHEN calling the event handler + result = app(load_event("bedrockAgentEvent.json"), {}) + + # THEN process the exception correctly + # AND return 500 because of the internal server error + assert result["messageVersion"] == "1.0" + assert result["response"]["apiPath"] == "/claims" + assert result["response"]["actionGroup"] == "ClaimManagementActionGroup" + assert result["response"]["httpMethod"] == "GET" + assert result["response"]["httpStatusCode"] == 500 + + body = result["response"]["responseBody"]["text/plain"]["body"] + assert body == "Something went wrong" + + +def test_bedrock_agent_with_post(): + # GIVEN a Bedrock Agent resolver with a POST method + app = BedrockAgentResolver() + + @app.post("/send-reminders", description="Sends reminders") + def send_reminders( + _claim_id: Annotated[int, Body(description="Claim ID", alias="claimId")], + _pending_documents: Annotated[str, Body(description="Social number and VAT", alias="pendingDocuments")], + ) -> Annotated[bool, Body(description="returns true if I like the email")]: + return True + + # WHEN calling the event handler + result = app(load_event("bedrockAgentPostEvent.json"), {}) + + # THEN process the event correctly + assert result["messageVersion"] == "1.0" + assert result["response"]["apiPath"] == "/send-reminders" + assert result["response"]["httpMethod"] == "POST" + assert result["response"]["httpStatusCode"] == 200 + + # THEN return the correct result + body = result["response"]["responseBody"]["application/json"]["body"] + assert json.loads(body) is True + + +@pytest.mark.usefixtures("pydanticv2_only") +def test_openapi_schema_for_pydanticv2(openapi30_schema): + # GIVEN BedrockAgentResolver is initialized with enable_validation=True + app = BedrockAgentResolver(enable_validation=True) + + # WHEN we have a simple handler + @app.get("/", description="Testing") + def handler() -> Optional[Dict]: + pass + + # WHEN we get the schema + schema = json.loads(app.get_openapi_json_schema()) + + # THEN the schema must be a valid 3.0.3 version + assert openapi30_schema(schema) + assert schema.get("openapi") == "3.0.3" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_encoders.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_encoders.py new file mode 100644 index 0000000000000000000000000000000000000000..01a595fe810293a0ada22bfb52648dae74ed40f7 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_encoders.py @@ -0,0 +1,242 @@ +import math +from collections import deque +from dataclasses import dataclass + +import pytest +from pydantic import BaseModel + +from aws_lambda_powertools.event_handler.openapi.encoders import jsonable_encoder +from aws_lambda_powertools.event_handler.openapi.exceptions import SerializationError + + +def test_openapi_encode_include(): + class User(BaseModel): + name: str + age: int + + result = jsonable_encoder(User(name="John", age=20), include=["name"]) + assert result == {"name": "John"} + + +def test_openapi_encode_exclude(): + class User(BaseModel): + name: str + age: int + + result = jsonable_encoder(User(name="John", age=20), exclude=["age"]) + assert result == {"name": "John"} + + +def test_openapi_encode_pydantic(): + class Order(BaseModel): + quantity: int + + class User(BaseModel): + name: str + order: Order + + result = jsonable_encoder(User(name="John", order=Order(quantity=2))) + assert result == {"name": "John", "order": {"quantity": 2}} + + +def test_openapi_encode_dataclass(): + @dataclass + class Order: + quantity: int + + @dataclass + class User: + name: str + order: Order + + result = jsonable_encoder(User(name="John", order=Order(quantity=2))) + assert result == {"name": "John", "order": {"quantity": 2}} + + +def test_openapi_encode_enum(): + from enum import Enum + + class Color(Enum): + RED = "red" + GREEN = "green" + BLUE = "blue" + + result = jsonable_encoder(Color.RED) + assert result == "red" + + +def test_openapi_encode_purepath(): + from pathlib import PurePath + + result = jsonable_encoder(PurePath("/foo/bar")) + assert result == "/foo/bar" + + +def test_openapi_encode_scalars(): + result = jsonable_encoder("foo") + assert result == "foo" + + result = jsonable_encoder(1) + assert result == 1 + + result = jsonable_encoder(1.0) + assert math.isclose(result, 1.0) + + result = jsonable_encoder(True) + assert result is True + + result = jsonable_encoder(None) + assert result is None + + +def test_openapi_encode_dict(): + result = jsonable_encoder({"foo": "bar"}) + assert result == {"foo": "bar"} + + +def test_openapi_encode_dict_with_include(): + result = jsonable_encoder({"foo": "bar", "bar": "foo"}, include=["foo"]) + assert result == {"foo": "bar"} + + +def test_openapi_encode_dict_with_exclude(): + result = jsonable_encoder({"foo": "bar", "bar": "foo"}, exclude=["bar"]) + assert result == {"foo": "bar"} + + +def test_openapi_encode_sequences(): + result = jsonable_encoder(["foo", "bar"]) + assert result == ["foo", "bar"] + + result = jsonable_encoder(("foo", "bar")) + assert result == ["foo", "bar"] + + result = jsonable_encoder({"foo", "bar"}) + assert set(result) == {"foo", "bar"} + + result = jsonable_encoder(frozenset(("foo", "bar"))) + assert set(result) == {"foo", "bar"} + + +def test_openapi_encode_bytes(): + result = jsonable_encoder(b"foo") + assert result == "foo" + + +def test_openapi_encode_timedelta(): + from datetime import timedelta + + result = jsonable_encoder(timedelta(seconds=1)) + assert result == 1 + + +def test_openapi_encode_decimal(): + from decimal import Decimal + + result = jsonable_encoder(Decimal("1.0")) + assert math.isclose(result, 1.0) + + result = jsonable_encoder(Decimal("1")) + assert result == 1 + + +def test_openapi_encode_uuid(): + from uuid import UUID + + result = jsonable_encoder(UUID("123e4567-e89b-12d3-a456-426614174000")) + assert result == "123e4567-e89b-12d3-a456-426614174000" + + +def test_openapi_encode_encodable(): + from datetime import date, datetime, time + + result = jsonable_encoder(date(2021, 1, 1)) + assert result == "2021-01-01" + + result = jsonable_encoder(datetime(2021, 1, 1, 0, 0, 0)) + assert result == "2021-01-01T00:00:00" + + result = jsonable_encoder(time(0, 0, 0)) + assert result == "00:00:00" + + +def test_openapi_encode_subclasses(): + class MyCustomSubclass(deque): + pass + + result = jsonable_encoder(MyCustomSubclass(["red"])) + assert result == ["red"] + + +def test_openapi_encode_other(): + class User: + def __init__(self, name: str): + self.name = name + + result = jsonable_encoder(User(name="John")) + assert result == {"name": "John"} + + +def test_openapi_encode_with_error(): + class MyClass: + __slots__ = [] + + with pytest.raises(SerializationError, match="Unable to serialize the object*"): + jsonable_encoder(MyClass()) + + +def test_openapi_encode_custom_serializer_nested_dict(): + # GIVEN a nested dictionary with a custom class + class CustomClass: ... + + nested_dict = {"a": {"b": CustomClass()}} + + # AND a custom serializer + def serializer(value): + return "serialized" + + # WHEN we call jsonable_encoder with the nested dictionary and unserializable value + result = jsonable_encoder(nested_dict, custom_serializer=serializer) + + # THEN we should get the custom serializer output + assert result == {"a": {"b": "serialized"}} + + +def test_openapi_encode_custom_serializer_sequences(): + # GIVEN a sequence with a custom class + class CustomClass: + __slots__ = [] + + seq = [CustomClass()] + + # AND a custom serializer + def serializer(value): + return "serialized" + + # WHEN we call jsonable_encoder with the nested dictionary and unserializable value + result = jsonable_encoder(seq, custom_serializer=serializer) + + # THEN we should get the custom serializer output + assert result == ["serialized"] + + +def test_openapi_encode_custom_serializer_dataclasses(): + # GIVEN a sequence with a custom class + class CustomClass: + __slots__ = [] + + @dataclass + class Order: + kind: CustomClass + + order = Order(kind=CustomClass()) + + # AND a custom serializer + def serializer(value): + return "serialized" + + # WHEN we call jsonable_encoder with the nested dictionary and unserializable value + result = jsonable_encoder(order, custom_serializer=serializer) + + # THEN we should get the custom serializer output + assert result == {"kind": "serialized"} diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_extensions.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_extensions.py new file mode 100644 index 0000000000000000000000000000000000000000..2f0552ffc4cc17cdda76fb0526b466cec5a488f8 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_extensions.py @@ -0,0 +1,266 @@ +import json + +from aws_lambda_powertools.event_handler.api_gateway import APIGatewayRestResolver, Router +from aws_lambda_powertools.event_handler.openapi.models import ( + APIKey, + APIKeyIn, + OAuth2, + OAuthFlowImplicit, + OAuthFlows, + Server, +) + + +def test_openapi_extension_root_level(): + # GIVEN an APIGatewayRestResolver instance + app = APIGatewayRestResolver() + + cors_config = { + "maxAge": 0, + "allowCredentials": False, + } + + # WHEN we get the OpenAPI JSON schema with CORS extension in the Root Level + schema = json.loads( + app.get_openapi_json_schema( + openapi_extensions={"x-amazon-apigateway-cors": cors_config}, + ), + ) + + # THEN the OpenAPI schema must contain the "x-amazon-apigateway-cors" extension + assert "x-amazon-apigateway-cors" in schema + assert schema["x-amazon-apigateway-cors"] == cors_config + + +def test_openapi_extension_server_level(): + # GIVEN an APIGatewayRestResolver instance + app = APIGatewayRestResolver() + + endpoint_config = { + "disableExecuteApiEndpoint": True, + "vpcEndpointIds": ["vpce-0df8e77555fca0000"], + } + + server_config = { + "url": "https://example.org/", + "description": "Example website", + } + + # WHEN we get the OpenAPI JSON schema with a server-level openapi extension + schema = json.loads( + app.get_openapi_json_schema( + title="Hello API", + version="1.0.0", + servers=[ + Server( + **server_config, + openapi_extensions={ + "x-amazon-apigateway-endpoint-configuration": endpoint_config, + }, + ), + ], + ), + ) + + # THEN the OpenAPI schema must contain the "x-amazon-apigateway-endpoint-configuration" at the server level + assert "x-amazon-apigateway-endpoint-configuration" in schema["servers"][0] + assert schema["servers"][0]["x-amazon-apigateway-endpoint-configuration"] == endpoint_config + assert schema["servers"][0]["url"] == server_config["url"] + assert schema["servers"][0]["description"] == server_config["description"] + + +def test_openapi_extension_security_scheme_level_with_api_key(): + # GIVEN an APIGatewayRestResolver instance + app = APIGatewayRestResolver() + + authorizer_config = { + "authorizerUri": "arn:aws:apigateway:us-east-1:...:function:authorizer/invocations", + "authorizerResultTtlInSeconds": 300, + "type": "token", + } + + api_key_config = { + "name": "X-API-KEY", + "description": "API Key", + "in_": APIKeyIn.header, + } + + # WHEN we get the OpenAPI JSON schema with a security scheme-level extension for a custom auth + schema = json.loads( + app.get_openapi_json_schema( + security_schemes={ + "apiKey": APIKey( + **api_key_config, + openapi_extensions={ + "x-amazon-apigateway-authtype": "custom", + "x-amazon-apigateway-authorizer": authorizer_config, + }, + ), + }, + ), + ) + + # THEN the OpenAPI schema must contain the "x-amazon-apigateway-authtype" extension at the security scheme level + assert "x-amazon-apigateway-authtype" in schema["components"]["securitySchemes"]["apiKey"] + assert schema["components"]["securitySchemes"]["apiKey"]["x-amazon-apigateway-authtype"] == "custom" + assert schema["components"]["securitySchemes"]["apiKey"]["x-amazon-apigateway-authorizer"] == authorizer_config + assert schema["components"]["securitySchemes"]["apiKey"]["name"] == api_key_config["name"] + assert schema["components"]["securitySchemes"]["apiKey"]["description"] == api_key_config["description"] + assert schema["components"]["securitySchemes"]["apiKey"]["in"] == "header" + + +def test_openapi_extension_security_scheme_level_with_oauth2(): + # GIVEN an APIGatewayRestResolver instance + app = APIGatewayRestResolver() + + authorizer_config = { + "identitySource": "$request.header.Authorization", + "jwtConfiguration": { + "audience": ["test"], + "issuer": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx/", + }, + "type": "jwt", + } + + oauth2_config = { + "flows": OAuthFlows( + implicit=OAuthFlowImplicit( + authorizationUrl="https://example.com/oauth2/authorize", + ), + ), + } + + # WHEN we get the OpenAPI JSON schema with a security scheme-level extension for a custom auth + schema = json.loads( + app.get_openapi_json_schema( + security_schemes={ + "oauth2": OAuth2( + **oauth2_config, + openapi_extensions={ + "x-amazon-apigateway-authorizer": authorizer_config, + }, + ), + }, + ), + ) + + # THEN the OpenAPI schema must contain the "x-amazon-apigateway-authorizer" extension at the security scheme level + assert "x-amazon-apigateway-authorizer" in schema["components"]["securitySchemes"]["oauth2"] + assert schema["components"]["securitySchemes"]["oauth2"]["x-amazon-apigateway-authorizer"] == authorizer_config + assert ( + schema["components"]["securitySchemes"]["oauth2"]["x-amazon-apigateway-authorizer"]["identitySource"] + == "$request.header.Authorization" + ) + assert schema["components"]["securitySchemes"]["oauth2"]["x-amazon-apigateway-authorizer"]["jwtConfiguration"][ + "audience" + ] == ["test"] + assert ( + schema["components"]["securitySchemes"]["oauth2"]["x-amazon-apigateway-authorizer"]["jwtConfiguration"][ + "issuer" + ] + == "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx/" + ) + + +def test_openapi_extension_operation_level(openapi_extension_integration_detail): + # GIVEN an APIGatewayRestResolver instance + app = APIGatewayRestResolver() + + # WHEN we define an integration extension at operation level + # AND get the schema + @app.get("/test", openapi_extensions={"x-amazon-apigateway-integration": openapi_extension_integration_detail}) + def lambda_handler(): + pass + + schema = json.loads(app.get_openapi_json_schema()) + + # THEN the OpenAPI schema must contain the "x-amazon-apigateway-integration" extension at the operation level + assert "x-amazon-apigateway-integration" in schema["paths"]["/test"]["get"] + assert schema["paths"]["/test"]["get"]["x-amazon-apigateway-integration"] == openapi_extension_integration_detail + assert schema["paths"]["/test"]["get"]["operationId"] == "lambda_handler_test_get" + + +def test_openapi_extension_operation_level_multiple_paths( + openapi_extension_integration_detail, + openapi_extension_validator_detail, +): + # GIVEN an APIGatewayRestResolver instance + app = APIGatewayRestResolver() + + # WHEN we define multiple routes with integration extension at operation level + # AND get the schema + @app.get("/test", openapi_extensions={"x-amazon-apigateway-integration": openapi_extension_integration_detail}) + def lambda_handler_get(): + pass + + @app.post("/test", openapi_extensions={"x-amazon-apigateway-request-validator": openapi_extension_validator_detail}) + def lambda_handler_post(): + pass + + schema = json.loads(app.get_openapi_json_schema()) + + # THEN each route must contain only your extension + assert "x-amazon-apigateway-integration" in schema["paths"]["/test"]["get"] + assert schema["paths"]["/test"]["get"]["x-amazon-apigateway-integration"] == openapi_extension_integration_detail + + assert "x-amazon-apigateway-integration" not in schema["paths"]["/test"]["post"] + assert "x-amazon-apigateway-request-validator" in schema["paths"]["/test"]["post"] + assert ( + schema["paths"]["/test"]["post"]["x-amazon-apigateway-request-validator"] == openapi_extension_validator_detail + ) + + +def test_openapi_extension_operation_level_with_router(openapi_extension_integration_detail): + # GIVEN an APIGatewayRestResolver and Router instance + app = APIGatewayRestResolver() + router = Router() + + # WHEN we define an integration extension at operation level using Router + # AND get the schema + @router.get("/test", openapi_extensions={"x-amazon-apigateway-integration": openapi_extension_integration_detail}) + def lambda_handler(): + pass + + app.include_router(router) + + schema = json.loads(app.get_openapi_json_schema()) + + # THEN the OpenAPI schema must contain the "x-amazon-apigateway-integration" extension at the operation level + assert "x-amazon-apigateway-integration" in schema["paths"]["/test"]["get"] + assert schema["paths"]["/test"]["get"]["x-amazon-apigateway-integration"] == openapi_extension_integration_detail + + +def test_openapi_extension_operation_level_multiple_paths_with_router( + openapi_extension_integration_detail, + openapi_extension_validator_detail, +): + # GIVEN an APIGatewayRestResolver and Router instance + app = APIGatewayRestResolver() + router = Router() + + # WHEN we define multiple routes using extensions at operation level using Router + # AND get the schema + @router.get("/test", openapi_extensions={"x-amazon-apigateway-integration": openapi_extension_integration_detail}) + def lambda_handler_get(): + pass + + @router.post( + "/test", + openapi_extensions={"x-amazon-apigateway-request-validator": openapi_extension_validator_detail}, + ) + def lambda_handler_post(): + pass + + app.include_router(router) + + schema = json.loads(app.get_openapi_json_schema()) + + # THEN each route must contain only your extension + assert "x-amazon-apigateway-integration" in schema["paths"]["/test"]["get"] + assert schema["paths"]["/test"]["get"]["x-amazon-apigateway-integration"] == openapi_extension_integration_detail + + assert "x-amazon-apigateway-integration" not in schema["paths"]["/test"]["post"] + assert "x-amazon-apigateway-request-validator" in schema["paths"]["/test"]["post"] + assert ( + schema["paths"]["/test"]["post"]["x-amazon-apigateway-request-validator"] == openapi_extension_validator_detail + ) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_params.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_params.py new file mode 100644 index 0000000000000000000000000000000000000000..710627922f6a6e217f3e301a90699d67d3aef396 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_params.py @@ -0,0 +1,533 @@ +from dataclasses import dataclass +from datetime import datetime +from typing import List + +from pydantic import BaseModel, Field +from typing_extensions import Annotated + +from aws_lambda_powertools.event_handler.api_gateway import APIGatewayRestResolver, Response, Router +from aws_lambda_powertools.event_handler.openapi.models import ( + Example, + Parameter, + ParameterInType, + Schema, +) +from aws_lambda_powertools.event_handler.openapi.params import ( + Body, + Header, + Param, + ParamTypes, + Query, + _create_model_field, +) + +JSON_CONTENT_TYPE = "application/json" + + +def test_openapi_no_params(): + app = APIGatewayRestResolver() + + @app.get("/") + def handler(): + raise NotImplementedError() + + schema = app.get_openapi_schema() + assert schema.info.title == "Powertools API" + assert schema.info.version == "1.0.0" + + assert len(schema.paths.keys()) == 1 + assert "/" in schema.paths + + path = schema.paths["/"] + assert path.get + + get = path.get + assert get.summary == "GET /" + assert get.operationId == "handler__get" + + assert get.responses is not None + assert 200 in get.responses.keys() + response = get.responses[200] + assert response.description == "Successful Response" + + assert JSON_CONTENT_TYPE in response.content + json_response = response.content[JSON_CONTENT_TYPE] + assert json_response.schema_ is None + assert not json_response.examples + assert not json_response.encoding + + +def test_openapi_with_scalar_params(): + app = APIGatewayRestResolver() + + @app.get("/users/") + def handler(user_id: str, include_extra: bool = False): + raise NotImplementedError() + + schema = app.get_openapi_schema(title="My API", version="0.2.2") + assert schema.info.title == "My API" + assert schema.info.version == "0.2.2" + + assert len(schema.paths.keys()) == 1 + assert "/users/{user_id}" in schema.paths + + path = schema.paths["/users/{user_id}"] + assert path.get + + get = path.get + assert get.summary == "GET /users/{user_id}" + assert get.operationId == "handler_users__user_id__get" + assert len(get.parameters) == 2 + + parameter = get.parameters[0] + assert isinstance(parameter, Parameter) + assert parameter.in_ == ParameterInType.path + assert parameter.name == "user_id" + assert parameter.required is True + assert parameter.schema_.default is None + assert parameter.schema_.type == "string" + assert parameter.schema_.title == "User Id" + + parameter = get.parameters[1] + assert isinstance(parameter, Parameter) + assert parameter.in_ == ParameterInType.query + assert parameter.name == "include_extra" + assert parameter.required is False + assert parameter.schema_.default is False + assert parameter.schema_.type == "boolean" + assert parameter.schema_.title == "Include Extra" + + +def test_openapi_with_custom_params(): + app = APIGatewayRestResolver() + + @app.get("/users", summary="Get Users", operation_id="GetUsers", description="Get paginated users", tags=["Users"]) + def handler( + count: Annotated[ + int, + Query(gt=0, lt=100, examples=[Example(summary="Example 1", value=10)]), + ] = 1, + ): + print(count) + raise NotImplementedError() + + schema = app.get_openapi_schema() + + get = schema.paths["/users"].get + assert len(get.parameters) == 1 + assert get.summary == "Get Users" + assert get.operationId == "GetUsers" + assert get.description == "Get paginated users" + assert get.tags == ["Users"] + + parameter = get.parameters[0] + assert parameter.required is False + assert parameter.name == "count" + assert parameter.in_ == ParameterInType.query + assert parameter.schema_.type == "integer" + assert parameter.schema_.default == 1 + assert parameter.schema_.title == "Count" + assert parameter.schema_.exclusiveMinimum == 0 + assert parameter.schema_.exclusiveMaximum == 100 + assert len(parameter.schema_.examples) == 1 + example = Example(**parameter.schema_.examples[0]) + assert example.summary == "Example 1" + assert example.value == 10 + + +def test_openapi_with_scalar_returns(): + app = APIGatewayRestResolver() + + @app.get("/") + def handler() -> str: + return "Hello, world" + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + get = schema.paths["/"].get + assert get.parameters is None + + response = get.responses[200].content[JSON_CONTENT_TYPE] + assert response.schema_.title == "Return" + assert response.schema_.type == "string" + + +def test_openapi_with_response_returns(): + app = APIGatewayRestResolver() + + @app.get("/") + def handler() -> Response[Annotated[str, Body(title="Response title")]]: + return Response(body="Hello, world", status_code=200) + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + get = schema.paths["/"].get + assert get.parameters is None + + response = get.responses[200].content[JSON_CONTENT_TYPE] + assert response.schema_.title == "Response title" + assert response.schema_.type == "string" + + +def test_openapi_with_omitted_param(): + app = APIGatewayRestResolver() + + @app.get("/") + def handler(page: Annotated[str, Query(include_in_schema=False)]): + return page + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + get = schema.paths["/"].get + assert get.parameters is None + + +def test_openapi_with_list_param(): + app = APIGatewayRestResolver() + + @app.get("/") + def handler(page: Annotated[List[str], Query()]): + return page + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + get = schema.paths["/"].get + assert get.parameters[0].schema_.type == "array" + + +def test_openapi_with_description(): + app = APIGatewayRestResolver() + + @app.get("/") + def handler(page: Annotated[str, Query(description="This is a description")]): + return page + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + get = schema.paths["/"].get + assert len(get.parameters) == 1 + + parameter = get.parameters[0] + assert parameter.description == "This is a description" + + +def test_openapi_with_deprecated(): + app = APIGatewayRestResolver() + + @app.get("/") + def handler(page: Annotated[str, Query(deprecated=True)]): + return page + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + get = schema.paths["/"].get + assert len(get.parameters) == 1 + + parameter = get.parameters[0] + assert parameter.deprecated is True + + +def test_openapi_with_pydantic_returns(): + app = APIGatewayRestResolver() + + class User(BaseModel): + name: str + + @app.get("/") + def handler() -> User: + return User(name="Ruben Fonseca") + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + get = schema.paths["/"].get + assert get.parameters is None + + response = get.responses[200].content[JSON_CONTENT_TYPE] + reference = response.schema_ + assert reference.ref == "#/components/schemas/User" + + assert "User" in schema.components.schemas + user_schema = schema.components.schemas["User"] + assert isinstance(user_schema, Schema) + assert user_schema.title == "User" + assert "name" in user_schema.properties + + +def test_openapi_with_pydantic_nested_returns(): + app = APIGatewayRestResolver() + + class Order(BaseModel): + date: datetime + + class User(BaseModel): + name: str + orders: List[Order] + + @app.get("/") + def handler() -> User: + return User(name="Ruben Fonseca", orders=[Order(date=datetime.now())]) + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + assert "User" in schema.components.schemas + assert "Order" in schema.components.schemas + + user_schema = schema.components.schemas["User"] + assert "orders" in user_schema.properties + assert user_schema.properties["orders"].type == "array" + + +def test_openapi_with_dataclass_return(): + app = APIGatewayRestResolver() + + @dataclass + class User: + surname: str + + @app.get("/") + def handler() -> User: + return User(surname="Fonseca") + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + get = schema.paths["/"].get + assert get.parameters is None + + response = get.responses[200].content[JSON_CONTENT_TYPE] + reference = response.schema_ + assert reference.ref == "#/components/schemas/User" + + assert "User" in schema.components.schemas + user_schema = schema.components.schemas["User"] + assert isinstance(user_schema, Schema) + assert user_schema.title == "User" + assert "surname" in user_schema.properties + + +def test_openapi_with_body_param(): + app = APIGatewayRestResolver() + + class User(BaseModel): + name: str + + @app.post("/users") + def handler(user: User): + print(user) + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + post = schema.paths["/users"].post + assert post.parameters is None + assert post.requestBody is not None + + request_body = post.requestBody + assert request_body.required is True + assert request_body.content[JSON_CONTENT_TYPE].schema_.ref == "#/components/schemas/User" + + +def test_openapi_with_embed_body_param(): + app = APIGatewayRestResolver() + + class User(BaseModel): + name: str + + @app.post("/users") + def handler(user: Annotated[User, Body(embed=True)]): + print(user) + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + post = schema.paths["/users"].post + assert post.parameters is None + assert post.requestBody is not None + + request_body = post.requestBody + assert request_body.required is True + # Notice here we craft a specific schema for the embedded user + assert request_body.content[JSON_CONTENT_TYPE].schema_.ref == "#/components/schemas/Body_handler_users_post" + + # Ensure that the custom body schema actually points to the real user class + components = schema.components + assert "Body_handler_users_post" in components.schemas + body_post_handler_schema = components.schemas["Body_handler_users_post"] + assert body_post_handler_schema.properties["user"].ref == "#/components/schemas/User" + + +def test_openapi_with_body_description(): + app = APIGatewayRestResolver() + + class User(BaseModel): + name: str + + @app.post("/users") + def handler(user: Annotated[User, Body(description="This is a user")]): + print(user) + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 1 + + post = schema.paths["/users"].post + assert post.parameters is None + assert post.requestBody is not None + + request_body = post.requestBody + + # Description should appear in two places: on the request body and on the schema + assert request_body.description == "This is a user" + assert request_body.content[JSON_CONTENT_TYPE].schema_.description == "This is a user" + + +def test_openapi_with_excluded_operations(): + app = APIGatewayRestResolver() + + @app.get("/secret", include_in_schema=False) + def secret(): + return "password" + + schema = app.get_openapi_schema() + assert len(schema.paths.keys()) == 0 + + +def test_openapi_with_router_response(): + router = Router() + + @router.put("/example-resource", responses={200: {"description": "Custom response"}}) + def handler(): + pass + + app = APIGatewayRestResolver(enable_validation=True) + app.include_router(router) + + schema = app.get_openapi_schema() + put = schema.paths["/example-resource"].put + assert 200 in put.responses.keys() + assert put.responses[200].description == "Custom response" + + +def test_openapi_with_router_tags(): + router = Router() + + @router.put("/example-resource", tags=["Example"]) + def handler(): + pass + + app = APIGatewayRestResolver(enable_validation=True) + app.include_router(router) + + schema = app.get_openapi_schema() + tags = schema.paths["/example-resource"].put.tags + assert len(tags) == 1 + assert tags[0] == "Example" + + +def test_create_header(): + header = Header(convert_underscores=True) + assert header.convert_underscores is True + + +def test_create_body(): + body = Body(embed=True, examples=[Example(summary="Example 1", value=10)]) + assert body.embed is True + + +# Tests that when we try to create a model without a field type, we return None +def test_create_empty_model_field(): + result = _create_model_field(None, int, "name", False) + assert result is None + + +# Tests that when we try to crate a param model without a source, we default to "query" +def test_create_model_field_with_empty_in(): + field_info = Param() + + result = _create_model_field(field_info, int, "name", False) + assert result.field_info.in_ == ParamTypes.query + + +# Tests that when we try to create a model field with convert_underscore, we convert the field name +def test_create_model_field_convert_underscore(): + field_info = Header(alias=None, convert_underscores=True) + + result = _create_model_field(field_info, int, "user_id", False) + assert result.alias == "user-id" + + +def test_openapi_with_example_as_list(): + app = APIGatewayRestResolver() + + @app.get("/users", summary="Get Users", operation_id="GetUsers", description="Get paginated users", tags=["Users"]) + def handler( + count: Annotated[ + int, + Query(gt=0, lt=100, examples=["Example 1"]), + ] = 1, + ): + print(count) + raise NotImplementedError() + + schema = app.get_openapi_schema() + + get = schema.paths["/users"].get + assert len(get.parameters) == 1 + assert get.summary == "Get Users" + assert get.operationId == "GetUsers" + assert get.description == "Get paginated users" + assert get.tags == ["Users"] + + parameter = get.parameters[0] + assert parameter.required is False + assert parameter.name == "count" + assert parameter.in_ == ParameterInType.query + assert parameter.schema_.type == "integer" + assert parameter.schema_.default == 1 + assert parameter.schema_.title == "Count" + assert parameter.schema_.exclusiveMinimum == 0 + assert parameter.schema_.exclusiveMaximum == 100 + assert len(parameter.schema_.examples) == 1 + assert parameter.schema_.examples[0] == "Example 1" + + +def test_openapi_with_examples_of_base_model_field(): + app = APIGatewayRestResolver() + + class Todo(BaseModel): + id: int = Field(examples=[1]) + title: str = Field(examples=["Example 1"]) + priority: float = Field(examples=[0.5]) + completed: bool = Field(examples=[True]) + + @app.get("/") + def handler() -> Todo: + return Todo(id=0, title="", priority=0.0, completed=False) + + schema = app.get_openapi_schema() + assert "Todo" in schema.components.schemas + todo_schema = schema.components.schemas["Todo"] + assert isinstance(todo_schema, Schema) + + assert "id" in todo_schema.properties + id_property = todo_schema.properties["id"] + assert id_property.examples == [1] + + assert "title" in todo_schema.properties + title_property = todo_schema.properties["title"] + assert title_property.examples == ["Example 1"] + + assert "priority" in todo_schema.properties + priority_property = todo_schema.properties["priority"] + assert priority_property.examples == [0.5] + + assert "completed" in todo_schema.properties + completed_property = todo_schema.properties["completed"] + assert completed_property.examples == [True] diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_responses.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_responses.py new file mode 100644 index 0000000000000000000000000000000000000000..c2ab8008b5c14e1b50a0679f1623040839b61255 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_responses.py @@ -0,0 +1,172 @@ +from secrets import randbelow +from typing import Union + +from pydantic import BaseModel + +from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response + + +def test_openapi_default_response(): + app = APIGatewayRestResolver(enable_validation=True) + + @app.get("/") + def handler(): + pass + + schema = app.get_openapi_schema() + responses = schema.paths["/"].get.responses + assert 200 in responses.keys() + assert responses[200].description == "Successful Response" + + assert 422 in responses.keys() + assert responses[422].description == "Validation Error" + + +def test_openapi_200_response_with_description(): + app = APIGatewayRestResolver(enable_validation=True) + + @app.get("/", response_description="Custom response") + def handler(): + return {"message": "hello world"} + + schema = app.get_openapi_schema() + responses = schema.paths["/"].get.responses + assert 200 in responses.keys() + assert responses[200].description == "Custom response" + + assert 422 in responses.keys() + assert responses[422].description == "Validation Error" + + +def test_openapi_200_custom_response(): + app = APIGatewayRestResolver(enable_validation=True) + + @app.get("/", responses={202: {"description": "Custom response"}}) + def handler(): + return {"message": "hello world"} + + schema = app.get_openapi_schema() + responses = schema.paths["/"].get.responses + assert 202 in responses.keys() + assert responses[202].description == "Custom response" + + assert 200 not in responses.keys() # 200 was not added due to custom responses + assert 422 in responses.keys() # 422 is always added due to potential data validation errors + + +def test_openapi_422_default_response(): + app = APIGatewayRestResolver(enable_validation=True) + + @app.get("/") + def handler(): + return {"message": "hello world"} + + schema = app.get_openapi_schema() + responses = schema.paths["/"].get.responses + assert 422 in responses.keys() + assert responses[422].description == "Validation Error" + + +def test_openapi_422_custom_response(): + app = APIGatewayRestResolver(enable_validation=True) + + @app.get("/", responses={422: {"description": "Custom validation response"}}) + def handler(): + return {"message": "hello world"} + + schema = app.get_openapi_schema() + responses = schema.paths["/"].get.responses + assert 422 in responses.keys() + assert responses[422].description == "Custom validation response" + + +def test_openapi_200_custom_schema(): + app = APIGatewayRestResolver(enable_validation=True) + + class User(BaseModel): + pass + + @app.get( + "/", + responses={ + 200: { + "description": "Custom response", + "content": {"application/json": {"schema": User.model_json_schema()}}, + }, + }, + ) + def handler(): + return {"message": "hello world"} + + schema = app.get_openapi_schema() + responses = schema.paths["/"].get.responses + assert 200 in responses.keys() + + assert responses[200].description == "Custom response" + assert responses[200].content["application/json"].schema_.title == "User" + + +def test_openapi_union_response(): + app = APIGatewayRestResolver(enable_validation=True) + + class User(BaseModel): + pass + + class Order(BaseModel): + pass + + @app.get( + "/", + responses={ + 200: {"description": "200 Response", "content": {"application/json": {"model": User}}}, + 202: {"description": "202 Response", "content": {"application/json": {"model": Order}}}, + }, + ) + def handler() -> Response[Union[User, Order]]: + if randbelow(2) > 0: + return Response(status_code=200, body=User()) + else: + return Response(status_code=202, body=Order()) + + schema = app.get_openapi_schema() + responses = schema.paths["/"].get.responses + assert 200 in responses.keys() + assert responses[200].description == "200 Response" + assert responses[200].content["application/json"].schema_.ref == "#/components/schemas/User" + + assert 202 in responses.keys() + assert responses[202].description == "202 Response" + assert responses[202].content["application/json"].schema_.ref == "#/components/schemas/Order" + + +def test_openapi_union_partial_response(): + app = APIGatewayRestResolver(enable_validation=True) + + class User(BaseModel): + pass + + class Order(BaseModel): + pass + + @app.get( + "/", + responses={ + 200: {"description": "200 Response"}, + 202: {"description": "202 Response", "content": {"application/json": {"model": Order}}}, + }, + ) + def handler() -> Response[Union[User, Order]]: + if randbelow(2) > 0: + return Response(status_code=200, body=User()) + else: + return Response(status_code=202, body=Order()) + + schema = app.get_openapi_schema() + responses = schema.paths["/"].get.responses + assert 200 in responses.keys() + assert responses[200].description == "200 Response" + assert responses[200].content["application/json"].schema_.anyOf is not None + + assert 202 in responses.keys() + assert responses[202].description == "202 Response" + assert responses[202].content["application/json"].schema_.ref == "#/components/schemas/Order" diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_schema_pydantic_v2.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_schema_pydantic_v2.py new file mode 100644 index 0000000000000000000000000000000000000000..0df8f6a22c5a10e6a1a3a89f09470d83ef658643 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/_pydantic/test_openapi_schema_pydantic_v2.py @@ -0,0 +1,112 @@ +import json +import warnings +from typing import Literal, Optional + +import pytest +from pydantic import BaseModel, Field +from typing_extensions import Annotated + +from aws_lambda_powertools.event_handler import APIGatewayRestResolver +from aws_lambda_powertools.event_handler.openapi.models import Contact, License, Server +from aws_lambda_powertools.event_handler.openapi.params import Query +from aws_lambda_powertools.event_handler.openapi.types import OpenAPIResponse + + +@pytest.mark.usefixtures("pydanticv2_only") +def test_openapi_3_1_simple_handler(openapi31_schema): + # GIVEN APIGatewayRestResolver is initialized with enable_validation=True + app = APIGatewayRestResolver(enable_validation=True) + + # WHEN we have a simple handler + @app.get("/") + def handler(): + pass + + # WHEN we get the schema + schema = json.loads(app.get_openapi_json_schema()) + + # THEN the schema should be valid + assert openapi31_schema(schema) + + +@pytest.mark.usefixtures("pydanticv2_only") +def test_openapi_3_0_with_pydantic_v2(): + # GIVEN APIGatewayRestResolver is initialized with enable_validation=True + app = APIGatewayRestResolver(enable_validation=True) + + # WHEN we get the schema + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("default") + app.get_openapi_json_schema(openapi_version="3.0.0") + assert len(w) == 1 + assert str(w[-1].message) == ( + "You are using Pydantic v2, which is incompatible with OpenAPI schema 3.0. Forcing OpenAPI 3.1" + ) + + +@pytest.mark.usefixtures("pydanticv2_only") +def test_openapi_3_1_complex_handler(openapi31_schema): + # GIVEN APIGatewayRestResolver is initialized with enable_validation=True + app = APIGatewayRestResolver(enable_validation=True) + + # GIVEN a complex pydantic model + class TodoAttributes(BaseModel): + userId: int + id_: Optional[int] = Field(alias="id", default=None) + title: str + completed: bool + + class Todo(BaseModel): + type: Literal["ingest"] + attributes: TodoAttributes + + class TodoEnvelope(BaseModel): + data: Annotated[Todo, Field(description="The todo")] + + # WHEN we have a complex handler + @app.get( + "/", + summary="This is a summary", + description="Gets todos", + tags=["users", "operations", "todos"], + responses={ + 204: OpenAPIResponse( + description="Successful creation", + content={"": {"schema": {}}}, + ), + }, + ) + def handler( + name: Annotated[str, Query(description="The name", min_length=10, max_length=20)] = "John Doe Junior", + ) -> TodoEnvelope: ... + + @app.post( + "/todos", + tags=["todo"], + responses={ + 204: OpenAPIResponse( + description="Successful creation", + content={"": {"schema": {}}}, + ), + }, + ) + def create_todo(todo: TodoEnvelope): ... + + # WHEN we get the schema + schema = json.loads( + app.get_openapi_json_schema( + title="My little API", + version="69", + openapi_version="3.1.0", + summary="API Summary", + description="API description", + tags=["api"], + servers=[Server(url="http://localhost")], + terms_of_service="Yes", + contact=Contact(name="John Smith"), + license_info=License(name="MIT"), + ), + ) + + # THEN the schema should be valid + assert openapi31_schema(schema) diff --git a/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/required_dependencies/appsync/test_appsync_batch_resolvers.py b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/required_dependencies/appsync/test_appsync_batch_resolvers.py new file mode 100644 index 0000000000000000000000000000000000000000..c594be54a5ba00a4be4f2336a55d9d1d73de1f41 --- /dev/null +++ b/testbed/aws-powertools__powertools-lambda-python/tests/functional/event_handler/required_dependencies/appsync/test_appsync_batch_resolvers.py @@ -0,0 +1,983 @@ +from typing import List, Optional + +import pytest + +from aws_lambda_powertools.event_handler import AppSyncResolver +from aws_lambda_powertools.event_handler.graphql_appsync.exceptions import InvalidBatchResponse, ResolverNotFoundError +from aws_lambda_powertools.event_handler.graphql_appsync.router import Router +from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent +from aws_lambda_powertools.utilities.typing import LambdaContext +from aws_lambda_powertools.warnings import PowertoolsUserWarning +from tests.functional.utils import load_event + + +# TESTS RECEIVING THE EVENT PARTIALLY AND PROCESS EACH RECORD PER TIME. +def test_resolve_batch_processing_with_related_events_one_at_time(): + # GIVEN An event with multiple requests to fetch related posts for different post IDs. + event = [ + { + "arguments": {}, + "identity": "None", + "source": { + "post_id": "3", + "title": "Third book", + }, + "info": { + "selectionSetList": [ + "title", + ], + "selectionSetGraphQL": "{\n title\n}", + "fieldName": "relatedPosts", + "parentTypeName": "Post", + }, + }, + { + "arguments": {}, + "identity": "None", + "source": { + "post_id": "4", + "title": "Fifth book", + }, + "info": { + "selectionSetList": [ + "title", + ], + "selectionSetGraphQL": "{\n title\n}", + "fieldName": "relatedPosts", + "parentTypeName": "Post", + }, + }, + { + "arguments": {}, + "identity": "None", + "source": { + "post_id": "1", + "title": "First book", + }, + "info": { + "selectionSetList": [ + "title", + ], + "selectionSetGraphQL": "{\n title\n}", + "fieldName": "relatedPosts", + "parentTypeName": "Post", + }, + }, + ] + + # GIVEN A dictionary of posts and a dictionary of related posts. + posts = { + "1": { + "post_id": "1", + "title": "First book", + }, + "2": { + "post_id": "2", + "title": "Second book", + }, + "3": { + "post_id": "3", + "title": "Third book", + }, + "4": { + "post_id": "4", + "title": "Fourth book", + }, + } + + posts_related = { + "1": [posts["2"]], + "2": [posts["3"], posts["4"], posts["1"]], + "3": [posts["2"], posts["1"]], + "4": [posts["3"], posts["1"]], + } + + app = AppSyncResolver() + + @app.batch_resolver(type_name="Post", field_name="relatedPosts", aggregate=False) + def related_posts(event: AppSyncResolverEvent) -> Optional[list]: + return posts_related[event.source["post_id"]] + + # WHEN related_posts function, which is the batch resolver, is called with the event. + result = app.resolve(event, LambdaContext()) + + # THEN the result must be a list of related posts + assert result == [ + posts_related["3"], + posts_related["4"], + posts_related["1"], + ] + + +# Batch resolver tests +def test_resolve_batch_processing_with_simple_queries_one_at_time(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "2", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": [3, 4], + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the batch resolver for the listLocations field is defined + @app.batch_resolver(field_name="listLocations", aggregate=False) + def create_something(event: AppSyncResolverEvent) -> Optional[list]: # noqa AA03 VNE003 + return event.source["id"] if event.source else None + + # THEN the resolver should correctly process the batch of queries + result = app.resolve(event, LambdaContext()) + assert result == [appsync_event["source"]["id"] for appsync_event in event] + + assert app.current_batch_event and len(app.current_batch_event) == len(event) + assert not app.current_event + + +def test_resolve_batch_processing_with_raise_on_exception_one_at_time(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "2", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": [3, 4], + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the sync batch resolver for the 'listLocations' field is defined with raise_on_error=True + @app.batch_resolver(field_name="listLocations", raise_on_error=True, aggregate=False) + def create_something(event: AppSyncResolverEvent) -> Optional[list]: # noqa AA03 VNE003 + raise RuntimeError + + # THEN the resolver should raise a RuntimeError when processing the batch of queries + with pytest.raises(RuntimeError): + app.resolve(event, LambdaContext()) + + +def test_async_resolve_batch_processing_with_raise_on_exception_one_at_time(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "2", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": [3, 4], + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the async batch resolver for the 'listLocations' field is defined with raise_on_error=True + @app.async_batch_resolver(field_name="listLocations", raise_on_error=True, aggregate=False) + async def create_something(event: AppSyncResolverEvent) -> Optional[list]: # noqa AA03 VNE003 + raise RuntimeError + + # THEN the resolver should raise a RuntimeError when processing the batch of queries + with pytest.raises(RuntimeError): + app.resolve(event, LambdaContext()) + + +def test_resolve_batch_processing_without_exception_one_at_time(): + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "2", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": [3, 4], + }, + }, + ] + + app = AppSyncResolver() + + @app.batch_resolver(field_name="listLocations", raise_on_error=False, aggregate=False) + def create_something(event: AppSyncResolverEvent) -> Optional[list]: # noqa AA03 VNE003 + raise RuntimeError + + # Call the implicit handler + result = app.resolve(event, LambdaContext()) + assert result == [None, None, None] + + assert app.current_batch_event and len(app.current_batch_event) == len(event) + assert not app.current_event + + +def test_resolve_async_batch_processing_without_exception_one_at_time(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "2", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": [3, 4], + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the batch resolver for the 'listLocations' field is defined with raise_on_error=False + @app.async_batch_resolver(field_name="listLocations", raise_on_error=False, aggregate=False) + async def create_something(event: AppSyncResolverEvent) -> Optional[list]: # noqa AA03 VNE003 + raise RuntimeError + + result = app.resolve(event, LambdaContext()) + + # THEN the resolver should return None for each event in the batch + assert len(app.current_batch_event) == len(event) + assert result == [None, None, None] + + +def test_resolver_batch_with_resolver_not_found_one_at_time(): + # GIVEN a AppSyncResolver + app = AppSyncResolver() + router = Router() + + # WHEN we have an event + # WHEN the event field_name doesn't match with the resolver field_name + mock_event1 = [ + { + "typeName": "Query", + "info": { + "fieldName": "listCars", + "parentTypeName": "Query", + }, + "fieldName": "listCars", + "arguments": {"name": "value"}, + "source": { + "id": "1", + }, + }, + ] + + @router.batch_resolver(type_name="Query", field_name="listLocations", aggregate=False) + def get_locations(event: AppSyncResolverEvent, name: str) -> str: + return f"get_locations#{name}#" + event.source["id"] + + app.include_router(router) + + # THEN must fail with ResolverNotFoundError + with pytest.raises(ResolverNotFoundError, match="No resolver found for.*"): + app.resolve(mock_event1, LambdaContext()) + + +def test_resolver_batch_with_sync_and_async_resolver_at_same_time(): + # GIVEN a AppSyncResolver + app = AppSyncResolver() + router = Router() + + # WHEN we have an event + # WHEN the event field_name doesn't match with the resolver field_name + mock_event1 = [ + { + "typeName": "Query", + "info": { + "fieldName": "listCars", + "parentTypeName": "Query", + }, + "fieldName": "listCars", + "arguments": {"name": "value"}, + "source": { + "id": "1", + }, + }, + ] + + @router.batch_resolver(type_name="Query", field_name="listCars", aggregate=False) + def get_locations(event: AppSyncResolverEvent, name: str) -> str: + return f"get_locations#{name}#" + event.source["id"] + + @router.async_batch_resolver(type_name="Query", field_name="listCars", aggregate=False) + async def get_locations_async(event: AppSyncResolverEvent, name: str) -> str: + return f"get_locations#{name}#" + event.source["id"] + + app.include_router(router) + + # THEN must raise a PowertoolsUserWarning + with pytest.warns(PowertoolsUserWarning, match="Both synchronous and asynchronous resolvers*"): + app.resolve(mock_event1, LambdaContext()) + + +def test_batch_resolver_with_router(): + # GIVEN an AppSyncResolver and a Router instance + app = AppSyncResolver() + router = Router() + + @router.batch_resolver(type_name="Query", field_name="listLocations", aggregate=False) + def get_locations(event: AppSyncResolverEvent, name: str) -> str: + return f"get_locations#{name}#" + event.source["id"] + + @router.batch_resolver(field_name="listLocations2", aggregate=False) + def get_locations2(event: AppSyncResolverEvent, name: str) -> str: + return f"get_locations2#{name}#" + event.source["id"] + + # WHEN we include the routes + app.include_router(router) + + mock_event1 = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Query", + }, + "fieldName": "listLocations", + "arguments": {"name": "value"}, + "source": { + "id": "1", + }, + }, + ] + mock_event2 = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations2", + "parentTypeName": "Post", + }, + "fieldName": "listLocations2", + "arguments": {"name": "value"}, + "source": { + "id": "2", + }, + }, + ] + result1 = app.resolve(mock_event1, LambdaContext()) + result2 = app.resolve(mock_event2, LambdaContext()) + + # THEN the resolvers should return the expected results + assert result1 == ["get_locations#value#1"] + assert result2 == ["get_locations2#value#2"] + + +def test_resolve_async_batch_processing(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "2", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": [3, 4], + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the async batch resolver for the 'listLocations' field is defined + @app.async_batch_resolver(field_name="listLocations", aggregate=False) + async def create_something(event: AppSyncResolverEvent) -> Optional[list]: + return event.source["id"] if event.source else None + + # THEN the resolver should correctly process the batch of queries asynchronously + result = app.resolve(event, LambdaContext()) + assert result == [appsync_event["source"]["id"] for appsync_event in event] + + assert app.current_batch_event and len(app.current_batch_event) == len(event) + + +def test_resolve_async_batch_and_sync_singular_processing(): + # GIVEN a router with an async batch resolver for 'listLocations' and a sync singular resolver for 'listLocation' + app = AppSyncResolver() + router = Router() + + @router.async_batch_resolver(type_name="Query", field_name="listLocations", aggregate=False) + async def get_locations(event: AppSyncResolverEvent, name: str) -> str: + return f"get_locations#{name}#" + event.source["id"] + + @app.resolver(type_name="Query", field_name="listLocation") + def get_location(name: str) -> str: + return f"get_location#{name}" + + app.include_router(router) + + # WHEN resolving a batch of events for async 'listLocations' and a singular event for 'listLocation' + mock_event1 = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Query", + }, + "fieldName": "listLocations", + "arguments": {"name": "value"}, + "source": { + "id": "1", + }, + }, + ] + mock_event2 = {"typeName": "Query", "fieldName": "listLocation", "arguments": {"name": "value"}} + + result1 = app.resolve(mock_event1, LambdaContext()) + result2 = app.resolve(mock_event2, LambdaContext()) + + # THEN the resolvers should return the expected results + assert result1 == ["get_locations#value#1"] + assert result2 == "get_location#value" + + +def test_async_resolver_include_batch_resolver(): + # GIVEN an AppSyncResolver instance and a Router + app = AppSyncResolver() + router = Router() + + @router.async_batch_resolver(type_name="Query", field_name="listLocations", aggregate=False) + async def get_locations(event: AppSyncResolverEvent, name: str) -> str: + return f"get_locations#{name}#" + event.source["id"] + + @app.async_batch_resolver(field_name="listLocations2", aggregate=False) + async def get_locations2(event: AppSyncResolverEvent, name: str) -> str: + return f"get_locations2#{name}#" + event.source["id"] + + app.include_router(router) + + # WHEN two different events needs to be resolved + mock_event1 = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Query", + }, + "fieldName": "listLocations", + "arguments": {"name": "value"}, + "source": { + "id": "1", + }, + }, + ] + mock_event2 = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations2", + "parentTypeName": "Post", + }, + "fieldName": "listLocations2", + "arguments": {"name": "value"}, + "source": { + "id": "2", + }, + }, + ] + + # WHEN Resolve the events using the AppSyncResolver + result1 = app.resolve(mock_event1, LambdaContext()) + result2 = app.resolve(mock_event2, LambdaContext()) + + # THEN Verify that the results match the expected values + assert result1 == ["get_locations#value#1"] + assert result2 == ["get_locations2#value#2"] + + +def test_resolve_batch_processing_with_simple_queries_with_aggregate(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "2", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": [3, 4], + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the sync batch resolver for the listLocations field is defined + # WHEN using an aggregated event + # WHEN function returns a List + @app.batch_resolver(field_name="listLocations") + def create_something(event: List[AppSyncResolverEvent]) -> List: # noqa AA03 VNE003 + results = [] + for record in event: + results.append(record.source.get("id") if record.source else None) + + return results + + # THEN the resolver should correctly process the batch of queries + result = app.resolve(event, LambdaContext()) + assert result == [appsync_event["source"]["id"] for appsync_event in event] + + assert app.current_batch_event and len(app.current_batch_event) == len(event) + + +def test_resolve_async_batch_processing_with_simple_queries_with_aggregate(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "2", + }, + }, + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": [3, 4], + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the async batch resolver for the listLocations field is defined + # WHEN using an aggregated event + # WHEN function returns a List + @app.async_batch_resolver(field_name="listLocations") + async def create_something(event: List[AppSyncResolverEvent]) -> List: # noqa AA03 VNE003 + results = [] + for record in event: + results.append(record.source.get("id") if record.source else None) + + return results + + # THEN the resolver should correctly process the batch of queries + result = app.resolve(event, LambdaContext()) + assert result == [appsync_event["source"]["id"] for appsync_event in event] + + assert app.current_batch_event and len(app.current_batch_event) == len(event) + + +def test_resolve_batch_processing_with_aggregate_and_returning_a_non_list(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the sync batch resolver for the listLocations field is defined + # WHEN using an aggregated event + # WHEN function return something different than a List + @app.batch_resolver(field_name="listLocations") + def create_something(event: List[AppSyncResolverEvent]) -> Optional[List]: # noqa AA03 VNE003 + return event[0].source.get("id") if event[0].source else None + + # THEN the resolver should raise a InvalidBatchResponse when processing the batch of queries + with pytest.raises(InvalidBatchResponse): + app.resolve(event, LambdaContext()) + + +def test_resolve_async_batch_processing_with_aggregate_and_returning_a_non_list(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the async batch resolver for the listLocations field is defined + # WHEN using an aggregated event + # WHEN function return something different than a List + @app.async_batch_resolver(field_name="listLocations") + async def create_something(event: List[AppSyncResolverEvent]) -> Optional[List]: # noqa AA03 VNE003 + return event[0].source.get("id") if event[0].source else None + + # THEN the resolver should raise a InvalidBatchResponse when processing the batch of queries + with pytest.raises(InvalidBatchResponse): + app.resolve(event, LambdaContext()) + + +def test_resolve_sync_batch_processing_with_aggregate_and_without_return(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the sync batch resolver for the listLocations field is defined + # WHEN using an aggregated event + # WHEN function there is no return statement + @app.batch_resolver(field_name="listLocations") + def create_something(event: List[AppSyncResolverEvent]) -> Optional[List]: # noqa AA03 VNE003 + def do_something_with_post_id(post_id): ... + + post_id = event[0].source.get("id") if event[0].source else None + do_something_with_post_id(post_id) + + # No Return statement + + # THEN the resolver should raise a InvalidBatchResponse when processing the batch of queries + with pytest.raises(InvalidBatchResponse): + app.resolve(event, LambdaContext()) + + +def test_resolve_async_batch_processing_with_aggregate_and_without_return(): + # GIVEN a list of events representing GraphQL queries for listing locations + event = [ + { + "typeName": "Query", + "info": { + "fieldName": "listLocations", + "parentTypeName": "Post", + }, + "fieldName": "listLocations", + "arguments": {}, + "source": { + "id": "1", + }, + }, + ] + + app = AppSyncResolver() + + # WHEN the async batch resolver for the listLocations field is defined + # WHEN using an aggregated event + # WHEN function there is no return statement + @app.async_batch_resolver(field_name="listLocations") + async def create_something(event: List[AppSyncResolverEvent]) -> Optional[List]: # noqa AA03 VNE003 + def do_something_with_post_id(post_id): ... + + post_id = event[0].source.get("id") if event[0].source else None + do_something_with_post_id(post_id) + + # No Return statement + + # THEN the resolver should raise a InvalidBatchResponse when processing the batch of queries + with pytest.raises(InvalidBatchResponse): + app.resolve(event, LambdaContext()) + + +def test_include_router_access_batch_current_event(): + mock_event = load_event("appSyncBatchEvent.json") + + # GIVEN An instance of AppSyncResolver, a Router instance, and a resolver function registered with the router + app = AppSyncResolver() + router = Router() + + @router.batch_resolver(field_name="createSomething") + def get_user(event: List) -> List: + return [router.current_batch_event[0].identity.sub] + + app.include_router(router) + + # WHEN we resolve the event + ret = app.resolve(mock_event, {}) + + # THEN the resolver must be able to return a field in the batch_current_event + assert ret[0] == mock_event[0]["identity"]["sub"] + + +def test_app_access_batch_current_event(): + mock_event = load_event("appSyncBatchEvent.json") + + # GIVEN An instance of AppSyncResolver and a resolver function registered with the app + app = AppSyncResolver() + + @app.batch_resolver(field_name="createSomething") + def get_user(event: List) -> List: + return [app.current_batch_event[0].identity.sub] + + # WHEN we resolve the event + ret = app.resolve(mock_event, {}) + + # THEN the resolver must be able to return a field in the batch_current_event + assert ret[0] == mock_event[0]["identity"]["sub"] + + +def test_context_is_accessible_in_sync_batch_resolver(): + mock_event = load_event("appSyncBatchEvent.json") + + # GIVEN An instance of AppSyncResolver and a resolver function registered with the app + app = AppSyncResolver() + + @app.batch_resolver(field_name="createSomething") + def get_user(event: List) -> List: + return [app.context.get("project_name")] + + # WHEN we resolve the event + app.append_context(project_name="powertools") + ret = app.resolve(mock_event, {}) + + # THEN the resolver must be able to return a field in the batch_current_event + assert app.context == {} + assert ret[0] == "powertools" + + +def test_context_is_accessible_in_async_batch_resolver(): + mock_event = load_event("appSyncBatchEvent.json") + + # GIVEN An instance of AppSyncResolver and a resolver function registered with the app + app = AppSyncResolver() + + @app.async_batch_resolver(field_name="createSomething") + async def get_user(event: List) -> List: + return [app.context.get("project_name")] + + # WHEN we resolve the event + app.append_context(project_name="powertools") + ret = app.resolve(mock_event, {}) + + # THEN the resolver must be able to return a field in the batch_current_event + assert app.context == {} + assert ret[0] == "powertools"