Allow chaining noprocess fixtures - closes #890

  This allows for more complex test suites with common base data fixture
  Extended for a specific group of tests that needs additional data elements in database

Author: fizyk

README.rst

@@ -146,6 +146,27 @@ To connect to an external server (e.g., running in Docker), use the ``postgresql
 
 By default, it connects to ``127.0.0.1:5432``.
 
+Chaining fixtures
+-----------------
+
+You can chain multiple ``postgresql_noproc`` fixtures to layer your data pre-population. Each fixture in the chain will create its own template database based on the previous one.
+
+.. code-block:: python
+
+    from pytest_postgresql import factories
+
+    # 1. Start with a process or a no-process base
+    base_proc = factories.postgresql_proc(load=[load_schema])
+
+    # 2. Add a layer with some data
+    seeded_noproc = factories.postgresql_noproc(depends_on="base_proc", load=[load_data])
+
+    # 3. Add another layer with more data
+    more_seeded_noproc = factories.postgresql_noproc(depends_on="seeded_noproc", load=[load_more_data])
+
+    # 4. Use the final layer in your test
+    client = factories.postgresql("more_seeded_noproc")
+
 Configuration
 =============
 

pytest_postgresql/factories/noprocess.py

@@ -45,6 +45,7 @@ def postgresql_noproc(
     dbname: str | None = None,
     options: str = "",
     load: list[Callable | str | Path] | None = None,
+    depends_on: str | None = None,
 ) -> Callable[[FixtureRequest], Iterator[NoopExecutor]]:
     """Postgresql noprocess factory.
 
@@ -55,6 +56,7 @@ def postgresql_noproc(
     :param dbname: postgresql database name
     :param options: Postgresql connection options
     :param load: List of functions used to initialize database's template.
+    :param depends_on: Optional name of the fixture to depend on.
     :returns: function which makes a postgresql process
     """
 
