Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

4.1 KB
Raw Blame
"""Provisioned concurrency lists use the AWS SDK's unqualified, paginated request."""

import io
import time
import zipfile

import pytest
from botocore.exceptions import ClientError


@pytest.fixture
def provisioned_list_function(lambda_client, minimal_lambda_zip, unique_name):
    created = lambda_client.create_function(
        FunctionName=unique_name, Runtime="nodejs22.x", Handler="index.handler",
        Role="arn:aws:iam::000000000000:role/lambda-role",
        Code={"ZipFile": minimal_lambda_zip},
    )
    try:
        yield unique_name, created["FunctionArn"]
    finally:
        lambda_client.delete_function(FunctionName=unique_name)


@pytest.mark.parametrize("form", ["name", "arn", "partial"])
def test_empty_list_uses_the_unqualified_function(lambda_client, provisioned_list_function, form):
    name, arn = provisioned_list_function
    reference = {"name": name, "arn": arn, "partial": arn.split(":", 4)[4]}[form]
    response = lambda_client.list_provisioned_concurrency_configs(FunctionName=reference)
    assert response["ProvisionedConcurrencyConfigs"] == []
    assert "NextMarker" not in response


def test_list_missing_function_returns_resource_not_found(lambda_client, unique_name):
    with pytest.raises(ClientError) as error:
        lambda_client.list_provisioned_concurrency_configs(FunctionName=unique_name)
    assert error.value.response["Error"]["Code"] == "ResourceNotFoundException"
    assert error.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404


def test_list_preserves_qualifiers_status_pagination_and_deletion(lambda_client, provisioned_list_function):
    name, arn = provisioned_list_function
    first = lambda_client.publish_version(FunctionName=name)["Version"]
    lambda_client.create_alias(FunctionName=name, Name="live", FunctionVersion=first)
    code = io.BytesIO()
    with zipfile.ZipFile(code, "w") as archive:
        archive.writestr("index.js", "exports.handler = async () => 'second version';")
    second = lambda_client.update_function_code(
        FunctionName=name, ZipFile=code.getvalue(), Publish=True
    )["Version"]
    assert second != first
    for qualifier in ("live", second):
        lambda_client.put_provisioned_concurrency_config(
            FunctionName=name, Qualifier=qualifier, ProvisionedConcurrentExecutions=1
        )
    deadline = time.monotonic() + 120
    while True:
        statuses = {
            qualifier: lambda_client.get_provisioned_concurrency_config(
                FunctionName=name, Qualifier=qualifier
            )
            for qualifier in ("live", second)
        }
        assert all(value["Status"] != "FAILED" for value in statuses.values()), statuses
        if all(value["Status"] == "READY" for value in statuses.values()):
            break
        assert time.monotonic() < deadline, statuses
        time.sleep(0.2)
    pages = list(lambda_client.get_paginator("list_provisioned_concurrency_configs").paginate(
        FunctionName=name, PaginationConfig={"PageSize": 1}
    ))
    assert len(pages) == 2
    assert "NextMarker" in pages[0] and "NextMarker" not in pages[1]
    entries = [entry for page in pages for entry in page["ProvisionedConcurrencyConfigs"]]
    assert {entry["FunctionArn"] for entry in entries} == {arn + ":live", arn + ":" + second}
    for entry in entries:
        qualifier = entry["FunctionArn"].rsplit(":", 1)[1]
        for field in ("Status", "RequestedProvisionedConcurrentExecutions",
                      "AllocatedProvisionedConcurrentExecutions", "AvailableProvisionedConcurrentExecutions",
                      "LastModified"):
            assert entry[field] == statuses[qualifier][field]
        assert entry["Status"] == "READY"
        assert entry["AllocatedProvisionedConcurrentExecutions"] == 1
        assert entry["AvailableProvisionedConcurrentExecutions"] == 1
    lambda_client.delete_provisioned_concurrency_config(FunctionName=name, Qualifier="live")
    remaining = lambda_client.list_provisioned_concurrency_configs(FunctionName=name)["ProvisionedConcurrencyConfigs"]
    assert [entry["FunctionArn"] for entry in remaining] == [arn + ":" + second]