unstructured-ingest 0.3.8__py3-none-any.whl → 0.3.9__py3-none-any.whl

test/integration/chunkers/test_chunkers.py

@@ -29,14 +29,3 @@ async def test_chunker_api(chunker_file: Path, strategy: str):
     chunker = Chunker(config=chunker_config)
     results = await chunker.run_async(elements_filepath=chunker_file)
     assert results
-
-
-@pytest.mark.parametrize("chunker_file", chunker_files, ids=[path.name for path in chunker_files])
-@pytest.mark.parametrize("strategy", ["basic", "by_title"])
-def test_chunker_basic(chunker_file: Path, strategy: str):
-    chunker_config = ChunkerConfig(
-        chunking_strategy=strategy,
-    )
-    chunker = Chunker(config=chunker_config)
-    results = chunker.run(elements_filepath=chunker_file)
-    assert results

test/integration/connectors/conftest.py

@@ -6,7 +6,7 @@ import pytest
 
 from unstructured_ingest.v2.logger import logger
 
-FILENAME = "DA-1p-with-duplicate-pages.pdf.json"
+FILENAME = Path("DA-1p-with-duplicate-pages.pdf.json")
 
 
 @pytest.fixture
@@ -19,6 +19,16 @@ def upload_file() -> Path:
     return upload_file
 
 
+@pytest.fixture
+def upload_file_ndjson() -> Path:
+    int_test_dir = Path(__file__).parent
+    assets_dir = int_test_dir / "assets"
+    upload_file = assets_dir / FILENAME.with_suffix(".ndjson")
+    assert upload_file.exists()
+    assert upload_file.is_file()
+    return upload_file
+
+
 @pytest.fixture
 def temp_dir() -> Generator[Path, None, None]:
     with tempfile.TemporaryDirectory() as temp_dir:

test/integration/connectors/databricks_tests/test_volumes_native.py

@@ -11,8 +11,8 @@ from databricks.sdk import WorkspaceClient
 from databricks.sdk.errors.platform import NotFound
 
 from test.integration.connectors.utils.constants import DESTINATION_TAG, SOURCE_TAG
