pyapiary 2.1.4__tar.gz → 2.2.0__tar.gz

{pyapiary-2.1.4 → pyapiary-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyapiary
-Version: 2.1.4
+Version: 2.2.0
 Summary: A simple, lightweight set of connectors and functions to various APIs and DBMSs, controlled by a central broker.
 Author: Rob D'Aveta
 Author-email: rob.daveta@gmail.com
@@ -14,6 +14,9 @@ Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: odbc
 Requires-Dist: elasticsearch (>=9.1.1,<10.0.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: psycopg-binary (>=3.3.4,<4.0.0)
+Requires-Dist: psycopg-pool[binary,pool] (>=3.3.1,<4.0.0)
+Requires-Dist: psycopg[pool] (>=3.3.4,<4.0.0)
 Requires-Dist: pymongo (>=4.15.0,<5.0.0)
 Requires-Dist: pyodbc (>=5.3.0,<6.0.0) ; extra == "odbc"
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
@@ -355,6 +358,16 @@ results = conn.query("search index=_internal | head 5")
 pytest -m integration
 ```
 
+
+### Manual Testing
+- Located in dev_env
+- Do not use pytest or mocking
+- run the docker-compose.yaml to stand up services, change directories into the folder in dev_env you wish to test
+- execute the following to test your module
+```
+poetry run python <your test file here>.py
+```
+
 ### 🧼 Suppress warnings
 
 Add this to `pytest.ini`:

{pyapiary-2.1.4 → pyapiary-2.2.0}/README.md

@@ -330,6 +330,16 @@ results = conn.query("search index=_internal | head 5")
 pytest -m integration
 ```
 
+
+### Manual Testing
+- Located in dev_env
+- Do not use pytest or mocking
+- run the docker-compose.yaml to stand up services, change directories into the folder in dev_env you wish to test
+- execute the following to test your module
+```
+poetry run python <your test file here>.py
+```
+
 ### 🧼 Suppress warnings
 
 Add this to `pytest.ini`:

{pyapiary-2.1.4 → pyapiary-2.2.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "pyapiary"
 packages = [{ include = "pyapiary", from = "src" }]
-version = "2.1.4"
+version = "2.2.0"
 description = "A simple, lightweight set of connectors and functions to various APIs and DBMSs, controlled by a central broker."
 authors = ["Rob D'Aveta <rob.daveta@gmail.com>"]
 readme = "README.md"
@@ -17,6 +17,9 @@ splunk-sdk = "^2.1.1"
 httpx = "^0.28.1"
 tenacity = "^9.1.2"
 pyodbc = "^5.3.0"
+psycopg-pool = {extras = ["binary", "pool"], version = "^3.3.1"}
+psycopg = {extras = ["pool"], version = "^3.3.4"}
+psycopg-binary = "^3.3.4"
 
 [tool.poetry.extras]
 odbc = ["pyodbc"]

{pyapiary-2.1.4 → pyapiary-2.2.0}/src/pyapiary/api_connectors/ipqs.py

@@ -36,6 +36,19 @@ class IPQSConnector(Broker):
         """
         return self.post("/url/", data={"url": query, "key": self.api_key, **kwargs})
 
+    @log_method_call
+    def phone_validation(self, query: str, **kwargs) -> httpx.Response:
+        """The IPQS Phone Number Validation API offers rapid analysis to determine the risk core,
+        country of origin, carrier, validity, owner information, and connection status of phone numbers
+
+        Args:
+            query (str): The phone number to look up.
+
+        Returns:
+            httpx.Response: the httpx.Response object
+        """
+        return self.post("/phone/", data={"phone": query, "key": self.api_key, **kwargs})
+
 
 @bubble_broker_init_signature()
 class AsyncIPQSConnector(AsyncBroker):
@@ -63,3 +76,16 @@ class AsyncIPQSConnector(AsyncBroker):
             httpx.Response: the httpx.Response object
         """
         return await self.post("/url/", data={"url": query, "key": self.api_key, **kwargs})
+
+    @log_method_call
+    async def phone_validation(self, query: str, **kwargs) -> httpx.Response:
+        """The IPQS Phone Number Validation API offers rapid analysis to determine the risk core,
+        country of origin, carrier, validity, owner information, and connection status of phone numbers
+
+        Args:
+            query (str): The phone number to look up.
+
+        Returns:
+            httpx.Response: the httpx.Response object
+        """
+        return await self.post("/phone/", data={"phone": query, "key": self.api_key, **kwargs})

pyapiary-2.2.0/src/pyapiary/dbms_connectors/postgres.py

@@ -0,0 +1,104 @@
+from typing import List, Dict, Any, Optional, Generator, Type, Union 
+from types import TracebackType
+from pyapiary.helpers import setup_logger
+from psycopg_pool import AsyncConnectionPool, ConnectionPool
+
+class PostgresConnector:
+    def __init__(self,conn_str, logger=None, min_size=5, max_size=30):
+        self.dsn = conn_str
+        self.min_size = min_size
+        self.max_size = max_size
+        self.connection_pool = ConnectionPool(self.dsn, kwargs={"autocommit":True}, min_size=self.min_size, max_size=self.max_size)
+        self.logger = logger if logger else setup_logger(__name__)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def close(self):
+        """Close the PG connection."""
+        if self.connection_pool:
+            self.connection_pool.close()
+            self._log("PG connection closed")
+
+    def _log(self, msg: str, level: str = "info"):
+        if self.logger:
+            log_method = getattr(self.logger, level, self.logger.info)
+            log_method(msg)  
+
+    def query(self, query: str, params=None):
+        """
+        query - string query representing the work the user wants done
+        params - must be legal for psycopog_pool AsyncConnectionPool object
+        https://www.psycopg.org/psycopg3/docs/api/pool.html#module-psycopg_pool
+        """
+        with self.connection_pool.connection() as conn:
+            with conn.transaction():
+                # claude recommended a transaction wrapper here
+                return conn.execute(query, params).fetchall()
+
+    def bulk_insert(self, table: str, data: List[Dict[str, Any]]):
+        if not data:
+            return
+    
+        self._log(f"Inserting {len(data)} rows into table {table}")
+    
+        columns = list(data[0].keys())
+        copy_query = f"COPY {table} ({', '.join(columns)}) FROM STDIN"
+    
+        with self.connection_pool.connection() as conn:
+            with conn.cursor() as cur:
+                with cur.copy(copy_query) as copy:
+                    for row in data:
+                        copy.write_row(tuple(row[col] for col in columns))
+                        # Note: pool is configured for autocommit, commit will happen before the with block ends
+
+# Async Version 
+## Need to write an async_bulk_insert
+class AsyncPostgresConnector:
+    def __init__(self,conn_str, min_size=5, max_size=30, logger=None):
+        self.dsn = conn_str
+        self.min_size = min_size
+        self.max_size = max_size
+        self.connection_pool = AsyncConnectionPool(self.dsn, kwargs={"autocommit":True}, min_size=self.min_size, max_size=self.max_size, open=False)
+        self.logger = logger if logger else setup_logger(__name__)
+
+    async def __aenter__(self):
+        # for async with calls
+        await self.connection_pool.open()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        # for async with calls
+        await self.connection_pool.close()   
+
+    async def async_query(self, query: str, params=None):
+        """
+        query - string query representing the work the user wants done
+        params - must be legal for psycopog_pool AsyncConnectionPool object
+        https://www.psycopg.org/psycopg3/docs/api/pool.html#module-psycopg_pool
+        """
+        async with self.connection_pool.connection() as conn:
+            cur = await conn.execute(query, params)
+            return await cur.fetchall()
+
+    async def async_bulk_insert(self, table_name: str, data: List[Dict[str, Any]]):
+        if not data:
+            return
+    
+        columns = list(data[0].keys())
+
+        # Google recommended using an cursor.copy command here to process the dict, better performance over a high volume of rows, more efficient
+        # than the odbc write/execute_many paradigm.        
+        async with self.connection_pool.connection() as aconn:
+            async with aconn.cursor() as acur:
+                # using COPY is the most performative for millions of rows
+                copy_query = f"COPY {table_name} ({', '.join(columns)}) FROM STDIN"
+                
+                async with acur.copy(copy_query) as copy:
+                    for record in data:
+                        row = tuple(record[col] for col in columns)
+                        await copy.write_row(row)
+                        # Note: since asyncpool passes autocommit kwarg, commits will happen before the with block ends

pyapiary-2.2.0/src/pyapiary/tests/test_ipqs/cassettes/test_ipqs_phone_validation_vcr.yaml

@@ -0,0 +1,70 @@
+interactions:
+- request:
+    body: phone=12024567041&key=HOwg8USe8QTBYpdxDEnfAqWZeb0kpAuQ
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '54'
+      content-type:
+      - application/x-www-form-urlencoded
+      host:
+      - www.ipqualityscore.com
+      user-agent:
+      - REDACTED
+    method: POST
+    uri: https://www.ipqualityscore.com/api/json/phone/
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAA/1VUXW/iOBT9K1aedjUM03a7s1KfcAE12aGBSaBVtbOKjGOIi2NnbYcqM+p/3+NA
+        aXmJcu+5Pvf7/opq4RzbiugmWlRGCyId2TMly2E0iFzLOeDoxttWDKKNsTXzXpQw/nR5dXF1/efX
+        vy6uL2GpDGeqOBgA/Q3g7wTw5yPeU554LGvLwnFj4fZiEFnBhfYFW7cOig1TDkYP82RxEhorGhYI
+        dKsUHki3604g417uxRs5Z9ZKYRHEg7Dyp9FkbOq61ZIzL412IVipReG7JiQ9Y7oMMtTctNpb8Ear
+        PIjSh/9HmsdJerecp9D9lE3BTRkeXl1c/PE1CsFvQQvFZAyplEhUb49Gl2/BFc4z36KQEe1lMoNL
+        8pnEclshPr2RpdA8BOFqV5SmZjJQpj++UOiYc4ZLhsIXAogqWFla9EWA8Ff0Tn0yI72ZIxtk1Dfy
+        IEc3/4QAjVDSi9E26Ibc1MAb1irwWOnZqHWleR5uzR76Z+NEU72gpEKfARZl69bCbv9rpfPnkFnr
+        TgE/84C2qBEv2V6WzmipXQsKLo7os3QVa6Q1o45Vxhy1O8meTaVhf+bAV6iP0w1TwtbmzEvJNFvb
+        1vHzNBSDtx1rENWZfiuM3QrHqxapnGfBKwyZ716k2IZUPkIbBN65GlPVjZhRpxR05yqpR5XZOG/Z
+        UJRt9O/rIMJQ26Ifg8NATbUXtgE7puD6E7ECJbSib1Ot+XvXa/5BUILtxGmBXMPqOsz4cQMCh3C+
+        CBuCLZXXfvfw8lThnWZ1GNa76Ty7m5LbVR4PyIKuZiRf0ixZ0gH5e55PFzF5pFk2TQcko+nkidxO
+        s7vvqyRfQjG/JenTDOoBGdNsRib0IZnk8zQ8TekypinJY7pIsnnQxCkg8i0B8zKe39Mc7mbT7B7g
+        hKaU3GarfAxwRlcZJd/oAswDcowvH8cruIbXcZzB+xN5TKZ3vetHfCnJ75MlMoC/x5Tcr7JF/ASn
+        SYggCfvpZS2w8iFligJh5398mQi9R60wHKbQxhc4VOpUOc8bVqwV4zuFdn84KRwT40VxvAnHfT6i
+        YUf7jXrvj25rjFCBS9bxcADCYr5f1rRHyQklG4GdtYKU0rG1QvPJAh3GRHCjPWaFuLZpjPXEG9KP
+        DmIZRm+XUnVHR+J0ERVD+8ML3IgSxm/6g+ogvb7+D6arKrXuBQAA
+    headers:
+      CF-RAY:
+      - 9e51976b889d98d5-ATL
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 31 Mar 2026 18:59:29 GMT
+      Nel:
+      - '{"report_to":"cf-nel","success_fraction":0.0,"max_age":604800}'
+      Report-To:
+      - '{"group":"cf-nel","max_age":604800,"endpoints":[{"url":"https://a.nel.cloudflare.com/report/v4?s=MNIXz1eWc6WlUYSlvt%2FrHoZ5QQ62jQe%2BvrW%2B0dRfxNJU4OAh9YKgXohdqxSO3ED9eYP2ynVDPg4y7nwpTZdHvmVi8GcVjKsApuuMnMiWLjJXwliCb5Yq22rBsNTixyO5F%2BrJesPFCuc%3D"}]}'
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-LB-ID:
+      - LB-3
+      X-Powered-By:
+      - IPQualityScore
+      X-Upstream-ID:
+      - N-152
+      cf-cache-status:
+      - DYNAMIC
+    status:
+      code: 200
+      message: OK
+version: 1

pyapiary-2.2.0/src/pyapiary/tests/test_ipqs/test_integration_ipqs.py

@@ -0,0 +1,24 @@
+import httpx
+import pytest
+from pyapiary.api_connectors.ipqs import IPQSConnector
+
+@pytest.mark.integration
+def test_ipqs_malicious_url_vcr(vcr_cassette):
+    with vcr_cassette.use_cassette("test_ipqs_malicious_url_vcr"):
+        connector = IPQSConnector(load_env_vars=True, enable_logging=True)
+        result = connector.malicious_url("github.com")
+
+        assert isinstance(result, httpx.Response)
+        assert "domain" in result.json()
+        assert result.json()["domain"] == "github.com"
+
+
+@pytest.mark.integration
+def test_ipqs_phone_validation_vcr(vcr_cassette):
+    with vcr_cassette.use_cassette("test_ipqs_phone_validation_vcr"):
+        connector = IPQSConnector(load_env_vars=True, enable_logging=True)
+        result = connector.phone_validation("+12024567041")
+
+        assert isinstance(result, httpx.Response)
+        assert "formatted" in result.json()
+        assert result.json()["formatted"] == "+12024567041"

{pyapiary-2.1.4 → pyapiary-2.2.0}/src/pyapiary/tests/test_ipqs/test_unit_async_ipqs.py

@@ -51,3 +51,30 @@ async def test_async_malicious_url(mock_post):
         "/url/",
         data={"url": "example.com", "key": "test_key", "strictness": 1}
     )
+
+
+@patch("pyapiary.api_connectors.ipqs.AsyncIPQSConnector.post", new_callable=AsyncMock)
+@pytest.mark.asyncio
+async def test_async_phone_validation(mock_post):
+    import json
+
+    request = httpx.Request("POST", "https://www.ipqualityscore.com/api/json/url/")
+    payload = {"success": True, "phone": "8888888888"}
+    mock_response = httpx.Response(
+        200,
+        request=request,
+        content=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    mock_post.return_value = mock_response
+
+    connector = AsyncIPQSConnector(api_key="test_key")
+    response = await connector.phone_validation("8888888888", strictness=1)
+
+    assert isinstance(response, httpx.Response)
+    assert response.status_code == 200
+    assert response.json() == payload
+    mock_post.assert_awaited_once_with(
+        "/phone/",
+        data={"phone": "8888888888", "key": "test_key", "strictness": 1}
+    )

{pyapiary-2.1.4 → pyapiary-2.2.0}/src/pyapiary/tests/test_ipqs/test_unit_ipqs.py

@@ -46,3 +46,29 @@ def test_malicious_url(mock_post):
     )
     assert isinstance(result, httpx.Response)
     assert result.json() == payload
+
+
+@patch("pyapiary.api_connectors.ipqs.IPQSConnector.post")
+def test_phone_validation(mock_post):
+    # Build a real httpx.Response to match the new return type
+    import json
+
+    request = httpx.Request("POST", "https://www.ipqualityscore.com/api/json/phone/")
+    payload = {"success": True, "phone": "8888888888"}
+    mock_response = httpx.Response(
+        200,
+        request=request,
+        content=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    mock_post.return_value = mock_response
+
+    connector = IPQSConnector(api_key="test_key")
+    result = connector.phone_validation("8888888888")
+
+    mock_post.assert_called_once_with(
+        "/phone/",
+        data={"phone": "8888888888", "key": "test_key"},
+    )
+    assert isinstance(result, httpx.Response)
+    assert result.json() == payload

pyapiary-2.2.0/src/pyapiary/tests/test_postgres/test_unit_postgres.py

@@ -0,0 +1,259 @@
+import sys
+from unittest.mock import MagicMock, AsyncMock, patch
+
+import pytest
+
+# Mock psycopg_pool before importing the module so tests run even when the
+# driver is not installed in the environment.
+sys.modules.setdefault("psycopg_pool", MagicMock())
+
+from pyapiary.dbms_connectors.postgres import PostgresConnector, AsyncPostgresConnector
+
+
+# ──────────────────────────────────────────────
+#  Sync PostgresConnector
+# ──────────────────────────────────────────────
+
+@pytest.fixture
+def pg():
+    with patch("pyapiary.dbms_connectors.postgres.ConnectionPool"):
+        yield PostgresConnector("postgresql://user:pass@localhost/testdb")
+
+
+class TestPostgresConnectorInit:
+    @patch("pyapiary.dbms_connectors.postgres.ConnectionPool")
+    def test_creates_pool_with_defaults(self, mock_pool):
+        conn = PostgresConnector("postgresql://localhost/db")
+        mock_pool.assert_called_once_with(
+            "postgresql://localhost/db",
+            kwargs={"autocommit": True},
+            min_size=5,
+            max_size=30,
+        )
+        assert conn.dsn == "postgresql://localhost/db"
+        assert conn.min_size == 5
+        assert conn.max_size == 30
+
+    @patch("pyapiary.dbms_connectors.postgres.ConnectionPool")
+    def test_creates_pool_with_custom_sizes(self, mock_pool):
+        conn = PostgresConnector("dsn", min_size=1, max_size=10)
+        mock_pool.assert_called_once_with(
+            "dsn",
+            kwargs={"autocommit": True},
+            min_size=1,
+            max_size=10,
+        )
+
+    @patch("pyapiary.dbms_connectors.postgres.ConnectionPool")
+    def test_accepts_custom_logger(self, mock_pool):
+        logger = MagicMock()
+        conn = PostgresConnector("dsn", logger=logger)
+        assert conn.logger is logger
+
+    @patch("pyapiary.dbms_connectors.postgres.ConnectionPool")
+    def test_uses_default_logger_when_none(self, mock_pool):
+        conn = PostgresConnector("dsn")
+        assert conn.logger is not None
+
+
+class TestPostgresConnectorContextManager:
+    def test_enter_returns_self(self, pg):
+        assert pg.__enter__() is pg
+
+    def test_exit_closes_pool(self, pg):
+        pg.__exit__(None, None, None)
+        pg.connection_pool.close.assert_called_once()
+
+
+class TestPostgresConnectorClose:
+    def test_close_closes_pool(self, pg):
+        pg.close()
+        pg.connection_pool.close.assert_called_once()
+
+    def test_close_when_pool_is_none(self, pg):
+        pg.connection_pool = None
+        pg.close()  # should not raise
+
+
+class TestPostgresConnectorQuery:
+    def test_query_returns_results(self, pg):
+        mock_conn = MagicMock()
+        mock_conn.execute.return_value.fetchall.return_value = [("row1",), ("row2",)]
+        pg.connection_pool.connection.return_value.__enter__ = MagicMock(return_value=mock_conn)
+        pg.connection_pool.connection.return_value.__exit__ = MagicMock(return_value=False)
+        mock_conn.transaction.return_value.__enter__ = MagicMock()
+        mock_conn.transaction.return_value.__exit__ = MagicMock(return_value=False)
+
+        result = pg.query("SELECT 1")
+        assert result == [("row1",), ("row2",)]
+        mock_conn.execute.assert_called_once_with("SELECT 1", None)
+
+    def test_query_passes_params(self, pg):
+        mock_conn = MagicMock()
+        mock_conn.execute.return_value.fetchall.return_value = []
+        pg.connection_pool.connection.return_value.__enter__ = MagicMock(return_value=mock_conn)
+        pg.connection_pool.connection.return_value.__exit__ = MagicMock(return_value=False)
+        mock_conn.transaction.return_value.__enter__ = MagicMock()
+        mock_conn.transaction.return_value.__exit__ = MagicMock(return_value=False)
+
+        pg.query("SELECT * FROM t WHERE id = %s", (42,))
+        mock_conn.execute.assert_called_once_with("SELECT * FROM t WHERE id = %s", (42,))
+
+
+class TestPostgresConnectorBulkInsert:
+    def test_empty_data_returns_immediately(self, pg):
+        pg.bulk_insert("my_table", [])
+        pg.connection_pool.connection.assert_not_called()
+
+    def test_bulk_insert_calls_copy(self, pg):
+        mock_copy = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.copy.return_value.__enter__ = MagicMock(return_value=mock_copy)
+        mock_cursor.copy.return_value.__exit__ = MagicMock(return_value=False)
+
+        mock_conn = MagicMock()
+        mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
+
+        pg.connection_pool.connection.return_value.__enter__ = MagicMock(return_value=mock_conn)
+        pg.connection_pool.connection.return_value.__exit__ = MagicMock(return_value=False)
+
+        data = [{"name": "alice", "age": 30}, {"name": "bob", "age": 25}]
+        pg.bulk_insert("users", data)
+
+        mock_cursor.copy.assert_called_once_with("COPY users (name, age) FROM STDIN")
+        assert mock_copy.write_row.call_count == 2
+        mock_copy.write_row.assert_any_call(("alice", 30))
+        mock_copy.write_row.assert_any_call(("bob", 25))
+
+
+class TestPostgresConnectorLog:
+    def test_log_default_level(self, pg):
+        pg.logger = MagicMock()
+        pg._log("test message")
+        pg.logger.info.assert_called_once_with("test message")
+
+    def test_log_custom_level(self, pg):
+        pg.logger = MagicMock()
+        pg._log("warning msg", level="warning")
+        pg.logger.warning.assert_called_once_with("warning msg")
+
+    def test_log_falls_back_to_info(self, pg):
+        pg.logger = MagicMock(spec=["info"])
+        pg.logger.info = MagicMock()
+        pg._log("msg", level="nonexistent")
+        pg.logger.info.assert_called_once_with("msg")
+
+
+# ──────────────────────────────────────────────
+#  Async AsyncPostgresConnector
+# ──────────────────────────────────────────────
+
+@pytest.fixture
+def async_pg():
+    with patch("pyapiary.dbms_connectors.postgres.AsyncConnectionPool"):
+        yield AsyncPostgresConnector("postgresql://user:pass@localhost/testdb")
+
+
+class TestAsyncPostgresConnectorInit:
+    @patch("pyapiary.dbms_connectors.postgres.AsyncConnectionPool")
+    def test_creates_pool_with_defaults(self, mock_pool):
+        conn = AsyncPostgresConnector("postgresql://localhost/db")
+        mock_pool.assert_called_once_with(
+            "postgresql://localhost/db",
+            kwargs={"autocommit": True},
+            min_size=5,
+            max_size=30,
+            open=False,
+        )
+        assert conn.dsn == "postgresql://localhost/db"
+
+    @patch("pyapiary.dbms_connectors.postgres.AsyncConnectionPool")
+    def test_creates_pool_with_custom_sizes(self, mock_pool):
+        conn = AsyncPostgresConnector("dsn", min_size=2, max_size=20)
+        mock_pool.assert_called_once_with(
+            "dsn",
+            kwargs={"autocommit": True},
+            min_size=2,
+            max_size=20,
+            open=False,
+        )
+
+
+class TestAsyncPostgresConnectorContextManager:
+    @pytest.mark.asyncio
+    async def test_aenter_opens_pool(self, async_pg):
+        async_pg.connection_pool.open = AsyncMock()
+        result = await async_pg.__aenter__()
+        assert result is async_pg
+        async_pg.connection_pool.open.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_aexit_closes_pool(self, async_pg):
+        async_pg.connection_pool.close = AsyncMock()
+        await async_pg.__aexit__(None, None, None)
+        async_pg.connection_pool.close.assert_awaited_once()
+
+
+class TestAsyncPostgresConnectorQuery:
+    @pytest.mark.asyncio
+    async def test_async_query_returns_results(self, async_pg):
+        mock_cursor = AsyncMock()
+        mock_cursor.fetchall.return_value = [("row1",)]
+
+        mock_conn = AsyncMock()
+        mock_conn.execute.return_value = mock_cursor
+
+        async_cm = AsyncMock()
+        async_cm.__aenter__.return_value = mock_conn
+        async_pg.connection_pool.connection.return_value = async_cm
+
+        result = await async_pg.async_query("SELECT 1")
+        assert result == [("row1",)]
+        mock_conn.execute.assert_awaited_once_with("SELECT 1", None)
+
+    @pytest.mark.asyncio
+    async def test_async_query_passes_params(self, async_pg):
+        mock_cursor = AsyncMock()
+        mock_cursor.fetchall.return_value = []
+
+        mock_conn = AsyncMock()
+        mock_conn.execute.return_value = mock_cursor
+
+        async_cm = AsyncMock()
+        async_cm.__aenter__.return_value = mock_conn
+        async_pg.connection_pool.connection.return_value = async_cm
+
+        await async_pg.async_query("SELECT * FROM t WHERE id = %s", (1,))
+        mock_conn.execute.assert_awaited_once_with("SELECT * FROM t WHERE id = %s", (1,))
+
+
+class TestAsyncPostgresConnectorBulkInsert:
+    @pytest.mark.asyncio
+    async def test_empty_data_returns_immediately(self, async_pg):
+        await async_pg.async_bulk_insert("my_table", [])
+        async_pg.connection_pool.connection.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_async_bulk_insert_calls_copy(self, async_pg):
+        mock_copy = AsyncMock()
+
+        mock_cursor = MagicMock()
+        mock_cursor.copy.return_value.__aenter__ = AsyncMock(return_value=mock_copy)
+        mock_cursor.copy.return_value.__aexit__ = AsyncMock(return_value=False)
+
+        mock_conn = MagicMock()
+        mock_conn.cursor.return_value.__aenter__ = AsyncMock(return_value=mock_cursor)
+        mock_conn.cursor.return_value.__aexit__ = AsyncMock(return_value=False)
+
+        async_cm = AsyncMock()
+        async_cm.__aenter__.return_value = mock_conn
+        async_pg.connection_pool.connection.return_value = async_cm
+
+        data = [{"name": "alice", "age": 30}, {"name": "bob", "age": 25}]
+        await async_pg.async_bulk_insert("users", data)
+
+        mock_cursor.copy.assert_called_once_with("COPY users (name, age) FROM STDIN")
+        assert mock_copy.write_row.await_count == 2
+        mock_copy.write_row.assert_any_await(("alice", 30))
+        mock_copy.write_row.assert_any_await(("bob", 25))

pyapiary-2.1.4/src/pyapiary/tests/test_ipqs/test_integration_ipqs.py

@@ -1,13 +0,0 @@
-import httpx
-import pytest
-from pyapiary.api_connectors.ipqs import IPQSConnector
-
-@pytest.mark.integration
-def test_ipqs_malicious_url_vcr(vcr_cassette):
-    with vcr_cassette.use_cassette("test_ipqs_malicious_url_vcr"):
-        connector = IPQSConnector(load_env_vars=True, enable_logging=True)
-        result = connector.malicious_url("github.com")
-
-        assert isinstance(result, httpx.Response)
-        assert "domain" in result.json()
-        assert result.json()["domain"] == "github.com"