eoapi-cdk 8.1.1 → 8.2.0

package/lib/ingestor-api/runtime/tests/conftest.py

@@ -1,270 +0,0 @@
-import boto3
-import pytest
-from fastapi.testclient import TestClient
-from moto import mock_dynamodb, mock_ssm
-from stac_pydantic import Item
-
-
-@pytest.fixture
-def test_environ(monkeypatch):
-    # Mocked AWS Credentials for moto
-    monkeypatch.setenv("AWS_ACCESS_KEY_ID", "testing")
-    monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "testing")
-    monkeypatch.setenv("AWS_SECURITY_TOKEN", "testing")
-    monkeypatch.setenv("AWS_SESSION_TOKEN", "testing")
-
-    # Config mocks
-    monkeypatch.setenv("DYNAMODB_TABLE", "test_table")
-    monkeypatch.setenv("JWKS_URL", "https://test-jwks.url")
-    monkeypatch.setenv("STAC_URL", "https://test-stac.url")
-    monkeypatch.setenv("DATA_ACCESS_ROLE", "arn:aws:iam::123456789012:role/test-role")
-    monkeypatch.setenv("DB_SECRET_ARN", "testing")
-    monkeypatch.setenv("ROOT_PATH", "testing")
-
-
-@pytest.fixture
-def mock_ssm_parameter_store():
-    with mock_ssm():
-        yield boto3.client("ssm")
-
-
-@pytest.fixture
-def app(test_environ, mock_ssm_parameter_store):
-    from src.main import app
-
-    return app
-
-
-@pytest.fixture
-def api_client(app):
-    return TestClient(app)
-
-
-@pytest.fixture
-def mock_table(app, test_environ):
-    from src import dependencies
-    from src.config import settings
-
-    with mock_dynamodb():
-        client = boto3.resource("dynamodb")
-        mock_table = client.create_table(
-            TableName=settings.dynamodb_table,
-            AttributeDefinitions=[
-                {"AttributeName": "created_by", "AttributeType": "S"},
-                {"AttributeName": "id", "AttributeType": "S"},
-                {"AttributeName": "status", "AttributeType": "S"},
-                {"AttributeName": "created_at", "AttributeType": "S"},
-            ],
-            KeySchema=[
-                {"AttributeName": "created_by", "KeyType": "HASH"},
-                {"AttributeName": "id", "KeyType": "RANGE"},
-            ],
-            BillingMode="PAY_PER_REQUEST",
-            GlobalSecondaryIndexes=[
-                {
-                    "IndexName": "status",
-                    "KeySchema": [
-                        {"AttributeName": "status", "KeyType": "HASH"},
-                        {"AttributeName": "created_at", "KeyType": "RANGE"},
-                    ],
-                    "Projection": {"ProjectionType": "ALL"},
-                }
-            ],
-        )
-        app.dependency_overrides[dependencies.get_table] = lambda: mock_table
-        yield mock_table
-        app.dependency_overrides.pop(dependencies.get_table)
-
-
-@pytest.fixture
-def example_stac_item():
-    return {
-        "stac_version": "1.0.0",
-        "stac_extensions": [],
-        "type": "Feature",
-        "id": "20201211_223832_CS2",
-        "bbox": [
-            172.91173669923782,
-            1.3438851951615003,
-            172.95469614953714,
-            1.3690476620161975,
-        ],
-        "geometry": {
-            "type": "Polygon",
-            "coordinates": [
-                [
-                    [172.91173669923782, 1.3438851951615003],
-                    [172.95469614953714, 1.3438851951615003],
-                    [172.95469614953714, 1.3690476620161975],
-                    [172.91173669923782, 1.3690476620161975],
-                    [172.91173669923782, 1.3438851951615003],
-                ]
-            ],
-        },
-        "properties": {
-            "datetime": "2020-12-11T22:38:32.125000Z",
-            "eo:cloud_cover": 1,
-        },
-        "collection": "simple-collection",
-        "links": [
-            {
-                "rel": "collection",
-                "href": "./collection.json",
-                "type": "application/json",
-                "title": "Simple Example Collection",
-            },
-            {
-                "rel": "root",
-                "href": "./collection.json",
-                "type": "application/json",
-                "title": "Simple Example Collection",
-            },
-            {
-                "rel": "parent",
-                "href": "./collection.json",
-                "type": "application/json",
-                "title": "Simple Example Collection",
-            },
-        ],
-        "assets": {
-            "visual": {
-                "href": "https://TEST_API.com/open-cogs/stac-examples/20201211_223832_CS2.tif",  # noqa
-                "type": "image/tiff; application=geotiff; profile=cloud-optimized",
-                "title": "3-Band Visual",
-                "roles": ["visual"],
-            },
-            "thumbnail": {
-                "href": "https://TEST_API.com/open-cogs/stac-examples/20201211_223832_CS2.jpg",  # noqa
-                "title": "Thumbnail",
-                "type": "image/jpeg",
-                "roles": ["thumbnail"],
-            },
-        },
-    }
-
-
-@pytest.fixture
-def example_stac_collection():
-    return {
-        "id": "simple-collection",
-        "type": "Collection",
-        "stac_extensions": [
-            "https://stac-extensions.github.io/eo/v1.0.0/schema.json",
-            "https://stac-extensions.github.io/projection/v1.0.0/schema.json",
-            "https://stac-extensions.github.io/view/v1.0.0/schema.json",
-        ],
-        "item_assets": {
-            "data": {
-                "type": "image/tiff; application=geotiff; profile=cloud-optimized",
-                "roles": ["data"],
-            }
-        },
-        "stac_version": "1.0.0",
-        "description": "A simple collection demonstrating core catalog fields with links to a couple of items",
-        "title": "Simple Example Collection",
-        "providers": [
-            {
-                "name": "Remote Data, Inc",
-                "description": "Producers of awesome spatiotemporal assets",
-                "roles": ["producer", "processor"],
-                "url": "http://remotedata.io",
-            }
-        ],
-        "extent": {
-            "spatial": {
-                "bbox": [
-                    [
-                        172.91173669923782,
-                        1.3438851951615003,
-                        172.95469614953714,
-                        1.3690476620161975,
-                    ]
-                ]
-            },
-            "temporal": {
-                "interval": [["2020-12-11T22:38:32.125Z", "2020-12-14T18:02:31.437Z"]]
-            },
-        },
-        "license": "CC-BY-4.0",
-        "summaries": {
-            "platform": ["cool_sat1", "cool_sat2"],
-            "constellation": ["ion"],
-            "instruments": ["cool_sensor_v1", "cool_sensor_v2"],
-            "gsd": {"minimum": 0.512, "maximum": 0.66},
-            "eo:cloud_cover": {"minimum": 1.2, "maximum": 1.2},
-            "proj:epsg": {"minimum": 32659, "maximum": 32659},
-            "view:sun_elevation": {"minimum": 54.9, "maximum": 54.9},
-            "view:off_nadir": {"minimum": 3.8, "maximum": 3.8},
-            "view:sun_azimuth": {"minimum": 135.7, "maximum": 135.7},
-        },
-        "links": [
-            {
-                "rel": "root",
-                "href": "./collection.json",
-                "type": "application/json",
-                "title": "Simple Example Collection",
-            },
-            {
-                "rel": "item",
-                "href": "./simple-item.json",
-                "type": "application/geo+json",
-                "title": "Simple Item",
-            },
-            {
-                "rel": "item",
-                "href": "./core-item.json",
-                "type": "application/geo+json",
-                "title": "Core Item",
-            },
-            {
-                "rel": "item",
-                "href": "./extended-item.json",
-                "type": "application/geo+json",
-                "title": "Extended Item",
-            },
-            {
-                "rel": "self",
-                "href": "https://raw.githubusercontent.com/radiantearth/stac-spec/v1.0.0/examples/collection.json",
-                "type": "application/json",
-            },
-        ],
-    }
-
-
-@pytest.fixture
-def client(app):
-    """
-    Return an API Client
-    """
-    app.dependency_overrides = {}
-    return TestClient(app)
-
-
-@pytest.fixture
-def client_authenticated(app):
-    """
-    Returns an API client which skips the authentication
-    """
-    from src.dependencies import get_username
-
-    app.dependency_overrides[get_username] = lambda: "test_user"
-    return TestClient(app)
-
-
-@pytest.fixture
-def stac_collection(example_stac_collection):
-    from src import schemas
-
-    return schemas.StacCollection(**example_stac_collection)
-
-
-@pytest.fixture(scope="function")
-def example_ingestion(example_stac_item):
-    from src import schemas
-
-    return schemas.Ingestion(
-        id=example_stac_item["id"],
-        created_by="test-user",
-        status=schemas.Status.queued,
-        item=Item.model_validate(example_stac_item),
-    )

