split Postgres settings into separate PostgresSettings class

Author: hrodmn

stac_fastapi/pgstac/config.py

@@ -1,10 +1,10 @@
 """Postgres API configuration."""
 
-from typing import List, Optional, Type
+from typing import List, Type
 from urllib.parse import quote_plus as quote
 
 from pydantic import BaseModel, field_validator
-from pydantic_settings import SettingsConfigDict
+from pydantic_settings import BaseSettings, SettingsConfigDict
 from stac_fastapi.types.config import ApiSettings
 
 from stac_fastapi.pgstac.types.base_item_cache import (
@@ -43,7 +43,7 @@ class ServerSettings(BaseModel):
     model_config = SettingsConfigDict(extra="allow")
 
 
-class Settings(ApiSettings):
+class PostgresSettings(BaseSettings):
     """Postgres-specific API settings.
 
     Attributes:
@@ -57,12 +57,12 @@ class Settings(ApiSettings):
         invalid_id_chars: list of characters that are not allowed in item or collection ids.
     """
 
-    postgres_user: Optional[str] = None
-    postgres_pass: Optional[str] = None
-    postgres_host_reader: Optional[str] = None
-    postgres_host_writer: Optional[str] = None
-    postgres_port: Optional[int] = None
-    postgres_dbname: Optional[str] = None
+    postgres_user: str
+    postgres_pass: str
+    postgres_host_reader: str
+    postgres_host_writer: str
+    postgres_port: int
+    postgres_dbname: str
 
     db_min_conn_size: int = 10
     db_max_conn_size: int = 10
@@ -71,9 +71,28 @@ class Settings(ApiSettings):
 
     server_settings: ServerSettings = ServerSettings()
 
+    model_config = {"env_file": ".env", "extra": "ignore"}
+
+    @property
+    def reader_connection_string(self):
+        """Create reader psql connection string."""
+        return f"postgresql://{self.postgres_user}:{quote(self.postgres_pass)}@{self.postgres_host_reader}:{self.postgres_port}/{self.postgres_dbname}"
+
+    @property
+    def writer_connection_string(self):
+        """Create writer psql connection string."""
+        return f"postgresql://{self.postgres_user}:{quote(self.postgres_pass)}@{self.postgres_host_writer}:{self.postgres_port}/{self.postgres_dbname}"
+
+    @property
+    def testing_connection_string(self):
+        """Create testing psql connection string."""
+        return f"postgresql://{self.postgres_user}:{quote(self.postgres_pass)}@{self.postgres_host_writer}:{self.postgres_port}/pgstactestdb"
+
+
+class Settings(ApiSettings):
     use_api_hydrate: bool = False
-    base_item_cache: Type[BaseItemCache] = DefaultBaseItemCache
     invalid_id_chars: List[str] = DEFAULT_INVALID_ID_CHARS
+    base_item_cache: Type[BaseItemCache] = DefaultBaseItemCache
 
     cors_origins: str = "*"
     cors_methods: str = "GET,POST,OPTIONS"
@@ -89,45 +108,3 @@ def parse_cors_origin(cls, v):
     def parse_cors_methods(cls, v):
         """Parse CORS methods."""
         return [method.strip() for method in v.split(",")]
-
-    @property
-    def reader_connection_string(self):
-        """Create reader psql connection string."""
-        self._validate_postgres_settings()
-        return f"postgresql://{self.postgres_user}:{quote(self.postgres_pass)}@{self.postgres_host_reader}:{self.postgres_port}/{self.postgres_dbname}"
-
-    @property
-    def writer_connection_string(self):
-        """Create writer psql connection string."""
-        self._validate_postgres_settings()
-        return f"postgresql://{self.postgres_user}:{quote(self.postgres_pass)}@{self.postgres_host_writer}:{self.postgres_port}/{self.postgres_dbname}"
-
-    @property
-    def testing_connection_string(self):
-        """Create testing psql connection string."""
-        self._validate_postgres_settings()
-        return f"postgresql://{self.postgres_user}:{quote(self.postgres_pass)}@{self.postgres_host_writer}:{self.postgres_port}/pgstactestdb"
-
-    def _validate_postgres_settings(self) -> None:
-        """Validate that required PostgreSQL settings are configured."""
-        required_settings = [
-            "postgres_host_writer",
-            "postgres_host_reader",
-            "postgres_user",
-            "postgres_pass",
-            "postgres_port",
-            "postgres_dbname",
-        ]
-
-        missing = [
-            setting for setting in required_settings if getattr(self, setting) is None
-        ]
-
-        if missing:
-            raise ValueError(
-                f"Missing required PostgreSQL settings: {', '.join(missing)}",
-            )
-
-    model_config = SettingsConfigDict(
-        **{**ApiSettings.model_config, **{"env_nested_delimiter": "__"}}
-    )

stac_fastapi/pgstac/db.py

@@ -25,6 +25,8 @@
     NotFoundError,
 )
 
