sefrone-api-e2e 1.3.8__tar.gz → 1.4.0__tar.gz

{sefrone_api_e2e-1.3.8 → sefrone_api_e2e-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sefrone_api_e2e
-Version: 1.3.8
+Version: 1.4.0
 Summary: A Python package to provide e2e testing helpers for sefrone API projects
 Home-page: https://bitbucket.org/sefrone/sefrone_pypi
 Author: Sefrone

{sefrone_api_e2e-1.3.8 → sefrone_api_e2e-1.4.0}/sefrone_api_e2e/__init__.py

@@ -7,6 +7,8 @@ from .runner_assets import AssetsRunner
 from .runner_satim_mock import SatimMockRunner
 from .runner_csv import CsvRunner
 from .runner_excel import ExcelRunner
+from .runner_postgresql import PostgresqlRunner
+from .runner_mysql import MysqlRunner
 from .json_mock_server import JsonMockServer
 from .e2e_scenarios_manager import E2EScenariosManager
 
@@ -23,6 +25,8 @@ __all__ = [
     "SatimMockRunner",
     "CsvRunner",
     "ExcelRunner",
+    "PostgresqlRunner",
+    "MysqlRunner",
     "JsonMockServer",
     "E2EScenariosManager",
 ]

{sefrone_api_e2e-1.3.8 → sefrone_api_e2e-1.4.0}/sefrone_api_e2e/e2e/Scenarios/Auth/4_workspace_endpoints.yaml

@@ -19,36 +19,15 @@ steps:
       body:
         response:
           token: string
+          projectId: string
     save:
       admin_token: "{{body.response.token}}"
+      seed_project_id: "{{body.response.projectId}}"
 
   - name: "Generate unique test suffix"
     randomize:
       seed_account_id: 8
 
-  - name: "List workspaces to obtain project ID"
-    method: "GET"
-    endpoint: "/api/v1/apiAuth/workspace/$var(AUTH_PROJECT_NAME)/list"
-    request_headers:
-      - x-api-token: "{$stored.admin_token}"
-    expect:
-      status: 200
-      body:
-        errorCode: number
-        errorCodeStr: string
-        message: string
-        totalCount: number
-        response:
-          - id: string
-            projectId: string
-            name: string
-            description: string
-            isActive: boolean
-    save:
-      seed_project_id: "{{body.response[0].projectId}}"
-    assertions:
-      - "{{body.totalCount}} >= 1"
-
   - name: "Create new workspace"
     method: "POST"
     endpoint: "/api/v1/apiAuth/workspace"

sefrone_api_e2e-1.4.0/sefrone_api_e2e/runner_mysql.py

@@ -0,0 +1,247 @@
+import time
+from typing import Any, Dict, Optional
+
+from sefrone_api_e2e import StepRunner, RunContext, StepResult
+
+# mysql-connector-python is an optional, bootstrap-installed dependency — only pulled
+# in by setup() below, so importing this module (e.g. via package __init__) never
+# installs it for consumers who never register MysqlRunner.
+mysql = None
+
+
+class MysqlRunner(StepRunner):
+    """
+    Runner for direct SQL access to the e2e MySQL database, for state a scenario can't reach or
+    observe through the HTTP API alone (fast-forwarding a due-date column, asserting a background
+    job wrote back the row it was supposed to, seeding data too tedious to build through endpoints).
+
+    Takes a ready-made MySqlConnector/Pomelo-style connection string via the constructor —
+    typically the caller's own SCAFFOLD_DB_CONNECTION_STRING value from the e2e .env file, the same
+    host-reachable connection string the EF Core scaffold tool uses for repos on
+    Pomelo.EntityFrameworkCore.MySql, already pointed at the docker-exposed port (see
+    DB_IMAGE_PORT_MAPPING in compose-template/.env). Nothing needs to be patched or injected into
+    docker-compose.yml; the database is already reachable from the host once DB_SERVICE is up.
+
+    Step syntax — execute (INSERT/UPDATE/DELETE, no result rows)::
+
+        - name: "Fast-forward the no-product reminder due date"
+          runner: mysql
+          mysql:
+            action: execute
+            statement: >
+              UPDATE store_reminder SET remind_at = NOW() - INTERVAL 1 MINUTE
+              WHERE store_id = '{$stored.store_id}' AND type = 'no_product'
+            expect_rows_affected: 1     # optional — fails the step if rowcount doesn't match
+
+    Step syntax — query (SELECT, populates {{mysql.*}} for assertions/save)::
+
+        - name: "Verify the reminder was marked sent"
+          runner: mysql
+          mysql:
+            action: query
+            statement: >
+              SELECT remind_at, sent_at FROM store_reminder
+              WHERE store_id = '{$stored.store_id}' AND type = 'no_product'
+          assertions:
+            - "{{mysql.row_count}} == 1"
+            - "{{mysql.rows[0].sent_at}} != None"
+          save:
+            reminder_sent_at: "{{mysql.rows[0].sent_at}}"
+
+    ``{$stored...}`` / ``{{...}}`` placeholders in ``statement`` are substituted before the
+    statement reaches MySQL — quote substituted values yourself (as in the examples above) the
+    same way you would in an HTTP step's body.
+
+    ``mysql.rows`` is a list of dicts keyed by column name; timestamps/decimals/etc. come back as
+    their native Python types (via mysql-connector-python), matching how the driver would hand them
+    to any other caller — stringify explicitly in an assertion/save expression if you need string
+    comparison.
+    """
+
+    def __init__(self, connection_string: str):
+        if not connection_string or not connection_string.strip():
+            raise ValueError("MysqlRunner requires a non-empty connection_string")
+        self._connect_kwargs = self._parse_connection_string(connection_string)
+
+    @property
+    def name(self) -> str:
+        return "mysql"
+
+    def handles(self, step: dict) -> bool:
+        return "mysql" in step and "method" not in step
+
+    # ------------------------------------------------------------------ #
+    #  Lifecycle
+    # ------------------------------------------------------------------ #
+
+    def setup(self, env_file_path: str) -> None:
+        global mysql
+        from sefrone_bootstrap.bootstrap_package import PackageManager
+        PackageManager.setup([("mysql-connector-python", "8.4.0")])
+        import mysql.connector
+
+        self._wait_for_db_ready()
+
+    def teardown(self) -> None:
+        pass  # each execute() opens and closes its own short-lived connection.
+
+    # ------------------------------------------------------------------ #
+    #  Execute
+    # ------------------------------------------------------------------ #
+
+    def execute(self, step: dict, ctx: RunContext) -> StepResult:
+        try:
+            spec = step.get("mysql")
+            if not isinstance(spec, dict):
+                return StepResult.failed("mysql step requires a 'mysql' object")
+
+            action = str(spec.get("action", "query")).strip().lower()
+            statement = spec.get("statement")
+            if not isinstance(statement, str) or not statement.strip():
+                return StepResult.failed("mysql.statement is required and must be a non-empty string")
+
+            rendered_statement = ctx.substitute_stored(statement)
+
+            if action == "execute":
+                return self._execute(step, rendered_statement)
+            if action == "query":
+                return self._query(step, spec, rendered_statement, ctx)
+
+            return StepResult.failed(f"Unsupported mysql action: '{action}'. Supported: 'execute', 'query'")
+        except AssertionError as e:
+            return StepResult.failed(str(e))
+        except Exception as e:
+            return StepResult.failed(str(e))
+
+    def _execute(self, step: dict, statement: str) -> StepResult:
+        conn = mysql.connector.connect(**self._connect_kwargs)
+        try:
+            conn.autocommit = True
+            cur = conn.cursor()
+            try:
+                cur.execute(statement)
+                row_count = cur.rowcount
+            finally:
+                cur.close()
+        finally:
+            conn.close()
+
+        spec = step.get("mysql", {})
+        if "expect_rows_affected" in spec:
+            expected = int(spec["expect_rows_affected"])
+            if row_count != expected:
+                return StepResult.failed(
+                    f"Expected {expected} row(s) affected, got {row_count}. Statement: {statement}"
+                )
+
+        print(f"[mysql] Executed ({row_count} row(s) affected): {statement}")
+        return StepResult.passed()
+
+    def _query(self, step: dict, spec: Dict[str, Any], statement: str, ctx: RunContext) -> StepResult:
+        conn = mysql.connector.connect(**self._connect_kwargs)
+        try:
+            conn.autocommit = True
+            cur = conn.cursor(dictionary=True)
+            try:
+                cur.execute(statement)
+                rows = list(cur.fetchall())
+            finally:
+                cur.close()
+        finally:
+            conn.close()
+
+        print(f"[mysql] Queried ({len(rows)} row(s)): {statement}")
+
+        template_context: Dict[str, Any] = {
+            "mysql": {
+                "rows": rows,
+                "row_count": len(rows),
+            }
+        }
+
+        if "assertions" in step:
+            for expr in step["assertions"]:
+                try:
+                    rendered_expr = ctx.substitute_stored(expr)
+                    rendered = ctx.render_template(rendered_expr, template_context, add_quotes=True)
+                    ctx.try_eval(rendered, rendered_expr)
+                except Exception as e:
+                    raise AssertionError(f"Assertion failed for expression\n    -->'{expr}'\n    -->{e}")
+
+        if "save" in step:
+            for key, path_expr in step["save"].items():
+                rendered_path = ctx.substitute_stored(str(path_expr))
+                rendered = ctx.render_template(rendered_path, template_context)
+                ctx.store_value(key, rendered)
+
+        return StepResult.passed()
+
+    # ------------------------------------------------------------------ #
+    #  Internal helpers
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def _parse_connection_string(raw: str) -> Dict[str, Any]:
+        """
+        Parse a MySqlConnector/Pomelo-style 'Key=Value;Key=Value;' connection string (as produced
+        by compose-template/.env's SCAFFOLD_DB_CONNECTION_STRING) into mysql-connector-python
+        connect() kwargs. Accepts the common key aliases MySqlConnector recognizes for each field.
+        """
+        fields: Dict[str, str] = {}
+        for part in raw.split(";"):
+            part = part.strip()
+            if not part or "=" not in part:
+                continue
+            key, _, value = part.partition("=")
+            fields[key.strip().lower()] = value.strip()
+
+        def first(*keys: str) -> Optional[str]:
+            for key in keys:
+                if key in fields:
+                    return fields[key]
+            return None
+
+        host = first("server", "host", "data source")
+        database = first("database", "initial catalog")
+        user = first("user", "uid", "user id", "username")
+        password = first("password", "pwd")
+        port = first("port")
+
+        missing = [
+            name for name, value in [("server/host", host), ("database", database), ("user/uid", user), ("password/pwd", password)]
+            if value is None
+        ]
+        if missing:
+            raise RuntimeError(f"[mysql] Connection string missing expected key(s) {missing}: '{raw}'")
+
+        return {
+            "host": host,
+            "port": int(port) if port else 3306,
+            "database": database,
+            "user": user,
+            "password": password,
+        }
+
+    def _wait_for_db_ready(self, timeout_seconds: int = 30) -> None:
+        deadline = time.time() + timeout_seconds
+        last_error: Optional[Exception] = None
+        while time.time() < deadline:
+            conn = None
+            try:
+                conn = mysql.connector.connect(**self._connect_kwargs)
+                cur = conn.cursor()
+                try:
+                    cur.execute("SELECT 1")
+                finally:
+                    cur.close()
+                print(f"[mysql] Database ready at {self._connect_kwargs['host']}:{self._connect_kwargs['port']}")
+                return
+            except Exception as e:
+                last_error = e
+                time.sleep(1)
+            finally:
+                if conn is not None:
+                    conn.close()
+        raise RuntimeError(
+            f"[mysql] Database did not become ready within {timeout_seconds}s: {last_error}"
+        )

sefrone_api_e2e-1.4.0/sefrone_api_e2e/runner_postgresql.py

@@ -0,0 +1,220 @@
+import time
+from typing import Any, Dict, Optional
+
+from sefrone_api_e2e import StepRunner, RunContext, StepResult
+
+# psycopg2 is an optional, bootstrap-installed dependency — only pulled in by setup()
+# below, so importing this module (e.g. via package __init__) never installs it for
+# consumers who never register PostgresqlRunner.
+psycopg2 = None
+
+
+class PostgresqlRunner(StepRunner):
+    """
+    Runner for direct SQL access to the e2e Postgres database, for state a scenario can't reach or
+    observe through the HTTP API alone (fast-forwarding a due-date column, asserting a background
+    job wrote back the row it was supposed to, seeding data too tedious to build through endpoints).
+
+    Takes a ready-made Npgsql-style connection string via the constructor — typically the caller's
+    own SCAFFOLD_DB_CONNECTION_STRING value from the e2e .env file, the same host-reachable
+    connection string the EF Core scaffold tool uses, already pointed at the docker-exposed port
+    (see DB_IMAGE_PORT_MAPPING in compose-template/.env). Nothing needs to be patched or injected
+    into docker-compose.yml; the database is already reachable from the host once DB_SERVICE is up.
+
+    Step syntax — execute (INSERT/UPDATE/DELETE, no result rows)::
+
+        - name: "Fast-forward the no-product reminder due date"
+          runner: postgresql
+          postgresql:
+            action: execute
+            statement: >
+              UPDATE store_reminder SET remind_at = NOW() - INTERVAL '1 minute'
+              WHERE store_id = '{$stored.store_id}' AND type = 'no_product'
+            expect_rows_affected: 1     # optional — fails the step if rowcount doesn't match
+
+    Step syntax — query (SELECT, populates {{postgresql.*}} for assertions/save)::
+
+        - name: "Verify the reminder was marked sent"
+          runner: postgresql
+          postgresql:
+            action: query
+            statement: >
+              SELECT remind_at, sent_at FROM store_reminder
+              WHERE store_id = '{$stored.store_id}' AND type = 'no_product'
+          assertions:
+            - "{{postgresql.row_count}} == 1"
+            - "{{postgresql.rows[0].sent_at}} != None"
+          save:
+            reminder_sent_at: "{{postgresql.rows[0].sent_at}}"
+
+    ``{$stored...}`` / ``{{...}}`` placeholders in ``statement`` are substituted before the
+    statement reaches Postgres — quote substituted values yourself (as in the examples above) the
+    same way you would in an HTTP step's body.
+
+    ``postgresql.rows`` is a list of dicts keyed by column name; timestamps/UUIDs/etc. come back as
+    their native Python types (via psycopg2), matching how the driver would hand them to any other
+    caller — stringify explicitly in an assertion/save expression if you need string comparison.
+    """
+
+    def __init__(self, connection_string: str):
+        if not connection_string or not connection_string.strip():
+            raise ValueError("PostgresqlRunner requires a non-empty connection_string")
+        self._connect_kwargs = self._parse_npgsql_connection_string(connection_string)
+
+    @property
+    def name(self) -> str:
+        return "postgresql"
+
+    def handles(self, step: dict) -> bool:
+        return "postgresql" in step and "method" not in step
+
+    # ------------------------------------------------------------------ #
+    #  Lifecycle
+    # ------------------------------------------------------------------ #
+
+    def setup(self, env_file_path: str) -> None:
+        global psycopg2
+        from sefrone_bootstrap.bootstrap_package import PackageManager
+        PackageManager.setup([("psycopg2-binary", "2.9.9")])
+        import psycopg2
+        import psycopg2.extras
+
+        self._wait_for_db_ready()
+
+    def teardown(self) -> None:
+        pass  # each execute() opens and closes its own short-lived connection.
+
+    # ------------------------------------------------------------------ #
+    #  Execute
+    # ------------------------------------------------------------------ #
+
+    def execute(self, step: dict, ctx: RunContext) -> StepResult:
+        try:
+            spec = step.get("postgresql")
+            if not isinstance(spec, dict):
+                return StepResult.failed("postgresql step requires a 'postgresql' object")
+
+            action = str(spec.get("action", "query")).strip().lower()
+            statement = spec.get("statement")
+            if not isinstance(statement, str) or not statement.strip():
+                return StepResult.failed("postgresql.statement is required and must be a non-empty string")
+
+            rendered_statement = ctx.substitute_stored(statement)
+
+            if action == "execute":
+                return self._execute(step, rendered_statement)
+            if action == "query":
+                return self._query(step, spec, rendered_statement, ctx)
+
+            return StepResult.failed(f"Unsupported postgresql action: '{action}'. Supported: 'execute', 'query'")
+        except AssertionError as e:
+            return StepResult.failed(str(e))
+        except Exception as e:
+            return StepResult.failed(str(e))
+
+    def _execute(self, step: dict, statement: str) -> StepResult:
+        conn = psycopg2.connect(**self._connect_kwargs)
+        try:
+            conn.autocommit = True
+            with conn.cursor() as cur:
+                cur.execute(statement)
+                row_count = cur.rowcount
+        finally:
+            conn.close()
+
+        spec = step.get("postgresql", {})
+        if "expect_rows_affected" in spec:
+            expected = int(spec["expect_rows_affected"])
+            if row_count != expected:
+                return StepResult.failed(
+                    f"Expected {expected} row(s) affected, got {row_count}. Statement: {statement}"
+                )
+
+        print(f"[postgresql] Executed ({row_count} row(s) affected): {statement}")
+        return StepResult.passed()
+
+    def _query(self, step: dict, spec: Dict[str, Any], statement: str, ctx: RunContext) -> StepResult:
+        conn = psycopg2.connect(**self._connect_kwargs)
+        try:
+            conn.autocommit = True
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+                cur.execute(statement)
+                rows = [dict(r) for r in cur.fetchall()]
+        finally:
+            conn.close()
+
+        print(f"[postgresql] Queried ({len(rows)} row(s)): {statement}")
+
+        template_context: Dict[str, Any] = {
+            "postgresql": {
+                "rows": rows,
+                "row_count": len(rows),
+            }
+        }
+
+        if "assertions" in step:
+            for expr in step["assertions"]:
+                try:
+                    rendered_expr = ctx.substitute_stored(expr)
+                    rendered = ctx.render_template(rendered_expr, template_context, add_quotes=True)
+                    ctx.try_eval(rendered, rendered_expr)
+                except Exception as e:
+                    raise AssertionError(f"Assertion failed for expression\n    -->'{expr}'\n    -->{e}")
+
+        if "save" in step:
+            for key, path_expr in step["save"].items():
+                rendered_path = ctx.substitute_stored(str(path_expr))
+                rendered = ctx.render_template(rendered_path, template_context)
+                ctx.store_value(key, rendered)
+
+        return StepResult.passed()
+
+    # ------------------------------------------------------------------ #
+    #  Internal helpers
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def _parse_npgsql_connection_string(raw: str) -> Dict[str, Any]:
+        """
+        Parse a Npgsql-style 'Key=Value;Key=Value;' connection string (as produced by
+        compose-template/.env's SCAFFOLD_DB_CONNECTION_STRING) into psycopg2 connect() kwargs.
+        """
+        fields: Dict[str, str] = {}
+        for part in raw.split(";"):
+            part = part.strip()
+            if not part or "=" not in part:
+                continue
+            key, _, value = part.partition("=")
+            fields[key.strip().lower()] = value.strip()
+
+        try:
+            return {
+                "host": fields["host"],
+                "port": int(fields.get("port", 5432)),
+                "dbname": fields["database"],
+                "user": fields["username"],
+                "password": fields["password"],
+            }
+        except KeyError as e:
+            raise RuntimeError(f"[postgresql] Connection string missing expected key {e}: '{raw}'")
+
+    def _wait_for_db_ready(self, timeout_seconds: int = 30) -> None:
+        deadline = time.time() + timeout_seconds
+        last_error: Optional[Exception] = None
+        while time.time() < deadline:
+            conn = None
+            try:
+                conn = psycopg2.connect(**self._connect_kwargs)
+                with conn.cursor() as cur:
+                    cur.execute("SELECT 1")
+                print(f"[postgresql] Database ready at {self._connect_kwargs['host']}:{self._connect_kwargs['port']}")
+                return
+            except Exception as e:
+                last_error = e
+                time.sleep(1)
+            finally:
+                if conn is not None:
+                    conn.close()
+        raise RuntimeError(
+            f"[postgresql] Database did not become ready within {timeout_seconds}s: {last_error}"
+        )

{sefrone_api_e2e-1.3.8 → sefrone_api_e2e-1.4.0}/sefrone_api_e2e.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sefrone_api_e2e
-Version: 1.3.8
+Version: 1.4.0
 Summary: A Python package to provide e2e testing helpers for sefrone API projects
 Home-page: https://bitbucket.org/sefrone/sefrone_pypi
 Author: Sefrone

{sefrone_api_e2e-1.3.8 → sefrone_api_e2e-1.4.0}/sefrone_api_e2e.egg-info/SOURCES.txt

@@ -9,6 +9,8 @@ sefrone_api_e2e/runner_assets.py
 sefrone_api_e2e/runner_csv.py
 sefrone_api_e2e/runner_email_mock.py
 sefrone_api_e2e/runner_excel.py
+sefrone_api_e2e/runner_mysql.py
+sefrone_api_e2e/runner_postgresql.py
 sefrone_api_e2e/runner_rest_api.py
 sefrone_api_e2e/runner_satim_mock.py
 sefrone_api_e2e/runner_webhook_mock.py

{sefrone_api_e2e-1.3.8 → sefrone_api_e2e-1.4.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="sefrone_api_e2e",
-    version="1.3.8",
+    version="1.4.0",
     author="Sefrone",
     author_email="contact@sefrone.com",
     description="A Python package to provide e2e testing helpers for sefrone API projects",