package/lib/ingestor-api/runtime/tests/test_collection.py

@@ -1,87 +0,0 @@
-import os
-from unittest.mock import Mock, patch
-
-import pytest
-import src.collection as collection
-from fastapi import HTTPException
-from pypgstac.load import Methods
-from src.utils import DbCreds
-
-
-@pytest.fixture()
-def loader():
-    with patch("src.collection.Loader", autospec=True) as m:
-        yield m
-
-
-@pytest.fixture()
-def pgstacdb():
-    with patch("src.collection.PgstacDB", autospec=True) as m:
-        m.return_value.__enter__.return_value = Mock()
-        yield m
-
-
-def test_load_collections(stac_collection, loader, pgstacdb):
-    with patch(
-        "src.collection.get_db_credentials",
-        return_value=DbCreds(
-            username="", password="", host="", port=1, dbname="", engine=""
-        ),
-    ):
-        os.environ["DB_SECRET_ARN"] = ""
-        collection.ingest(stac_collection)
-
-    loader.return_value.load_collections.assert_called_once_with(
-        file=[stac_collection.model_dump(mode="json")],
-        insert_mode=Methods.upsert,
-    )
-
-
-def test_ingest_loader_error(stac_collection, pgstacdb):
-    """Test handling of errors during the loading process."""
-    with patch(
-        "src.collection.get_db_credentials",
-        return_value=DbCreds(
-            username="", password="", host="", port=1, dbname="", engine=""
-        ),
-    ):
-        os.environ["DB_SECRET_ARN"] = ""
-
-        with patch("src.collection.Loader") as mock_loader:
-            mock_loader_instance = Mock()
-            mock_loader.return_value = mock_loader_instance
-            mock_loader_instance.load_collections.side_effect = Exception(
-                "Invalid collection data"
-            )
-
-            with pytest.raises(HTTPException) as excinfo:
-                collection.ingest(stac_collection)
-
-            assert excinfo.value.status_code == 500
-            assert "Invalid collection data" in str(excinfo.value.detail)
-
-
-def test_ingest_missing_environment_variable(stac_collection):
-    """Test handling when the required environment variable is missing."""
-    if "DB_SECRET_ARN" in os.environ:
-        del os.environ["DB_SECRET_ARN"]
-
-    with pytest.raises(HTTPException) as excinfo:
-        collection.ingest(stac_collection)
-
-    assert "DB_SECRET_ARN" in str(excinfo.value)
-
-
-def test_ingest_credentials_error(stac_collection):
-    """Test handling of errors during credential retrieval."""
-    with patch(
-        "src.collection.get_db_credentials",
-        side_effect=Exception("Failed to retrieve credentials"),
-    ):
-        os.environ["DB_SECRET_ARN"] = ""
-
-        with pytest.raises(HTTPException) as excinfo:
-            collection.ingest(stac_collection)
-
-        assert excinfo.value.status_code == 500
-        assert "Failed to retrieve credentials" in str(excinfo.value.detail)