@@ -66,28 +68,47 @@ def postgresql_noproc_fixture(request: FixtureRequest) -> Iterator[NoopExecutor]
         :returns: tcp executor-like object
         """
         config = get_config(request)
-        pg_host = host or config.host
-        pg_port = port or config.port or 5432
-        pg_user = user or config.user
-        pg_password = password or config.password
+
+        base_template_dbname = None
+        if depends_on:
+            base = request.getfixturevalue(depends_on)
+            pg_host = host or base.host
+            pg_port = port or base.port
+            pg_user = user or base.user
+            pg_password = password or base.password
+            pg_options = options or base.options
+            base_template_dbname = base.template_dbname
+        else:
+            pg_host = host or config.host
+            pg_port = port or config.port or 5432
+            pg_user = user or config.user
+            pg_password = password or config.password
+            pg_options = options or config.options
+
         pg_dbname = xdistify_dbname(dbname or config.dbname)
         pg_options = options or config.options
         pg_load = load or config.load
         drop_test_database = config.drop_test_database
 
+        if depends_on:
+            noop_exec_dbname = f"{pg_dbname}_{depends_on}"
+        else:
+            noop_exec_dbname = pg_dbname
+
         noop_exec = NoopExecutor(
             host=pg_host,
             port=pg_port,
             user=pg_user,
             password=pg_password,
-            dbname=pg_dbname,
+            dbname=noop_exec_dbname,
             options=pg_options,
         )
         janitor = DatabaseJanitor(
             user=noop_exec.user,
             host=noop_exec.host,
             port=noop_exec.port,
-            template_dbname=noop_exec.template_dbname,
+            template_dbname=base_template_dbname or noop_exec.template_dbname,
+            dbname=noop_exec.template_dbname if base_template_dbname else None,
             version=noop_exec.version,
             password=noop_exec.password,
         )

tests/test_chaining.py

@@ -0,0 +1,101 @@
+"""Chaining noprocess fixtures tests for pytest-postgresql."""
+
+import psycopg
+
+from pytest_postgresql import factories
+from pytest_postgresql.executor import PostgreSQLExecutor
+from pytest_postgresql.executor_noop import NoopExecutor
+
+
+def load_schema(host: str, port: int, user: str, dbname: str, password: str | None) -> None:
+    """Load schema into the database."""
+    with psycopg.connect(host=host, port=port, user=user, dbname=dbname, password=password) as conn:
+        with conn.cursor() as cur:
+            cur.execute("CREATE TABLE schema_table (id serial PRIMARY KEY, name varchar);")
+            conn.commit()
+
+
+def load_data(host: str, port: int, user: str, dbname: str, password: str | None) -> None:
+    """Load the first layer of data into the database."""
+    with psycopg.connect(host=host, port=port, user=user, dbname=dbname, password=password) as conn:
+        with conn.cursor() as cur:
+            cur.execute("INSERT INTO schema_table (name) VALUES ('data_layer');")
+            cur.execute("CREATE TABLE data_table (id serial PRIMARY KEY, val varchar);")
+            conn.commit()
+
+
+def load_more_data(host: str, port: int, user: str, dbname: str, password: str | None) -> None:
+    """Load the second layer of data into the database."""
+    with psycopg.connect(host=host, port=port, user=user, dbname=dbname, password=password) as conn:
+        with conn.cursor() as cur:
+            cur.execute("INSERT INTO schema_table (name) VALUES ('more_data_layer');")
+            cur.execute("CREATE TABLE more_data_table (id serial PRIMARY KEY, extra varchar);")
+            conn.commit()
+
+
+# Chaining: proc -> noproc -> client
+base_proc = factories.postgresql_proc(load=[load_schema])
+seeded_noproc = factories.postgresql_noproc(depends_on="base_proc", load=[load_data])
+client_layered = factories.postgresql("seeded_noproc")
+
+# Deeper chaining: proc -> noproc -> noproc -> client
+more_seeded_noproc = factories.postgresql_noproc(depends_on="seeded_noproc", load=[load_more_data])
+client_deep_layered = factories.postgresql("more_seeded_noproc")
+
+
+def test_chaining_two_layers(client_layered: psycopg.Connection) -> None:
+    """Test that data from both proc and noproc layers is present."""
+    with client_layered.cursor() as cur:
+        # From base_proc (load_schema)
+        cur.execute("SELECT count(*) FROM information_schema.tables WHERE table_name = 'schema_table';")
+        res = cur.fetchone()
+        assert res
+        assert res[0] == 1
+
+        # From seeded_noproc (load_data)
+        cur.execute("SELECT count(*) FROM information_schema.tables WHERE table_name = 'data_table';")
+        res = cur.fetchone()
+        assert res
+        assert res[0] == 1
+
+        # Data inserted in seeded_noproc
+        cur.execute("SELECT name FROM schema_table;")
+        res = cur.fetchone()
+        assert res
+        assert res[0] == "data_layer"
+
+
+def test_chaining_three_layers(client_deep_layered: psycopg.Connection) -> None:
+    """Test that data from all three layers is present."""
+    with client_deep_layered.cursor() as cur:
+        # From base_proc
+        cur.execute("SELECT count(*) FROM information_schema.tables WHERE table_name = 'schema_table';")
+        res = cur.fetchone()
+        assert res
+        assert res[0] == 1
+
+        # From seeded_noproc
+        cur.execute("SELECT count(*) FROM information_schema.tables WHERE table_name = 'data_table';")
+        res = cur.fetchone()
+        assert res
+        assert res[0] == 1
+
+        # From more_seeded_noproc
+        cur.execute("SELECT count(*) FROM information_schema.tables WHERE table_name = 'more_data_table';")
+        res = cur.fetchone()
+        assert res
+        assert res[0] == 1
+
+        # Data from multiple layers
+        cur.execute("SELECT name FROM schema_table ORDER BY id;")
+        results = cur.fetchall()
+        assert results[0][0] == "data_layer"
+        assert results[1][0] == "more_data_layer"
+
+
+def test_inheritance(base_proc: PostgreSQLExecutor, seeded_noproc: NoopExecutor) -> None:
+    """Verify that connection parameters are inherited from the base fixture."""
+    assert seeded_noproc.host == base_proc.host
+    assert seeded_noproc.port == base_proc.port
+    assert seeded_noproc.user == base_proc.user
+    assert seeded_noproc.password == base_proc.password