def create_lambda( name: str, runtime: str, role: str = "foobar", handler: str = "main.handler", path: str = "dist/build.zip", environment: dict = {}, **kwargs, ): def clean_env(env): for k, v in env.items(): if isinstance(v, bool): if v: env[k] = str(v) else: continue elif isinstance(v, type(None)): env[k] = "" return env with open(str(Path().absolute() / path), "rb") as f: zipped_code = f.read() utils.call( boto3_fixtures.contrib.boto3.client("lambda").create_function, FunctionName=name, Runtime=runtime, Role=role, Handler=handler, Code=dict(ZipFile=zipped_code), Timeout=300, Environment={"Variables": clean_env(environment)}, )
def destroy_bucket(b: str): client = boto3_fixtures.contrib.boto3.client("s3") objects = boto3_fixtures.contrib.boto3.resource("s3").Bucket( b).objects.all() [utils.call(client.delete_object, Bucket=b, Key=o.key) for o in objects] resp = utils.call(client.delete_bucket, Bucket=b) client.get_waiter("bucket_not_exists").wait(Bucket=b) return resp
def check_sqs_fixtures(sqs_queues): client = boto3.client("sqs") for q in sqs_queues: queue_url = sqs.get_queue_url(q) utils.call( client.send_message, QueueUrl=queue_url, MessageBody=json.dumps({"foo": "bar"}), )
def create_queue(QueueName, **kwargs): client = boto3_fixtures.contrib.boto3.client("sqs") resp = utils.call(client.create_queue, QueueName=QueueName, **kwargs) utils.call( backoff_check, func=lambda: boto3_fixtures.contrib.boto3.client("sqs").get_queue_url( QueueName=QueueName ), ) return SQSQueue( name=QueueName, url=resp["QueueUrl"], arn=get_queue_arn(resp["QueueUrl"]), response=resp, )
def check_sns_fixtures(sns_topics): client = boto3.client("sns") resp = utils.call(utils.backoff_check, func=lambda: client.list_topics()) topic_names = [ tpc["TopicArn"].rsplit(":", 1)[-1] for tpc in resp["Topics"] ] assert set(topic_names) == set(sns_topics)
def check_lambda_fixtures(lambda_functions): client = boto3.client("lambda") resp = utils.call(utils.backoff_check, func=lambda: client.list_functions()) lambda_names = {lam["FunctionName"]: lam for lam in resp["Functions"]} for lam in lambda_functions: assert lam["FunctionName"] in lambda_names
def create_topic(topic_config: dict) -> SNSTopic: resp = utils.call( boto3_fixtures.contrib.boto3.client("sns").create_topic, **topic_config) def _check_topic(arn): return boto3_fixtures.contrib.boto3.client("sns").get_topic_attributes( TopicArn=arn) utils.call(utils.backoff_check, func=lambda: _check_topic(resp["TopicArn"])) return SNSTopic( name=topic_config["Name"], arn=resp["TopicArn"], response=resp, )
def create_table(TableName: str, **kwargs): kwargs.update({"BillingMode": "PAY_PER_REQUEST"}) resp = utils.call(boto3.client("dynamodb").create_table, TableName=TableName, **kwargs) name = mdict.get_nested(resp, ["TableDescription", "TableName"]) arn = mdict.get_nested(resp, ["TableDescription", "TableArn"]) return DynamoDBTable(name=name, arn=arn, response=resp)
def create_queue(q, dlq_url=None): client = boto3_fixtures.contrib.boto3.client("sqs") attrs = {} if dlq_url: attrs["RedrivePolicy"] = json.dumps({ "deadLetterTargetArn": get_queue_arn(dlq_url), "maxReceiveCount": 1 }) resp = utils.call(client.create_queue, QueueName=q, Attributes=attrs) utils.call( backoff_check, func=lambda: boto3_fixtures.contrib.boto3.client("sqs").get_queue_url( QueueName=q), ) return resp["QueueUrl"]
def get_queue_arn(queue_url): return mindictive.get_nested( utils.call( boto3.client("sqs").get_queue_attributes, QueueUrl=queue_url, AttributeNames=["QueueArn"], ), ["Attributes", "QueueArn"], )
def destroy_stream(StreamName: str, **kwargs): client = boto3_fixtures.contrib.boto3.client("kinesis") resp = utils.call(client.delete_stream, StreamName=StreamName) client.get_waiter("stream_not_exists").wait(StreamName=StreamName, WaiterConfig={ "Delay": 2, "MaxAttempts": 2 }) return resp
def create_stream(name: str, waiter_config: dict = { "Delay": 2, "MaxAttempts": 2 }): client = boto3_fixtures.contrib.boto3.client("kinesis") resp = utils.call(client.create_stream, StreamName=name, ShardCount=1) client.get_waiter("stream_exists").wait(StreamName=name, WaiterConfig=waiter_config) return resp
def create_tables(dynamodb_tables): client = boto3_fixtures.contrib.boto3.client("dynamodb") for table in dynamodb_tables: assert create_table(table) for table in dynamodb_tables: name = table["TableName"] client.get_waiter("table_exists").wait( TableName=name, WaiterConfig={"Delay": 1, "MaxAttempts": 30} ) assert utils.call(client.describe_table, TableName=name) return [t["TableName"] for t in dynamodb_tables]
def create_tables(tables: list): client = boto3_fixtures.contrib.boto3.client("dynamodb") _tables = [create_table(**table) for table in tables] for table in _tables: client.get_waiter("table_exists").wait(TableName=table.name, WaiterConfig={ "Delay": 1, "MaxAttempts": 30 }) assert utils.call(client.describe_table, TableName=table.name) return {t.name: t for t in _tables}
def create_stream(StreamName: str, ShardCount: int, **kwargs): client = boto3_fixtures.contrib.boto3.client("kinesis") resp = utils.call(client.create_stream, StreamName=StreamName, ShardCount=ShardCount, **kwargs) client.get_waiter("stream_exists").wait(StreamName=StreamName, WaiterConfig={ "Delay": 2, "MaxAttempts": 2 }) return KinesisStream(name=StreamName, response=resp)
def destroy_table(TableName: str, **kwargs): client = boto3_fixtures.contrib.boto3.client("dynamodb") return utils.call(client.delete_table, TableName=TableName)
def get_queue_url(queue_name): return utils.call(boto3.client("sqs").get_queue_url, QueueName=queue_name)["QueueUrl"]
def destroy_lambda(FunctionName: str, **kwargs): return utils.call( boto3_fixtures.contrib.boto3.client("lambda").delete_function, FunctionName=FunctionName, )
def create_bucket(b: str): client = boto3_fixtures.contrib.boto3.client("s3") resp = utils.call(client.create_bucket, Bucket=b) client.get_waiter("bucket_exists").wait(Bucket=b) return resp
def destroy_queue(QueueUrl, **kwargs): return utils.call( boto3_fixtures.contrib.boto3.client("sqs").delete_queue, QueueUrl=QueueUrl )
def create_bucket(Bucket: str, **kwargs): client = boto3_fixtures.contrib.boto3.client("s3") resp = utils.call(client.create_bucket, Bucket=Bucket, **kwargs) client.get_waiter("bucket_exists").wait(Bucket=Bucket) return S3Bucket(name=Bucket, response=resp)
def destroy_table(config): client = boto3_fixtures.contrib.boto3.client("dynamodb") return utils.call(client.delete_table, TableName=config["TableName"])
def create_table(config): config.update({"BillingMode": "PAY_PER_REQUEST"}) return utils.call(boto3.client("dynamodb").create_table, **config)
def destroy_topic(topic_arn: str): return utils.call(boto3_fixtures.contrib.boto3.client("sns").delete_topic, TopicArn=topic_arn)
def check_dynamodb_fixtures(dynamodb_tables): client = boto3.client("dynamodb") resp = utils.call(utils.backoff_check, func=lambda: client.list_tables()) for table in dynamodb_tables: assert table in resp["TableNames"]
def check_s3_fixtures(s3_buckets): client = boto3.client("s3") resp = utils.call(utils.backoff_check, func=lambda: client.list_buckets()) bucket_names = {b["Name"]: b for b in resp["Buckets"]} for b in s3_buckets: assert b in bucket_names