package/lib/ingestor-api/runtime/tests/test_collection_endpoint.py

@@ -1,41 +0,0 @@
-from unittest.mock import patch
-
-publish_collections_endpoint = "/collections"
-delete_collection_endpoint = "/collections/{collection_id}"
-
-
-@patch("src.collection.ingest")
-def test_auth_publish_collection(
-    ingest, stac_collection, example_stac_collection, client_authenticated
-):
-    token = "token"
-    response = client_authenticated.post(
-        publish_collections_endpoint,
-        headers={"Authorization": f"bearer {token}"},
-        json=example_stac_collection,
-    )
-    ingest.assert_called_once_with(stac_collection)
-    assert response.status_code == 201
-
-
-def test_unauth_publish_collection(client, example_stac_collection):
-    response = client.post(publish_collections_endpoint, json=example_stac_collection)
-    assert response.status_code == 403
-
-
-@patch("src.collection.delete")
-def test_auth_delete_collection(delete, example_stac_collection, client_authenticated):
-    token = "token"
-    response = client_authenticated.delete(
-        delete_collection_endpoint.format(collection_id=example_stac_collection["id"]),
-        headers={"Authorization": f"bearer {token}"},
-    )
-    delete.assert_called_once_with(collection_id=example_stac_collection["id"])
-    assert response.status_code == 200
-
-
-def test_unauth_delete_collection(client, example_stac_collection):
-    response = client.delete(
-        delete_collection_endpoint.format(collection_id=example_stac_collection["id"]),
-    )
-    assert response.status_code == 403

package/lib/ingestor-api/runtime/tests/test_ingestor.py