-from test.integration.connectors.utils.validation import (
-    ValidationConfigs,
+from test.integration.connectors.utils.validation.source import (
+    SourceValidationConfigs,
     source_connector_validation,
 )
 from test.integration.utils import requires_env
@@ -82,7 +82,7 @@ async def test_volumes_native_source():
         await source_connector_validation(
             indexer=indexer,
             downloader=downloader,
-            configs=ValidationConfigs(
+            configs=SourceValidationConfigs(
                 test_id="databricks_volumes_native",
                 expected_num_files=1,
             ),
@@ -156,6 +156,7 @@ async def test_volumes_native_destination(upload_file: Path):
                 catalog=env_data.catalog,
             ),
         )
+        uploader.precheck()
         if uploader.is_async():
             await uploader.run_async(path=upload_file, file_data=file_data)
         else:

test/integration/connectors/duckdb/conftest.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+import pytest
+
+int_test_dir = Path(__file__).parent
+assets_dir = int_test_dir / "assets"
+
+
+@pytest.fixture
+def duckdb_schema() -> Path:
+    schema_file = assets_dir / "duckdb-schema.sql"
+    assert schema_file.exists()
+    assert schema_file.is_file()
+    return schema_file

test/integration/connectors/duckdb/test_duckdb.py

@@ -1,13 +1,15 @@
-import tempfile
-from contextlib import contextmanager
+import json
 from pathlib import Path
-from typing import Generator
 
 import duckdb
-import pandas as pd
 import pytest
+from _pytest.fixtures import TopRequest
 
 from test.integration.connectors.utils.constants import DESTINATION_TAG
+from test.integration.connectors.utils.validation.destination import (
+    StagerValidationConfigs,
+    stager_validation,
+)
 from unstructured_ingest.v2.interfaces.file_data import FileData, SourceIdentifiers
 from unstructured_ingest.v2.processes.connectors.duckdb.duckdb import (
     CONNECTOR_TYPE,
@@ -18,19 +20,15 @@ from unstructured_ingest.v2.processes.connectors.duckdb.duckdb import (
 )
 
 
-@contextmanager
-def duckdbd_setup() -> Generator[Path, None, None]:
-    with tempfile.TemporaryDirectory() as temp_dir:
-        db_path = Path(temp_dir) / "temp_duck.db"
-        db_init_path = Path(__file__).parent / "duckdb-schema.sql"
-        assert db_init_path.exists()
-        assert db_init_path.is_file()
-        with duckdb.connect(database=db_path) as duckdb_connection:
-            with db_init_path.open("r") as f:
-                query = f.read()
-            duckdb_connection.execute(query)
-            duckdb_connection.close()
-        yield db_path
+@pytest.fixture
+def provisioned_db_file(duckdb_schema: Path, temp_dir: Path) -> Path:
+    db_path = Path(temp_dir) / "temp_duck.db"
+    with duckdb.connect(database=db_path) as duckdb_connection:
+        with duckdb_schema.open("r") as f:
+            query = f.read()
+        duckdb_connection.execute(query)
+        duckdb_connection.close()
+    return db_path
 
 
 def validate_duckdb_destination(db_path: Path, expected_num_elements: int):
@@ -49,34 +47,43 @@ def validate_duckdb_destination(db_path: Path, expected_num_elements: int):
 
 
 @pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, "duckdb")
-def test_duckdb_destination(upload_file: Path):
-    with duckdbd_setup() as test_db_path:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            file_data = FileData(
-                source_identifiers=SourceIdentifiers(
-                    fullpath=upload_file.name, filename=upload_file.name
-                ),
-                connector_type=CONNECTOR_TYPE,
-                identifier="mock-file-data",
-            )
+def test_duckdb_destination(upload_file: Path, provisioned_db_file: Path, temp_dir: Path):
+    file_data = FileData(
+        source_identifiers=SourceIdentifiers(fullpath=upload_file.name, filename=upload_file.name),
+        connector_type=CONNECTOR_TYPE,
+        identifier="mock-file-data",
+    )
+
+    stager = DuckDBUploadStager()
+    staged_path = stager.run(
+        elements_filepath=upload_file,
+        file_data=file_data,
+        output_dir=temp_dir,
+        output_filename=upload_file.name,
+    )
+
+    connection_config = DuckDBConnectionConfig(database=str(provisioned_db_file))
+    upload_config = DuckDBUploaderConfig()
+    uploader = DuckDBUploader(connection_config=connection_config, upload_config=upload_config)
 
-            # deafults to default stager config
-            stager = DuckDBUploadStager()
-            stager_params = {
-                "elements_filepath": upload_file,
-                "file_data": file_data,
-                "output_dir": temp_dir,
-                "output_filename": "test_db",
-            }
-            staged_path = stager.run(**stager_params)
+    uploader.run(path=staged_path, file_data=file_data)
 
-            connection_config = DuckDBConnectionConfig(database=str(test_db_path))
-            upload_config = DuckDBUploaderConfig()
-            uploader = DuckDBUploader(
-                connection_config=connection_config, upload_config=upload_config
-            )
+    with staged_path.open() as f:
+        data = json.load(f)
+    validate_duckdb_destination(db_path=provisioned_db_file, expected_num_elements=len(data))
 
-            uploader.run(path=staged_path, file_data=file_data)
 
-            staged_df = pd.read_json(staged_path, orient="records", lines=True)
-            validate_duckdb_destination(db_path=test_db_path, expected_num_elements=len(staged_df))
+@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
+def test_duckdb_stager(
+    request: TopRequest,
+    upload_file_str: str,
+    tmp_path: Path,
+):
+    upload_file: Path = request.getfixturevalue(upload_file_str)
+    stager = DuckDBUploadStager()
+    stager_validation(
+        configs=StagerValidationConfigs(test_id=CONNECTOR_TYPE, expected_count=22),
+        input_file=upload_file,
+        stager=stager,
+        tmp_dir=tmp_path,
+    )

test/integration/connectors/duckdb/test_motherduck.py

@@ -1,7 +1,5 @@
 import os
-import tempfile
 import uuid
-from contextlib import contextmanager
 from pathlib import Path
 from typing import Generator
 
@@ -22,15 +20,19 @@ from unstructured_ingest.v2.processes.connectors.duckdb.motherduck import (
 )
 
 
-@contextmanager
-def motherduck_setup(md_token: str) -> Generator[Path, None, None]:
+@pytest.fixture
+def md_token() -> str:
+    motherduck_token = os.getenv("MOTHERDUCK_TOKEN", None)
+    assert motherduck_token
+    return motherduck_token
+
+
+@pytest.fixture
+def provisioned_db(md_token: str, duckdb_schema: Path) -> Generator[str, None, None]:
     database_name = f"test_{str(uuid.uuid4()).replace('-', '_')}"
     try:
-        db_init_path = Path(__file__).parent / "duckdb-schema.sql"
-        assert db_init_path.exists()
-        assert db_init_path.is_file()
         with duckdb.connect(f"md:?motherduck_token={md_token}") as md_conn:
-            with db_init_path.open("r") as f:
+            with duckdb_schema.open("r") as f:
                 query = f.read()
             md_conn.execute(f"CREATE DATABASE {database_name}")
             md_conn.execute(f"USE {database_name}")
@@ -59,48 +61,35 @@ def validate_motherduck_destination(database: str, expected_num_elements: int, m
             conn.close()
 
 
-def get_motherduck_token() -> dict:
-    motherduck_token = os.getenv("MOTHERDUCK_TOKEN", None)
-    assert motherduck_token
-    return motherduck_token
-
-
-@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, "motherduck")
+@pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG)
 @requires_env("MOTHERDUCK_TOKEN")
