snapline-core 0.1.10__tar.gz

snapline_core-0.1.10/.gitignore

@@ -0,0 +1,5 @@
+/*.iml
+.idea
+dist/
+build/
+*.egg-info/

snapline_core-0.1.10/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: snapline-core
+Version: 0.1.10
+Summary: Declarative snapshot and reconciliation testing — Snapline core
+Project-URL: Homepage, https://github.com/vaagatech/snapline-python
+Project-URL: Repository, https://github.com/vaagatech/snapline-python
+Author-email: VaagaTech <info@vaagatech.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: snapline-api-adapters==0.1.10
+Requires-Dist: snapline-auth-adapters==0.1.10
+Requires-Dist: snapline-engine==0.1.10

snapline_core-0.1.10/examples/basic_usage.py

@@ -0,0 +1,19 @@
+"""Basic Snapline usage example."""
+from snapline.engine import reconcile
+
+live = {"email": "alice@example.com", "status": "synced", "pincode": "123456"}
+expected = {"email": "alice@example.com", "status": "synced"}
+
+result = reconcile(
+    live,
+    expected,
+    {
+        "ignoreFields": ["pincode"],
+        "transformations": {
+            "status": lambda value, _key=None, _parent=None: str(value).upper(),
+        },
+    },
+)
+
+print("match:", result["match"])
+print("diff:", result["diff"])

snapline_core-0.1.10/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "snapline-core"
+version = "0.1.10"
+description = "Declarative snapshot and reconciliation testing — Snapline core"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "VaagaTech", email = "info@vaagatech.com" }]
+dependencies = [
+    "snapline-engine==0.1.10",
+    "snapline-api-adapters==0.1.10",
+    "snapline-auth-adapters==0.1.10",
+]
+
+[project.urls]
+Homepage = "https://github.com/vaagatech/snapline-python"
+Repository = "https://github.com/vaagatech/snapline-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["snapline"]

snapline_core-0.1.10/snapline/core/__init__.py

@@ -0,0 +1,48 @@
+from snapline.api_adapters import api, execute_api, resolve_url
+from snapline.auth_adapters import AuthAdapter, auth
+from snapline.engine import assert_against_file, load_json_file, reconcile
+
+from .api_config.to_api_request_config import to_api_request_config
+from .cross_system.run_api_to_db import run_api_to_db
+from .cross_system.run_db_to_api import run_db_to_api
+from .db import (
+    SqliteConnection,
+    create_sqlite_connection,
+    db,
+    exec_sqlite_file,
+    exec_sqlite_sql,
+    seed_db,
+)
+from .db.db_connection import DbConnection
+from .db_comparison.run_db_comparison import run_db_comparison
+from .reporting.write_report import build_report, render_report, write_test_report
+from .test_suite import test_suite
+
+execute_api_request = execute_api
+
+__all__ = [
+    "AuthAdapter",
+    "DbConnection",
+    "SqliteConnection",
+    "api",
+    "assert_against_file",
+    "auth",
+    "build_report",
+    "create_sqlite_connection",
+    "db",
+    "execute_api",
+    "execute_api_request",
+    "exec_sqlite_file",
+    "exec_sqlite_sql",
+    "load_json_file",
+    "reconcile",
+    "render_report",
+    "resolve_url",
+    "run_api_to_db",
+    "run_db_comparison",
+    "run_db_to_api",
+    "seed_db",
+    "test_suite",
+    "to_api_request_config",
+    "write_test_report",
+]

snapline_core-0.1.10/snapline/core/api_config/to_api_request_config.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..types import ApiFileTestConfig, ApiRequestConfig
+
+
+def to_api_request_config(config: ApiFileTestConfig | dict[str, Any]) -> ApiRequestConfig:
+    protocol = config.get("protocol")
+
+    if protocol == "soap":
+        return {
+            "protocol": "soap",
+            "endpoint": config.get("endpoint", "/"),
+            "soapAction": config.get("soapAction"),
+            "envelope": config.get("envelope"),
+            "inputFile": config.get("inputFile"),
+            "headers": config.get("headers"),
+        }
+
+    if protocol == "graphql":
+        return {
+            "protocol": "graphql",
+            "endpoint": config.get("endpoint", "/graphql"),
+            "query": config.get("query"),
+            "queryFile": config.get("queryFile"),
+            "variables": config.get("variables"),
+            "variablesFile": config.get("variablesFile"),
+            "inputFile": config.get("inputFile"),
+            "dataPath": config.get("dataPath"),
+            "headers": config.get("headers"),
+        }
+
+    return {
+        "protocol": "rest",
+        "endpoint": config.get("endpoint", "/"),
+        "method": config.get("method"),
+        "inputFile": config.get("inputFile"),
+        "body": config.get("body"),
+        "headers": config.get("headers"),
+    }

snapline_core-0.1.10/snapline/core/cross_system/run_api_to_db.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+from snapline.api_adapters import execute_api
+from snapline.engine import reconcile
+
+from ..types import ApiToDbConfig, CrossSystemResult
+
+
+async def run_api_to_db(
+    config: ApiToDbConfig | dict[str, Any],
+    auth_headers: dict[str, str] | None = None,
+    base_url: str | None = None,
+    fetch_impl: Any | None = None,
+) -> CrossSystemResult:
+    api_config = dict(config["api"])
+    expected_status = api_config.pop("expectedStatus", 200)
+
+    response = execute_api(
+        api_config,
+        {
+            "baseUrl": base_url,
+            "authHeaders": auth_headers or {},
+            "fetchImpl": fetch_impl,
+        },
+    )
+
+    if response["status"] != expected_status:
+        return {
+            "match": False,
+            "source": response["data"],
+            "target": None,
+            "diff": {
+                "path": "(http)",
+                "actual": response["status"],
+                "expected": expected_status,
+                "message": f"Expected status {expected_status}, got {response['status']}",
+            },
+        }
+
+    rows = await config["db"]["db"].query(
+        config["db"]["query"],
+        config["db"].get("params", {}),
+    )
+    db_data = rows[0] if rows else None
+
+    result = reconcile(
+        response["data"],
+        db_data,
+        {
+            "ignoreFields": config.get("ignoreFields", []),
+            "transformations": config.get("transformations", {}),
+            "dataMapping": config.get("dataMapping", {}),
+        },
+    )
+
+    return {
+        "match": result["match"],
+        "source": result["processed"],
+        "target": result["expected"],
+        "diff": result["diff"],
+    }

snapline_core-0.1.10/snapline/core/cross_system/run_db_to_api.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Any
+
+from snapline.api_adapters import execute_api
+from snapline.engine import reconcile
+
+from ..types import CrossSystemResult, DbToApiConfig
+
+
+async def run_db_to_api(
+    config: DbToApiConfig | dict[str, Any],
+    auth_headers: dict[str, str] | None = None,
+    base_url: str | None = None,
+    fetch_impl: Any | None = None,
+) -> CrossSystemResult:
+    rows = await config["db"]["db"].query(
+        config["db"]["query"],
+        config["db"].get("params", {}),
+    )
+    db_data = rows[0] if rows else None
+
+    api_config = dict(config["api"])
+    expected_status = api_config.pop("expectedStatus", 200)
+    input_from_db = config.get("inputFromDb", True)
+
+    response = execute_api(
+        api_config,
+        {
+            "baseUrl": base_url,
+            "authHeaders": auth_headers or {},
+            "fetchImpl": fetch_impl,
+            "inputFromRow": db_data if input_from_db and db_data else None,
+        },
+    )
+
+    if response["status"] != expected_status:
+        return {
+            "match": False,
+            "source": db_data,
+            "target": response["data"],
+            "diff": {
+                "path": "(http)",
+                "actual": response["status"],
+                "expected": expected_status,
+                "message": f"Expected status {expected_status}, got {response['status']}",
+            },
+        }
+
+    result = reconcile(
+        db_data,
+        response["data"],
+        {
+            "ignoreFields": config.get("ignoreFields", []),
+            "transformations": config.get("transformations", {}),
+            "dataMapping": config.get("dataMapping", {}),
+        },
+    )
+
+    return {
+        "match": result["match"],
+        "source": result["processed"],
+        "target": result["expected"],
+        "diff": result["diff"],
+    }

snapline_core-0.1.10/snapline/core/db/__init__.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..types import DbRow
+from .db_connection import DbConnection
+from .sqlite_connection import (
+    SqliteConnection,
+    create_sqlite_connection,
+    exec_sqlite_file,
+    exec_sqlite_sql,
+)
+
+_db_registry: dict[str, list[DbRow]] = {}
+
+
+def seed_db(connection_string: str, rows: list[DbRow]) -> None:
+    _db_registry[connection_string] = rows
+
+
+def create_db_connection(dialect: str, connection_string: str) -> DbConnection:
+    seed = _db_registry.get(connection_string, [])
+    return DbConnection(dialect, connection_string, seed)
+
+
+class DbFactory:
+    @staticmethod
+    def postgres(connection_string: str) -> DbConnection:
+        return create_db_connection("postgres", connection_string)
+
+    @staticmethod
+    def mysql(connection_string: str) -> DbConnection:
+        return create_db_connection("mysql", connection_string)
+
+    @staticmethod
+    def sqlite(path: str = ":memory:") -> SqliteConnection:
+        return create_sqlite_connection(path)
+
+    @staticmethod
+    def seed(connection_string: str, rows: list[DbRow]) -> None:
+        seed_db(connection_string, rows)
+
+
+db = DbFactory()
+
+__all__ = [
+    "SqliteConnection",
+    "create_sqlite_connection",
+    "db",
+    "exec_sqlite_file",
+    "exec_sqlite_sql",
+    "seed_db",
+]

snapline_core-0.1.10/snapline/core/db/db_connection.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..types import DbDialect, DbRow
+
+
+class DbConnection:
+    def __init__(
+        self,
+        dialect: DbDialect,
+        connection_string: str,
+        rows: list[DbRow] | None = None,
+    ) -> None:
+        self.dialect = dialect
+        self.connection_string = connection_string
+        self._rows = list(rows or [])
+
+    async def query(self, query: str, params: dict[str, Any] | None = None) -> list[DbRow]:
+        normalized = re.sub(r"\s+", " ", query).strip().lower()
+        if not normalized.startswith("select"):
+            raise ValueError(f"Unsupported query: {query}")
+
+        results = list(self._rows)
+        params = params or {}
+
+        for key, value in params.items():
+            results = [row for row in results if row.get(key) == value]
+
+        columns_match = re.search(r"select\s+(.+?)\s+from", query, flags=re.IGNORECASE)
+        if columns_match and columns_match.group(1).strip() != "*":
+            columns = [column.strip() for column in columns_match.group(1).split(",")]
+            projected: list[DbRow] = []
+            for row in results:
+                projected.append({column: row[column] for column in columns if column in row})
+            results = projected
+
+        return results

snapline_core-0.1.10/snapline/core/db/sqlite_connection.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import re
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from ..types import DbRow
+
+
+def _normalize_named_params(query: str) -> str:
+    return re.sub(r":([a-zA-Z_][a-zA-Z0-9_]*)", r"@\1", query)
+
+
+class SqliteConnection:
+    def __init__(self, database: sqlite3.Connection) -> None:
+        self._database = database
+
+    def exec(self, sql: str) -> None:
+        self._database.executescript(sql)
+
+    async def query(self, query: str, params: dict[str, Any] | None = None) -> list[DbRow]:
+        normalized = _normalize_named_params(query)
+        cursor = self._database.execute(normalized, params or {})
+        columns = [description[0] for description in cursor.description or []]
+        return [dict(zip(columns, row)) for row in cursor.fetchall()]
+
+    def close(self) -> None:
+        self._database.close()
+
+
+def create_sqlite_connection(path: str = ":memory:") -> SqliteConnection:
+    database = sqlite3.connect(path)
+    database.row_factory = sqlite3.Row
+    database.execute("PRAGMA foreign_keys = ON")
+    return SqliteConnection(database)
+
+
+def exec_sqlite_sql(connection: SqliteConnection, sql: str) -> None:
+    connection.exec(sql)
+
+
+def exec_sqlite_file(connection: SqliteConnection, file_path: str | Path) -> None:
+    connection.exec(Path(file_path).read_text(encoding="utf-8"))

snapline_core-0.1.10/snapline/core/db_comparison/run_db_comparison.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from snapline.engine import reconcile
+
+from ..types import CrossSystemResult, DbComparisonConfig
+
+
+async def run_db_comparison(db_comparison: DbComparisonConfig | dict) -> CrossSystemResult:
+    source_rows = await db_comparison["sourceDb"].query(
+        db_comparison["query"],
+        db_comparison.get("params", {}),
+    )
+    target_rows = await db_comparison["targetDb"].query(
+        db_comparison["query"],
+        db_comparison.get("params", {}),
+    )
+
+    source_data = source_rows[0] if source_rows else None
+    target_data = target_rows[0] if target_rows else None
+
+    result = reconcile(
+        source_data,
+        target_data,
+        {
+            "ignoreFields": db_comparison.get("ignoreFields", []),
+            "transformations": db_comparison.get("transformations", {}),
+            "dataMapping": db_comparison.get("dataMapping", {}),
+        },
+    )
+
+    return {
+        "match": result["match"],
+        "source": result["processed"],
+        "target": result["expected"],
+        "diff": result["diff"],
+    }

snapline_core-0.1.10/snapline/core/reporting/html_reporter.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import html
+import json
+from typing import Any
+
+from .types import TestRunReport
+
+
+def _escape(value: str) -> str:
+    return html.escape(value)
+
+
+def _render_diff_block(diff: Any) -> str:
+    if not diff:
+        return ""
+    payload = _escape(json.dumps(diff, indent=2))
+    return f'<pre class="diff">{payload}</pre>'
+
+
+def render_html_report(report: TestRunReport) -> str:
+    suite_rows = []
+    for suite in report["suites"]:
+        step_rows = []
+        for step in suite["results"]:
+            status_class = "pass" if step["passed"] else "fail"
+            message = (
+                f'<p class="message">{_escape(step["message"])}</p>'
+                if step.get("message")
+                else ""
+            )
+            diff = _render_diff_block(step.get("diff")) if not step["passed"] else ""
+            step_rows.append(
+                f"""
+            <li class="step {status_class}">
+              <span class="badge">{"PASS" if step["passed"] else "FAIL"}</span>
+              <span class="step-name">{_escape(step["step"])}</span>
+              {message}
+              {diff}
+            </li>"""
+            )
+
+        suite_rows.append(
+            f"""
+        <section class="suite {"pass" if suite["passed"] else "fail"}">
+          <h2>{_escape(suite["name"])}</h2>
+          <p class="suite-status">{"PASSED" if suite["passed"] else "FAILED"}</p>
+          <ul class="steps">{''.join(step_rows)}</ul>
+        </section>"""
+        )
+
+    duration = report["summary"].get("durationMs") or 0
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>snapline-engine Test Report</title>
+  <style>
+    :root {{
+      color-scheme: light dark;
+      --bg: #0f172a;
+      --panel: #111827;
+      --text: #e5e7eb;
+      --muted: #94a3b8;
+      --pass: #16a34a;
+      --fail: #dc2626;
+      --border: #334155;
+    }}
+    body {{
+      margin: 0;
+      font-family: ui-sans-serif, system-ui, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      line-height: 1.5;
+    }}
+    main {{ max-width: 960px; margin: 0 auto; padding: 2rem; }}
+    h1 {{ margin-top: 0; }}
+    .summary {{
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+      gap: 1rem;
+      margin: 1.5rem 0 2rem;
+    }}
+    .metric {{
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 12px;
+      padding: 1rem;
+    }}
+    .metric strong {{ display: block; font-size: 1.5rem; }}
+    .metric span {{ color: var(--muted); font-size: 0.875rem; }}
+    .suite {{
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 12px;
+      padding: 1rem 1.25rem;
+      margin-bottom: 1rem;
+    }}
+    .suite.pass {{ border-left: 4px solid var(--pass); }}
+    .suite.fail {{ border-left: 4px solid var(--fail); }}
+    .suite h2 {{ margin: 0 0 0.25rem; font-size: 1.125rem; }}
+    .suite-status {{ margin: 0 0 1rem; color: var(--muted); }}
+    .steps {{ list-style: none; padding: 0; margin: 0; }}
+    .step {{ padding: 0.75rem 0; border-top: 1px solid var(--border); }}
+    .badge {{
+      display: inline-block;
+      min-width: 3rem;
+      margin-right: 0.5rem;
+      padding: 0.125rem 0.5rem;
+      border-radius: 999px;
+      font-size: 0.75rem;
+      font-weight: 700;
+      text-align: center;
+    }}
+    .step.pass .badge {{ background: rgba(22, 163, 74, 0.2); color: var(--pass); }}
+    .step.fail .badge {{ background: rgba(220, 38, 38, 0.2); color: var(--fail); }}
+    .message {{ margin: 0.5rem 0 0; color: var(--muted); }}
+    .diff {{
+      margin: 0.75rem 0 0;
+      padding: 0.75rem;
+      overflow-x: auto;
+      background: #020617;
+      border-radius: 8px;
+      border: 1px solid var(--border);
+      font-size: 0.8125rem;
+    }}
+    footer {{ margin-top: 2rem; color: var(--muted); font-size: 0.875rem; }}
+  </style>
+</head>
+<body>
+  <main>
+    <h1>snapline-engine Test Report</h1>
+    <p>Generated at {_escape(report["generatedAt"])}</p>
+    <div class="summary">
+      <div class="metric"><strong>{report["summary"]["total"]}</strong><span>Total suites</span></div>
+      <div class="metric"><strong>{report["summary"]["passed"]}</strong><span>Passed</span></div>
+      <div class="metric"><strong>{report["summary"]["failed"]}</strong><span>Failed</span></div>
+      <div class="metric"><strong>{duration}ms</strong><span>Duration</span></div>
+    </div>
+    {''.join(suite_rows)}
+    <footer>
+      Upload this file to any CI dashboard, artifact store, or reporting system.
+    </footer>
+  </main>
+</body>
+</html>"""

snapline_core-0.1.10/snapline/core/reporting/json_reporter.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import json
+
+from .types import TestRunReport
+
+
+def render_json_report(report: TestRunReport) -> str:
+    return json.dumps(report, indent=2)

snapline_core-0.1.10/snapline/core/reporting/text_reporter.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .types import TestRunReport
+
+
+def _format_diff(diff: Any) -> str:
+    if not diff:
+        return "none"
+    return json.dumps(diff, indent=2).replace("\n", "\n      ")
+
+
+def render_text_report(report: TestRunReport) -> str:
+    lines = [
+        "snapline-engine — Test Run Report",
+        "=====================================",
+        f"Generated: {report['generatedAt']}",
+        f"Duration:  {report['summary'].get('durationMs') or 0}ms",
+        "",
+        f"Total:  {report['summary']['total']}",
+        f"Passed: {report['summary']['passed']}",
+        f"Failed: {report['summary']['failed']}",
+        "",
+    ]
+
+    for suite in report["suites"]:
+        lines.append(f"{'PASS' if suite['passed'] else 'FAIL'}  {suite['name']}")
+        for step in suite["results"]:
+            lines.append(f"  {'✓' if step['passed'] else '✗'} {step['step']}")
+            if not step["passed"] and step.get("message"):
+                lines.append(f"      message: {step['message']}")
+            if not step["passed"] and step.get("diff"):
+                lines.append(f"      diff:\n      {_format_diff(step['diff'])}")
+        lines.append("")
+
+    return "\n".join(lines) + "\n"

snapline_core-0.1.10/snapline/core/reporting/types.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Literal
+
+from ..types import TestSuiteResult
+
+ReportFormat = Literal["json", "html", "text"]
+
+
+class ReportConfig(dict):
+    format: ReportFormat
+    outputPath: str
+
+
+class TestRunReportMeta(dict):
+    durationMs: int | None
+    environment: dict[str, Any] | None
+
+
+class TestRunReport(dict):
+    generatedAt: str
+    framework: str
+    summary: dict[str, Any]
+    environment: dict[str, Any] | None
+    suites: list[TestSuiteResult]

snapline_core-0.1.10/snapline/core/reporting/write_report.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from ..types import TestSuiteResult
+from .html_reporter import render_html_report
+from .json_reporter import render_json_report
+from .text_reporter import render_text_report
+from .types import ReportConfig, TestRunReport, TestRunReportMeta
+
+FRAMEWORK_NAME = "snapline-engine"
+
+
+def build_report(
+    suites: list[TestSuiteResult],
+    meta: TestRunReportMeta | dict[str, Any] | None = None,
+) -> TestRunReport:
+    meta = meta or {}
+    passed = sum(1 for suite in suites if suite["passed"])
+    failed = len(suites) - passed
+
+    return {
+        "generatedAt": datetime.now(timezone.utc).isoformat(),
+        "framework": FRAMEWORK_NAME,
+        "summary": {
+            "total": len(suites),
+            "passed": passed,
+            "failed": failed,
+            "durationMs": meta.get("durationMs"),
+        },
+        "environment": meta.get("environment"),
+        "suites": suites,
+    }
+
+
+def render_report(report: TestRunReport, format: str) -> str:
+    if format == "json":
+        return render_json_report(report)
+    if format == "html":
+        return render_html_report(report)
+    if format == "text":
+        return render_text_report(report)
+    raise ValueError(f"Unsupported report format: {format}")
+
+
+def write_test_report(
+    suites: list[TestSuiteResult],
+    config: ReportConfig | dict[str, Any],
+    meta: TestRunReportMeta | dict[str, Any] | None = None,
+) -> str:
+    report = build_report(suites, meta)
+    content = render_report(report, config["format"])
+    output_path = Path(config["outputPath"])
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(content, encoding="utf-8")
+    return str(output_path)

snapline_core-0.1.10/snapline/core/test_suite.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from snapline.api_adapters import execute_api
+from snapline.engine import assert_against_file
+
+from .api_config.to_api_request_config import to_api_request_config
+from .cross_system.run_api_to_db import run_api_to_db
+from .cross_system.run_db_to_api import run_db_to_api
+from .db_comparison.run_db_comparison import run_db_comparison
+from .types import TestStepResult, TestSuiteConfig, TestSuiteResult
+
+
+def _log_step_result(
+    label: str,
+    match: bool,
+    diff: Any,
+    on_fail,
+) -> None:
+    if match:
+        print(f"  ✓ {label}")
+    else:
+        on_fail()
+        print(f"  ✗ {label}")
+        print(f"    diff: {json.dumps(diff)}")
+
+
+async def test_suite(name: str, config: TestSuiteConfig | dict[str, Any]) -> TestSuiteResult:
+    auth_adapter = config.get("auth")
+    api = config.get("api")
+    db_comparison = config.get("dbComparison")
+    api_to_db = config.get("apiToDb")
+    db_to_api = config.get("dbToApi")
+    base_url = config.get("baseUrl")
+    fetch_impl = config.get("fetchImpl")
+
+    results: list[TestStepResult] = []
+    passed = True
+
+    def fail() -> None:
+        nonlocal passed
+        passed = False
+
+    print(f"\n▶ {name}")
+
+    auth_headers: dict[str, str] = {}
+    if auth_adapter:
+        auth_result = await auth_adapter.initialize()
+        auth_headers = auth_result["headers"]
+        results.append(
+            {
+                "step": "auth",
+                "passed": True,
+                "token": "[redacted]" if auth_result.get("token") else None,
+            }
+        )
+        print("  ✓ auth initialized")
+
+    if api:
+        expected_file = api.get("expectedFile")
+        ignore_fields = api.get("ignoreFields", [])
+        transformations = api.get("transformations", {})
+        data_mapping = api.get("dataMapping", {})
+        expected_status = api.get("expectedStatus", 200)
+
+        api_request = to_api_request_config(api)
+        response = execute_api(
+            api_request,
+            {
+                "baseUrl": base_url,
+                "authHeaders": auth_headers,
+                "fetchImpl": fetch_impl,
+            },
+        )
+
+        if response["status"] != expected_status:
+            fail()
+            results.append(
+                {
+                    "step": "api",
+                    "passed": False,
+                    "message": f"Expected status {expected_status}, got {response['status']}",
+                    "data": response["data"],
+                }
+            )
+            print(
+                f"  ✗ api status mismatch (expected {expected_status}, got {response['status']})"
+            )
+        elif expected_file:
+            assertion = assert_against_file(
+                response["data"],
+                expected_file,
+                {
+                    "ignoreFields": ignore_fields,
+                    "transformations": transformations,
+                    "dataMapping": data_mapping,
+                },
+            )
+            results.append(
+                {
+                    "step": "api-file",
+                    "passed": assertion["match"],
+                    "diff": assertion["diff"],
+                    "processed": assertion["processed"],
+                }
+            )
+            _log_step_result(
+                "api response reconciled with fixture file",
+                assertion["match"],
+                assertion["diff"],
+                fail,
+            )
+        else:
+            results.append({"step": "api", "passed": True, "data": response["data"]})
+            print("  ✓ api request completed")
+
+    if db_comparison:
+        db_result = await run_db_comparison(db_comparison)
+        results.append({"step": "db-to-db", "passed": db_result["match"], **db_result})
+        _log_step_result("db-to-db reconciliation passed", db_result["match"], db_result["diff"], fail)
+
+    if api_to_db:
+        result = await run_api_to_db(api_to_db, auth_headers, base_url, fetch_impl)
+        results.append({"step": "api-to-db", "passed": result["match"], **result})
+        _log_step_result("api-to-db reconciliation passed", result["match"], result["diff"], fail)
+
+    if db_to_api:
+        result = await run_db_to_api(db_to_api, auth_headers, base_url, fetch_impl)
+        results.append({"step": "db-to-api", "passed": result["match"], **result})
+        _log_step_result("db-to-api reconciliation passed", result["match"], result["diff"], fail)
+
+    summary = "PASSED" if passed else "FAILED"
+    print(f"\n{'✅' if passed else '❌'} {name}: {summary}\n")
+
+    return {"name": name, "passed": passed, "results": results}

snapline_core-0.1.10/snapline/core/types.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from typing import Any, Literal, Protocol
+
+from snapline.api_adapters.types import ApiRequestConfig
+from snapline.auth_adapters import AuthAdapter
+from snapline.engine.types import DataMappingMap, DiffResult, ReconcileOptions, TransformationMap
+
+DbRow = dict[str, Any]
+DbDialect = Literal["postgres", "mysql", "sqlite"]
+
+
+class DbConnectionLike(Protocol):
+    async def query(self, query: str, params: dict[str, Any] | None = None) -> list[DbRow]: ...
+
+
+class DbQueryConfig(dict):
+    db: DbConnectionLike
+    query: str
+    params: dict[str, Any] | None
+
+
+class ApiFileTestConfig(ReconcileOptions):
+    endpoint: str | None
+    method: str | None
+    inputFile: str | None
+    expectedFile: str | None
+    body: Any
+    headers: dict[str, str] | None
+    expectedStatus: int | None
+    protocol: Literal["rest", "soap", "graphql"] | None
+    soapAction: str | None
+    envelope: str | None
+    query: str | None
+    queryFile: str | None
+    variables: dict[str, Any] | None
+    variablesFile: str | None
+    dataPath: str | None
+
+
+class DbComparisonConfig(ReconcileOptions):
+    sourceDb: DbConnectionLike
+    targetDb: DbConnectionLike
+    query: str
+    params: dict[str, Any] | None
+
+
+class ApiToDbConfig(ReconcileOptions):
+    api: ApiRequestConfig
+    db: DbQueryConfig
+
+
+class DbToApiConfig(ReconcileOptions):
+    db: DbQueryConfig
+    api: ApiRequestConfig
+    inputFromDb: bool | None
+
+
+class TestSuiteConfig(dict):
+    auth: AuthAdapter | None
+    api: ApiFileTestConfig | None
+    dbComparison: DbComparisonConfig | None
+    apiToDb: ApiToDbConfig | None
+    dbToApi: DbToApiConfig | None
+    baseUrl: str | None
+    fetchImpl: Any | None
+
+
+class TestStepResult(dict):
+    step: str
+    passed: bool
+    message: str | None
+    data: Any
+    diff: DiffResult | None
+    processed: Any
+    token: str | None
+    source: Any
+    target: Any
+    match: bool | None
+
+
+class TestSuiteResult(dict):
+    name: str
+    passed: bool
+    results: list[TestStepResult]
+
+
+class CrossSystemResult(dict):
+    match: bool
+    source: Any
+    target: Any
+    diff: DiffResult | None
+
+
+DbComparisonResult = CrossSystemResult