@@ -1,60 +0,0 @@
-from unittest.mock import patch
-
-import pytest
-
-
-@pytest.fixture()
-def dynamodb_stream_event():
-    return {"Records": None}
-
-
-@pytest.fixture()
-def get_queued_ingestions(example_ingestion):
-    with patch(
-        "src.ingestor.get_queued_ingestions",
-        return_value=iter([example_ingestion]),
-        autospec=True,
-    ) as m:
-        yield m
-
-
-@pytest.fixture()
-def get_db_credentials():
-    with patch("src.ingestor.get_db_credentials", return_value="", autospec=True) as m:
-        yield m
-
-
-@pytest.fixture()
-def load_items():
-    with patch("src.ingestor.load_items", return_value=0, autospec=True) as m:
-        yield m
-
-
-@pytest.fixture()
-def get_table(mock_table):
-    with patch("src.ingestor.get_table", return_value=mock_table, autospec=True) as m:
-        yield m
-
-
-def test_handler(
-    monkeypatch,
-    test_environ,
-    dynamodb_stream_event,
-    example_ingestion,
-    get_queued_ingestions,
-    get_db_credentials,
-    load_items,
-    get_table,
-    mock_table,
-):
-    import src.ingestor as ingestor
-
-    ingestor.handler(dynamodb_stream_event, {})
-    load_items.assert_called_once_with(
-        creds="",
-        ingestions=[example_ingestion],
-    )
-    response = mock_table.get_item(
-        Key={"created_by": example_ingestion.created_by, "id": example_ingestion.id}
-    )
-    assert response["Item"]["status"] == "succeeded"

package/lib/ingestor-api/runtime/tests/test_registration.py