-def test_motherduck_destination(upload_file: Path):
-    md_token = get_motherduck_token()
-    with motherduck_setup(md_token) as test_database:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            file_data = FileData(
-                source_identifiers=SourceIdentifiers(
-                    fullpath=upload_file.name, filename=upload_file.name
-                ),
-                connector_type=CONNECTOR_TYPE,
-                identifier="mock-file-data",
-            )
+def test_motherduck_destination(
+    md_token: str, upload_file: Path, provisioned_db: str, temp_dir: Path
+):
+    file_data = FileData(
+        source_identifiers=SourceIdentifiers(fullpath=upload_file.name, filename=upload_file.name),
+        connector_type=CONNECTOR_TYPE,
+        identifier="mock-file-data",
+    )
 
-            # deafults to default stager config
-            stager = MotherDuckUploadStager()
-            stager_params = {
-                "elements_filepath": upload_file,
-                "file_data": file_data,
-                "output_dir": temp_dir,
-                "output_filename": "test_db",
-            }
-            staged_path = stager.run(**stager_params)
+    stager = MotherDuckUploadStager()
+    staged_path = stager.run(
+        elements_filepath=upload_file,
+        file_data=file_data,
+        output_dir=temp_dir,
+        output_filename=upload_file.name,
+    )
 
-            access_config = MotherDuckAccessConfig(md_token=md_token)
-            connection_config = MotherDuckConnectionConfig(
-                database=test_database, access_config=access_config
-            )
-            upload_config = MotherDuckUploaderConfig()
-            uploader = MotherDuckUploader(
-                connection_config=connection_config, upload_config=upload_config
-            )
+    access_config = MotherDuckAccessConfig(md_token=md_token)
+    connection_config = MotherDuckConnectionConfig(
+        database=provisioned_db, access_config=access_config
+    )
+    upload_config = MotherDuckUploaderConfig()
+    uploader = MotherDuckUploader(connection_config=connection_config, upload_config=upload_config)
 
-            uploader.run(path=staged_path, file_data=file_data)
+    uploader.run(path=staged_path, file_data=file_data)
 
-            staged_df = pd.read_json(staged_path, orient="records", lines=True)
-            validate_motherduck_destination(
-                database=test_database, expected_num_elements=len(staged_df), md_token=md_token
-            )
+    staged_df = pd.read_json(staged_path, orient="records", lines=True)
+    validate_motherduck_destination(
+        database=provisioned_db, expected_num_elements=len(staged_df), md_token=md_token
+    )

test/integration/connectors/elasticsearch/test_elasticsearch.py

@@ -5,16 +5,20 @@ import time
 from contextlib import contextmanager
 from pathlib import Path
 from typing import Generator
-
+from test.integration.connectors.utils.validation.destination import (
+    StagerValidationConfigs,
+    stager_validation,
+)
 import pandas as pd
 import pytest