+from stac_fastapi.pgstac.config import PostgresSettings
+
 
 async def con_init(conn):
     """Use orjson for json returns."""
@@ -46,19 +48,25 @@ async def con_init(conn):
 
 
 async def connect_to_db(
-    app: FastAPI, get_conn: Optional[ConnectionGetter] = None
+    app: FastAPI,
+    get_conn: Optional[ConnectionGetter] = None,
+    postgres_settings: Optional[PostgresSettings] = None,
 ) -> None:
     """Create connection pools & connection retriever on application."""
-    settings = app.state.settings
-    if app.state.settings.testing:
-        readpool = writepool = settings.testing_connection_string
+    app_settings = app.state.settings
+
+    if not postgres_settings:
+        postgres_settings = PostgresSettings()
+
+    if app_settings.testing:
+        readpool = writepool = postgres_settings.testing_connection_string
     else:
-        readpool = settings.reader_connection_string
-        writepool = settings.writer_connection_string
+        readpool = postgres_settings.reader_connection_string
+        writepool = postgres_settings.writer_connection_string
 
     db = DB()
-    app.state.readpool = await db.create_pool(readpool, settings)
-    app.state.writepool = await db.create_pool(writepool, settings)
+    app.state.readpool = await db.create_pool(readpool, postgres_settings)
+    app.state.writepool = await db.create_pool(writepool, postgres_settings)
     app.state.get_connection = get_conn if get_conn else get_connection
 
 

tests/api/test_api.py

@@ -20,6 +20,7 @@
 from stac_fastapi.extensions.core.fields import FieldsConformanceClasses
 from stac_fastapi.types import stac as stac_types
 
+from stac_fastapi.pgstac.config import PostgresSettings
 from stac_fastapi.pgstac.core import CoreCrudClient, Settings
 from stac_fastapi.pgstac.db import close_db_connection, connect_to_db
 from stac_fastapi.pgstac.transactions import TransactionsClient