@@ -1,207 +0,0 @@
-import base64
-import json
-from datetime import timedelta
-from typing import TYPE_CHECKING, List
-from unittest.mock import call, patch
-
-import pytest
-from fastapi.encoders import jsonable_encoder
-
-if TYPE_CHECKING:
-    from fastapi.testclient import TestClient
-    from src import schemas, services
-
-ingestion_endpoint = "/ingestions"
-
-
-@pytest.fixture()
-def collection_exists():
-    with patch("src.validators.collection_exists", return_value=True) as m:
-        yield m
-
-
-@pytest.fixture()
-def collection_missing():
-    def bad_collection(collection_id: str):
-        raise ValueError("MOCKED MISSING COLLECTION ERROR")
-
-    with patch("src.validators.collection_exists", side_effect=bad_collection) as m:
-        yield m
-
-
-@pytest.fixture()
-def asset_exists():
-    with patch("src.validators.url_is_accessible", return_value=True) as m:
-        yield m
-
-
-@pytest.fixture()
-def asset_missing():
-    def bad_asset_url(href: str):
-        raise ValueError("MOCKED INACCESSIBLE URL ERROR")
-
-    with patch("src.validators.url_is_accessible", side_effect=bad_asset_url) as m:
-        yield m
-
-
-class TestCreate:
-    @pytest.fixture(autouse=True)
-    def setup(
-        self,
-        api_client: "TestClient",
-        mock_table: "services.Table",
-        example_ingestion: "schemas.Ingestion",
-    ):
-        from src import services
-
-        self.api_client = api_client
-        self.mock_table = mock_table
-        self.db = services.Database(self.mock_table)
-        self.example_ingestion = example_ingestion
-
-    def test_unauthenticated_create(self):
-        response = self.api_client.post(
-            ingestion_endpoint,
-            json=jsonable_encoder(self.example_ingestion.item),
-        )
-
-        assert response.status_code == 403
-
-    def test_create(self, client_authenticated, collection_exists, asset_exists):
-        response = self.api_client.post(
-            ingestion_endpoint,
-            json=jsonable_encoder(self.example_ingestion.item),
-        )
-
-        assert response.status_code == 201
-        collection_exists.assert_called_once_with(
-            collection_id=self.example_ingestion.item.collection
-        )
-
-        stored_data = self.db.fetch_many(status="queued")["items"]
-        assert len(stored_data) == 1
-        assert json.loads(stored_data[0].json(by_alias=True)) == response.json()
-
-    def test_validates_missing_collection(
-        self, client_authenticated, collection_missing, asset_exists
-    ):
-        response = self.api_client.post(
-            ingestion_endpoint,
-            json=jsonable_encoder(self.example_ingestion.item),
-        )
-        collection_missing.assert_called_once_with(
-            collection_id=self.example_ingestion.item.collection
-        )
-        assert response.status_code == 422, "should get validation error"
-        assert (
-            len(self.db.fetch_many(status="queued")["items"]) == 0
-        ), "data should not be stored in DB"
-
-    def test_validates_no_collection_id(self, asset_exists):
-        item_sans_id = self.example_ingestion.item.model_copy()
-        item_sans_id.collection = None
-
-        response = self.api_client.post(
-            ingestion_endpoint,
-            json=item_sans_id.model_dump(mode="json"),
-        )
-        assert response.status_code == 422, "should get validation error"
-        assert (
-            len(self.db.fetch_many(status="queued")["items"]) == 0
-        ), "data should not be stored in DB"
-
-    def test_validates_missing_assets(
-        self, client_authenticated, collection_exists, asset_missing
-    ):
-        response = self.api_client.post(
-            ingestion_endpoint,
-            json=jsonable_encoder(self.example_ingestion.item),
-        )
-
-        collection_exists.assert_called_once_with(
-            collection_id=self.example_ingestion.item.collection
-        )
-        asset_missing.assert_has_calls(
-            [
-                call(href=asset.href)
-                for asset in self.example_ingestion.item.assets.values()
-            ],
-            any_order=True,
-        )
-        assert response.status_code == 422, "should get validation error"
-        for asset_type in self.example_ingestion.item.assets.keys():
-            assert any(
-                err["loc"] == ["body", "assets", asset_type, "href"]
-                for err in response.json()["detail"]
-            ), "should reference asset type in validation error response"
-        assert (
-            len(self.db.fetch_many(status="queued")["items"]) == 0
-        ), "data should not be stored in DB"
-
-
-class TestList:
-    @pytest.fixture(autouse=True)
-    def setup(
-        self,
-        api_client: "TestClient",
-        mock_table: "services.Table",
-        example_ingestion: "schemas.Ingestion",
-    ):
-        self.api_client = api_client
-        self.mock_table = mock_table
-        self.example_ingestion = example_ingestion
-
-    def populate_table(self, count=100) -> List["schemas.Ingestion"]:
-        example_ingestions = []
-        for i in range(count):
-            ingestion = self.example_ingestion.model_copy()
-            ingestion.id = str(i)
-            ingestion.created_at = ingestion.created_at + timedelta(hours=i)
-            self.mock_table.put_item(Item=ingestion.dynamodb_dict())
-            example_ingestions.append(ingestion)
-        return example_ingestions
-
-    def test_simple_lookup(self):
-        self.mock_table.put_item(Item=self.example_ingestion.dynamodb_dict())
-        ingestion = jsonable_encoder(self.example_ingestion)
-        response = self.api_client.get(ingestion_endpoint)
-        assert response.status_code == 200
-        assert response.json() == {
-            "items": [ingestion],
-            "next": None,
-        }
-
-    def test_next_response(self):
-        example_ingestions = self.populate_table(100)
-
-        limit = 25
-        expected_next = json.loads(
-            example_ingestions[limit - 1].json(
-                include={"created_by", "id", "status", "created_at"}
-            )
-        )
-
-        response = self.api_client.get(ingestion_endpoint, params={"limit": limit})
-        assert response.status_code == 200
-        assert json.loads(base64.b64decode(response.json()["next"])) == expected_next
-        assert response.json()["items"] == jsonable_encoder(example_ingestions[:limit])
-
-    @pytest.mark.skip(reason="Test is currently broken")
-    def test_get_next_page(self):
-        example_ingestions = self.populate_table(100)
-
-        limit = 25
-        next_param = base64.b64encode(
-            example_ingestions[limit - 1]
-            .json(include={"created_by", "id", "status", "created_at"})
-            .encode()
-        )
-
-        response = self.api_client.get(
-            ingestion_endpoint, params={"limit": limit, "next": next_param}
-        )
-        assert response.status_code == 200
-        assert response.json()["items"] == [
-            json.loads(ingestion.json(by_alias=True))
-            for ingestion in example_ingestions[limit : limit * 2]
-        ]

package/lib/ingestor-api/runtime/tests/test_utils.py

@@ -1,35 +0,0 @@
-from unittest.mock import Mock, patch
-
-import pytest
-from pypgstac.load import Methods
-from src.utils import DbCreds
-
-
-@pytest.fixture()
-def loader():
-    with patch("src.utils.Loader", autospec=True) as m:
-        yield m
-
-
-@pytest.fixture()
-def pgstacdb():
-    with patch("src.utils.PgstacDB", autospec=True) as m:
-        m.return_value.__enter__.return_value = Mock()
-        yield m
-
-
-@pytest.fixture()
-def dbcreds():
-    dbcreds = DbCreds(username="", password="", host="", port=1, dbname="", engine="")
-    return dbcreds
-
-
-def test_load_items(loader, pgstacdb, example_ingestion, dbcreds):
-    import src.utils as utils
-
-    ingestions = [example_ingestion]
-    utils.load_items(dbcreds, ingestions)
-    loader.return_value.load_items.assert_called_once_with(
-        file=[i.item.model_dump(mode="json") for i in ingestions],
-        insert_mode=Methods.upsert,
-    )