+from _pytest.fixtures import TopRequest
 from elasticsearch import Elasticsearch as ElasticsearchClient
 from elasticsearch.helpers import bulk
 
 from test.integration.connectors.utils.constants import DESTINATION_TAG, SOURCE_TAG
 from test.integration.connectors.utils.docker import HealthCheck, container_context
-from test.integration.connectors.utils.validation import (
-    ValidationConfigs,
+from test.integration.connectors.utils.validation.source import (
+    SourceValidationConfigs,
     source_connector_validation,
 )
 from unstructured_ingest.error import DestinationConnectionError, SourceConnectionError
@@ -194,7 +198,7 @@ async def test_elasticsearch_source(source_index: str, movies_dataframe: pd.Data
         await source_connector_validation(
             indexer=indexer,
             downloader=downloader,
-            configs=ValidationConfigs(
+            configs=SourceValidationConfigs(
                 test_id=CONNECTOR_TYPE,
                 expected_num_files=expected_num_files,
                 expected_number_indexed_file_data=1,
@@ -306,3 +310,21 @@ def test_elasticsearch_destination_precheck_fail_no_index(destination_index: str
     )
     with pytest.raises(DestinationConnectionError):
         uploader.precheck()
+
+
+@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
+def test_elasticsearch_stager(
+    request: TopRequest,
+    upload_file_str: str,
+    tmp_path: Path,
+):
+    upload_file: Path = request.getfixturevalue(upload_file_str)
+    stager = ElasticsearchUploadStager(
+        upload_stager_config=ElasticsearchUploadStagerConfig(index_name="mock_index")
+    )
+    stager_validation(
+        configs=StagerValidationConfigs(test_id=CONNECTOR_TYPE, expected_count=22),
+        input_file=upload_file,
+        stager=stager,
+        tmp_dir=tmp_path,
+    )

test/integration/connectors/elasticsearch/test_opensearch.py

@@ -7,12 +7,17 @@ from typing import Generator
 
 import pandas as pd
 import pytest
+from _pytest.fixtures import TopRequest
 from opensearchpy import Document, Keyword, OpenSearch, Text
 
 from test.integration.connectors.utils.constants import DESTINATION_TAG, SOURCE_TAG
 from test.integration.connectors.utils.docker import HealthCheck, container_context
-from test.integration.connectors.utils.validation import (
-    ValidationConfigs,
+from test.integration.connectors.utils.validation.destination import (
+    StagerValidationConfigs,
+    stager_validation,
+)
+from test.integration.connectors.utils.validation.source import (
+    SourceValidationConfigs,
     source_connector_validation,
 )
 from unstructured_ingest.error import (
@@ -183,7 +188,7 @@ async def test_opensearch_source(source_index: str, movies_dataframe: pd.DataFra
         await source_connector_validation(
             indexer=indexer,
             downloader=downloader,
-            configs=ValidationConfigs(
+            configs=SourceValidationConfigs(
                 test_id=CONNECTOR_TYPE,
                 expected_num_files=expected_num_files,
                 expected_number_indexed_file_data=1,
@@ -300,3 +305,21 @@ def test_opensearch_destination_precheck_fail_no_index(destination_index: str):
     )
     with pytest.raises(DestinationConnectionError):
         uploader.precheck()
+
+
+@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
+def test_opensearch_stager(
+    request: TopRequest,
+    upload_file_str: str,
+    tmp_path: Path,
+):
+    upload_file: Path = request.getfixturevalue(upload_file_str)
+    stager = OpenSearchUploadStager(
+        upload_stager_config=OpenSearchUploadStagerConfig(index_name="mock_index")
+    )
+    stager_validation(
+        configs=StagerValidationConfigs(test_id=CONNECTOR_TYPE, expected_count=22),
+        input_file=upload_file,
+        stager=stager,
+        tmp_dir=tmp_path,
+    )

test/integration/connectors/sql/test_postgres.py

@@ -1,15 +1,18 @@
-import tempfile
-from contextlib import contextmanager
+import json
 from pathlib import Path
 
-import pandas as pd
 import pytest
+from _pytest.fixtures import TopRequest
 from psycopg2 import connect
 
 from test.integration.connectors.utils.constants import DESTINATION_TAG, SOURCE_TAG, env_setup_path
 from test.integration.connectors.utils.docker_compose import docker_compose_context
-from test.integration.connectors.utils.validation import (
-    ValidationConfigs,
+from test.integration.connectors.utils.validation.destination import (
+    StagerValidationConfigs,
+    stager_validation,
+)
+from test.integration.connectors.utils.validation.source import (
+    SourceValidationConfigs,
     source_connector_validation,
 )
 from unstructured_ingest.v2.interfaces import FileData
@@ -28,13 +31,14 @@ from unstructured_ingest.v2.processes.connectors.sql.postgres import (
 SEED_DATA_ROWS = 20
 
 
-@contextmanager
-def postgres_download_setup() -> None:
+@pytest.fixture
+def source_database_setup() -> str:
+    db_name = "test_db"
     with docker_compose_context(docker_compose_path=env_setup_path / "sql" / "postgres" / "source"):
         connection = connect(
             user="unstructured",
             password="test",
-            dbname="test_db",
+            dbname=db_name,
             host="localhost",
             port=5433,
         )
@@ -43,12 +47,12 @@ def postgres_download_setup() -> None:
                 sql_statment = f"INSERT INTO cars (brand, price) VALUES " f"('brand_{i}', {i})"
                 cursor.execute(sql_statment)
             connection.commit()
-        yield
+        yield db_name
 
 
 @pytest.mark.asyncio
 @pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, "sql")
-async def test_postgres_source():
+async def test_postgres_source(temp_dir: Path, source_database_setup: str):
     connect_params = {
         "host": "localhost",
         "port": 5433,
@@ -56,37 +60,31 @@ async def test_postgres_source():
         "user": "unstructured",
         "password": "test",
     }
-    with postgres_download_setup():
-        with tempfile.TemporaryDirectory() as tmpdir:
-            connection_config = PostgresConnectionConfig(
-                host=connect_params["host"],
-                port=connect_params["port"],
-                database=connect_params["database"],
-                username=connect_params["user"],
-                access_config=PostgresAccessConfig(password=connect_params["password"]),
-            )
-            indexer = PostgresIndexer(
-                connection_config=connection_config,
-                index_config=PostgresIndexerConfig(
-                    table_name="cars", id_column="car_id", batch_size=5
-                ),
-            )
-            downloader = PostgresDownloader(
-                connection_config=connection_config,
-                download_config=PostgresDownloaderConfig(
-                    fields=["car_id", "brand"], download_dir=Path(tmpdir)
-                ),
-            )
-            await source_connector_validation(
-                indexer=indexer,
-                downloader=downloader,
-                configs=ValidationConfigs(
-                    test_id="postgres",
-                    expected_num_files=SEED_DATA_ROWS,
-                    expected_number_indexed_file_data=4,
-                    validate_downloaded_files=True,
-                ),
-            )
+    connection_config = PostgresConnectionConfig(
+        host=connect_params["host"],
+        port=connect_params["port"],
+        database=connect_params["database"],
+        username=connect_params["user"],
+        access_config=PostgresAccessConfig(password=connect_params["password"]),
+    )
+    indexer = PostgresIndexer(
+        connection_config=connection_config,
+        index_config=PostgresIndexerConfig(table_name="cars", id_column="car_id", batch_size=5),
+    )
+    downloader = PostgresDownloader(
+        connection_config=connection_config,
+        download_config=PostgresDownloaderConfig(fields=["car_id", "brand"], download_dir=temp_dir),
+    )
+    await source_connector_validation(
+        indexer=indexer,
+        downloader=downloader,
+        configs=SourceValidationConfigs(
+            test_id="postgres",
+            expected_num_files=SEED_DATA_ROWS,
+            expected_number_indexed_file_data=4,
+            validate_downloaded_files=True,
+        ),
+    )
 
 
 def validate_destination(
@@ -118,63 +116,76 @@ def validate_destination(
 
 @pytest.mark.asyncio
 @pytest.mark.tags(CONNECTOR_TYPE, DESTINATION_TAG, "sql")
-async def test_postgres_destination(upload_file: Path):
+async def test_postgres_destination(upload_file: Path, temp_dir: Path):
     # the postgres destination connector doesn't leverage the file data but is required as an input,
     # mocking it with arbitrary values to meet the base requirements:
     mock_file_data = FileData(identifier="mock file data", connector_type=CONNECTOR_TYPE)
     with docker_compose_context(
         docker_compose_path=env_setup_path / "sql" / "postgres" / "destination"
     ):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            stager = PostgresUploadStager()
-            stager_params = {
-                "elements_filepath": upload_file,
-                "file_data": mock_file_data,
-                "output_dir": Path(tmpdir),
-                "output_filename": "test_db",
-            }
-            if stager.is_async():
-                staged_path = await stager.run_async(**stager_params)
-            else:
-                staged_path = stager.run(**stager_params)
-
-            # The stager should append the `.json` suffix to the output filename passed in.
-            assert staged_path.name == "test_db.json"
-
-            connect_params = {
-                "host": "localhost",
-                "port": 5433,
-                "database": "elements",
-                "user": "unstructured",
-                "password": "test",
-            }
-
-            uploader = PostgresUploader(
-                connection_config=PostgresConnectionConfig(
-                    host=connect_params["host"],
-                    port=connect_params["port"],
-                    database=connect_params["database"],
-                    username=connect_params["user"],
-                    access_config=PostgresAccessConfig(password=connect_params["password"]),
-                )
-            )
+        stager = PostgresUploadStager()
+        staged_path = stager.run(
+            elements_filepath=upload_file,
+            file_data=mock_file_data,
+            output_dir=temp_dir,
+            output_filename=upload_file.name,
+        )
 
-            uploader.run(path=staged_path, file_data=mock_file_data)
+        # The stager should append the `.json` suffix to the output filename passed in.
+        assert staged_path.suffix == upload_file.suffix
 
-            staged_df = pd.read_json(staged_path, orient="records", lines=True)
-            sample_element = staged_df.iloc[0]
-            expected_num_elements = len(staged_df)
-            validate_destination(
-                connect_params=connect_params,
-                expected_num_elements=expected_num_elements,
-                expected_text=sample_element["text"],
-                test_embedding=sample_element["embeddings"],
-            )
+        connect_params = {
+            "host": "localhost",
+            "port": 5433,
+            "database": "elements",
+            "user": "unstructured",
+            "password": "test",
+        }
 
-            uploader.run(path=staged_path, file_data=mock_file_data)
-            validate_destination(
-                connect_params=connect_params,
-                expected_num_elements=expected_num_elements,
-                expected_text=sample_element["text"],
-                test_embedding=sample_element["embeddings"],
+        uploader = PostgresUploader(
+            connection_config=PostgresConnectionConfig(
+                host=connect_params["host"],
+                port=connect_params["port"],
+                database=connect_params["database"],
+                username=connect_params["user"],
+                access_config=PostgresAccessConfig(password=connect_params["password"]),
             )
+        )
+        uploader.precheck()
+        uploader.run(path=staged_path, file_data=mock_file_data)
+
+        with staged_path.open("r") as f:
+            staged_data = json.load(f)
+
+        sample_element = staged_data[0]
+        expected_num_elements = len(staged_data)
+        validate_destination(
+            connect_params=connect_params,
+            expected_num_elements=expected_num_elements,
+            expected_text=sample_element["text"],
+            test_embedding=sample_element["embeddings"],
+        )
+
+        uploader.run(path=staged_path, file_data=mock_file_data)
+        validate_destination(
+            connect_params=connect_params,
+            expected_num_elements=expected_num_elements,
+            expected_text=sample_element["text"],
+            test_embedding=sample_element["embeddings"],
+        )
+
+
+@pytest.mark.parametrize("upload_file_str", ["upload_file_ndjson", "upload_file"])
+def test_postgres_stager(
+    request: TopRequest,
+    upload_file_str: str,
+    tmp_path: Path,
+):
+    upload_file: Path = request.getfixturevalue(upload_file_str)
+    stager = PostgresUploadStager()
+    stager_validation(
+        configs=StagerValidationConfigs(test_id=CONNECTOR_TYPE, expected_count=22),
+        input_file=upload_file,
+        stager=stager,
+        tmp_dir=tmp_path,
+    )