@@ -720,13 +721,16 @@ async def get_collection(
             return await super().get_collection(collection_id, request=request, **kwargs)
 
     settings = Settings(
+        testing=True,
+    )
+
+    postgres_settings = PostgresSettings(
         postgres_user=database.user,
         postgres_pass=database.password,
         postgres_host_reader=database.host,
         postgres_host_writer=database.host,
         postgres_port=database.port,
         postgres_dbname=database.dbname,
-        testing=True,
     )
 
     extensions = [
@@ -751,7 +755,7 @@ async def get_collection(
         collections_get_request_model=collection_search_extension.GET,
     )
     app = api.app
-    await connect_to_db(app)
+    await connect_to_db(app, postgres_settings=postgres_settings)
     try:
         async with AsyncClient(transport=ASGITransport(app=app)) as client:
             response = await client.post(
@@ -786,15 +790,17 @@ async def test_no_extension(
         loader.load_items(os.path.join(DATA_DIR, "test_item.json"))
 
     settings = Settings(
+        testing=True,
+        use_api_hydrate=hydrate,
+        enable_response_models=validation,
+    )
+    postgres_settings = PostgresSettings(
         postgres_user=database.user,
         postgres_pass=database.password,
         postgres_host_reader=database.host,
         postgres_host_writer=database.host,
         postgres_port=database.port,
         postgres_dbname=database.dbname,
-        testing=True,
-        use_api_hydrate=hydrate,
-        enable_response_models=validation,
     )
     extensions = []
     post_request_model = create_post_request_model(extensions, base_model=PgstacSearch)
@@ -805,7 +811,7 @@ async def test_no_extension(
         search_post_request_model=post_request_model,
     )
     app = api.app
-    await connect_to_db(app)
+    await connect_to_db(app, postgres_settings=postgres_settings)
     try:
         async with AsyncClient(transport=ASGITransport(app=app)) as client:
             landing = await client.get("http://test/")

tests/clients/test_postgres.py

@@ -6,8 +6,10 @@
 
 import pytest
 from fastapi import Request
+from pydantic import ValidationError
 from stac_pydantic import Collection, Item
 
+from stac_fastapi.pgstac.config import PostgresSettings
 from stac_fastapi.pgstac.db import close_db_connection, connect_to_db, get_connection
 
 # from tests.conftest import MockStarletteRequest
@@ -534,14 +536,41 @@ async def custom_get_connection(
         yield conn
 
 
+async def test_db_setup_works_with_env_vars(api_client, database, monkeypatch):
+    """Test that the application starts successfully if the POSTGRES_* environment variables are set"""
+    monkeypatch.setenv("POSTGRES_USER", database.user)
+    monkeypatch.setenv("POSTGRES_PASS", database.password)
+    monkeypatch.setenv("POSTGRES_HOST_READER", database.host)
+    monkeypatch.setenv("POSTGRES_HOST_WRITER", database.host)
+    monkeypatch.setenv("POSTGRES_PORT", str(database.port))
+    monkeypatch.setenv("POSTGRES_DBNAME", database.dbname)
+
+    await connect_to_db(api_client.app)
+
+
+async def test_db_setup_fails_without_env_vars(api_client):
+    """Test that the application fails to start if database environment variables are not set."""
+    with pytest.raises(ValidationError):
+        await connect_to_db(api_client.app)
+
+
 class TestDbConnect:
     @pytest.fixture
-    async def app(self, api_client):
+    async def app(self, api_client, database):
         """
         app fixture override to setup app with a customized db connection getter
         """
+        postgres_settings = PostgresSettings(
+            postgres_user=database.user,
+            postgres_pass=database.password,
+            postgres_host_reader=database.host,
+            postgres_host_writer=database.host,
+            postgres_port=database.port,
+            postgres_dbname=database.dbname,
+        )
+
         logger.debug("Customizing app setup")
-        await connect_to_db(api_client.app, custom_get_connection)
+        await connect_to_db(api_client.app, custom_get_connection, postgres_settings)
         yield api_client.app
         await close_db_connection(api_client.app)
 

tests/conftest.py

@@ -42,7 +42,7 @@
 from stac_fastapi.extensions.third_party import BulkTransactionExtension
 from stac_pydantic import Collection, Item
 
-from stac_fastapi.pgstac.config import Settings
+from stac_fastapi.pgstac.config import PostgresSettings, Settings
 from stac_fastapi.pgstac.core import CoreCrudClient
 from stac_fastapi.pgstac.db import close_db_connection, connect_to_db
 from stac_fastapi.pgstac.extensions import QueryExtension
@@ -120,15 +120,9 @@ async def pgstac(database):
 def api_client(request, database):
     hydrate, prefix, response_model = request.param
     api_settings = Settings(
-        postgres_user=database.user,
-        postgres_pass=database.password,
-        postgres_host_reader=database.host,
-        postgres_host_writer=database.host,
-        postgres_port=database.port,
-        postgres_dbname=database.dbname,
-        use_api_hydrate=hydrate,
         enable_response_models=response_model,
         testing=True,
+        use_api_hydrate=hydrate,
     )
 
     api_settings.openapi_url = prefix + api_settings.openapi_url
@@ -209,11 +203,19 @@ def api_client(request, database):
 
 
 @pytest.fixture(scope="function")
-async def app(api_client):
+async def app(api_client, database):
+    postgres_settings = PostgresSettings(
+        postgres_user=database.user,
+        postgres_pass=database.password,
+        postgres_host_reader=database.host,
+        postgres_host_writer=database.host,
+        postgres_port=database.port,
+        postgres_dbname=database.dbname,
+    )
     logger.info("Creating app Fixture")
     time.time()
     app = api_client.app
-    await connect_to_db(app)
+    await connect_to_db(app, postgres_settings=postgres_settings)
 
     yield app