Maintainers
-This module is part of the odoonix/education project on GitHub.
-You are welcome to contribute.
-
-
-
-
-
-
-
-
-
diff --git a/bookland/views/book_views.xml b/bookland/views/book_views.xml
deleted file mode 100644
index dc81963..0000000
--- a/bookland/views/book_views.xml
+++ /dev/null
@@ -1,87 +0,0 @@
-
-
-
-Book land a modern library management system
- -
این یک اپلیکشن برای مدیریت کتابخانههای دانشگاه است.
-در این نرم افزار شما امکانات متفاوتی خواهی داشت.
-Table of contents
-
-
--
-
- Changelog -
- نسخه ۱.۰.۰ -
- Bug Tracker -
- Credits
-
-
- Authors -
- Maintainers -
-
-
-Changelog
-
-
-نسخه ۱.۰.۰
-در این نسخه ساختار اولیه نرم افزار ایجاد شده و امکانات زیر ایجاد شده -است.
--
-
- TODO: -
-
-
-Bug Tracker
-Bugs are tracked on GitHub Issues. -In case of trouble, please check there if your issue has already been reported. -If you spotted it first, help us to smash it by providing a detailed and welcomed -feedback.
-Do not contact contributors directly about support or help with technical issues.
-
-
-
-
-
-
-
-
-
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..1785f7e
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,116 @@
+services:
+
+ # --- Odoo's own database ---
+ postgres:
+ image: postgres:16
+ container_name: odoo_postgres
+ environment:
+ POSTGRES_DB: postgres
+ POSTGRES_USER: odoo
+ POSTGRES_PASSWORD: odoo
+ volumes:
+ - postgres_data:/var/lib/postgresql/data
+ healthcheck:
+ test: ["CMD-SHELL", "pg_isready -U odoo -d postgres"]
+ interval: 5s
+ timeout: 5s
+ retries: 10
+
+ # --- One-shot: create the Odoo database and install Sales ---
+ odoo_init:
+ image: odoo:17
+ container_name: odoo_init
+ depends_on:
+ postgres:
+ condition: service_healthy
+ environment:
+ HOST: postgres
+ USER: odoo
+ PASSWORD: odoo
+ volumes:
+ - odoo_data:/var/lib/odoo
+ command:
+ - odoo
+ - -d
+ - odoo_test
+ - -i
+ - base,sale_management
+ - --without-demo=all
+ - --stop-after-init
+ restart: "no"
+
+ # --- Odoo server ---
+ odoo:
+ image: odoo:17
+ container_name: odoo_app
+ depends_on:
+ odoo_init:
+ condition: service_completed_successfully
+ ports:
+ - "8069:8069"
+ environment:
+ HOST: postgres
+ USER: odoo
+ PASSWORD: odoo
+ volumes:
+ - odoo_data:/var/lib/odoo
+ command: ["odoo", "--db-filter=^odoo_test$$"]
+
+ # --- Sync target database ---
+ app_db:
+ image: postgres:16
+ container_name: odoo_app_db
+ environment:
+ POSTGRES_DB: sync_db
+ POSTGRES_USER: sync
+ POSTGRES_PASSWORD: sync
+ volumes:
+ - app_db_data:/var/lib/postgresql/data
+ ports:
+ - "5433:5432"
+ healthcheck:
+ test: ["CMD-SHELL", "pg_isready -U sync -d sync_db"]
+ interval: 5s
+ timeout: 5s
+ retries: 10
+
+ # --- One-shot: seed test data into Odoo ---
+ odoo_seed:
+ build: .
+ container_name: odoo_seed
+ depends_on:
+ odoo:
+ condition: service_started
+ environment:
+ ODOO_URL: http://odoo:8069
+ ODOO_DB_NAME: odoo_test
+ ODOO_USERNAME: admin
+ ODOO_PASSWORD: admin
+ command: ["python", "-m", "scripts.seed_odoo"]
+ restart: "no"
+
+ # --- Backend: migrate + run the sync pipeline ---
+ backend:
+ build: .
+ container_name: odoo_backend
+ depends_on:
+ app_db:
+ condition: service_healthy
+ odoo_seed:
+ condition: service_completed_successfully
+ environment:
+ DATABASE_NAME: sync_db
+ DATABASE_USER: sync
+ DATABASE_PASSWORD: sync
+ DATABASE_HOST: app_db
+ DATABASE_PORT: "5432"
+ ODOO_URL: http://odoo:8069
+ ODOO_DB_NAME: odoo_test
+ ODOO_USERNAME: admin
+ ODOO_PASSWORD: admin
+ restart: "no"
+
+volumes:
+ postgres_data:
+ odoo_data:
+ app_db_data:
diff --git a/docker/entrypoint.sh b/docker/entrypoint.sh
new file mode 100644
index 0000000..a3ca531
--- /dev/null
+++ b/docker/entrypoint.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+set -e
+
+echo ">> Applying database migrations (alembic upgrade head)..."
+alembic upgrade head
+
+echo ">> Running sync pipeline..."
+python -m app.main
diff --git a/docs/TECHNICAL.md b/docs/TECHNICAL.md
new file mode 100644
index 0000000..ea0e775
--- /dev/null
+++ b/docs/TECHNICAL.md
@@ -0,0 +1,75 @@
+# Technical Documentation
+
+## Architecture
+
+Clean / hexagonal architecture, dependencies point **inward**:
+
+| Layer | Contents | Depends on |
+|---|---|---|
+| **domain** | entities, repository interfaces, `IDBConnection` port | nothing |
+| **application** | DTOs, mappers, sync services, use cases | domain |
+| **infrastructure** | Odoo XML-RPC client, SQLAlchemy models/repos, DI container | domain + application |
+
+Flow of one sync run:
+
+```
+OdooClient ─▶ SyncService (fetch + map to entity)
+ │
+ SyncEntityUseCase (upsert + error isolation + record run/logs)
+ │
+ Repository (IDBConnection) ─▶ PostgreSQL
+```
+
+The **DI container** (`dependency-injector`) wires everything; `main.py` is the
+composition root and orchestrator (runs the 4 use cases in FK-safe order).
+
+## Key design decisions
+
+- **Adapter separate from service** — Odoo access is isolated in `OdooClient`
+ (infrastructure). Swapping ERPs means writing one adapter; services/use cases
+ stay unchanged.
+- **Repository pattern over a port** — repos depend on the `IDBConnection`
+ abstraction, not on SQLAlchemy directly. Swapping PostgreSQL for another DB
+ means one new adapter.
+- **`odoo_id` as primary key** for the 4 synced tables — the source id *is* the
+ identity, so foreign keys line up directly without id translation.
+ `sync_runs` / `sync_logs` use their own auto-increment ids.
+- **Idempotency (no duplicates)** — the use case looks up each record by
+ `odoo_id`; found → `update`, missing → `save`. Re-runs update in place.
+- **Per-record error isolation** — each record is processed in its own
+ `try/except` and its own transaction. One failure is logged to `sync_logs`
+ and counted; the batch continues. A single error never rolls back the run.
+- **Type hints + generic interfaces** throughout; enums for run status / log level.
+
+## Data model
+
+`contacts`, `products`, `sale_orders`, `sale_order_lines` (+ FKs:
+`sale_orders.customer_id → contacts`, `sale_order_lines → sale_orders, products`).
+
+Observability: `sync_runs` (one row per operation: type, start/end, counts,
+status) and `sync_logs` (per-error detail, FK → `sync_runs`, `ON DELETE CASCADE`).
+
+Schema is managed by **Alembic** migrations.
+
+## Defense notes
+
+- **One error → full rollback?** No. Per-record transactions, so other records
+ still commit. This matches the requirement to keep processing on failure.
+- **Hundreds of thousands of orders?** Add pagination + batch reads on the Odoo
+ side, bulk upserts, and indexing; move to incremental sync by `write_date`.
+- **Extensibility** — a new entity type = one service + one repository + one use
+ case provider; the generic `SyncEntityUseCase` is reused.
+
+## Testing strategy
+
+- **Unit** — entities, mappers, and the use case (error isolation, counting,
+ status) with fakes; repositories against in-memory SQLite.
+- **Integration** — the full pipeline is validated end-to-end via
+ `docker compose up` (real Odoo + PostgreSQL).
+
+## Known limitations
+
+- No retry / pagination / incremental sync yet (single full pull per run).
+- Odoo credentials are passed via environment; production should use a secrets
+ manager.
+- `odoo_init` re-installs modules on every `up` (slower, but non-destructive).
diff --git a/docs/USER.md b/docs/USER.md
new file mode 100644
index 0000000..2c8783b
--- /dev/null
+++ b/docs/USER.md
@@ -0,0 +1,73 @@
+# User Documentation
+
+## Prerequisites
+
+- Docker + Docker Compose
+
+## Run everything
+
+```bash
+docker compose up --build
+```
+
+Startup order (handled automatically via healthchecks / dependencies):
+
+1. `postgres` — Odoo's database
+2. `odoo_init` — creates the `odoo_test` DB and installs Sales *(first run: a few minutes)*
+3. `odoo` — Odoo server
+4. `odoo_seed` — inserts test data into Odoo (idempotent)
+5. `app_db` — the sync target PostgreSQL
+6. `odoo_backend` — runs `alembic upgrade head`, then the sync
+
+Success looks like this in the `odoo_backend` logs:
+
+```
+[contacts] status=success received=7 saved=7 failed=0
+[products] status=success received=5 saved=5 failed=0
+[sale_orders] status=success received=7 saved=7 failed=0
+[sale_order_lines] status=success received=12 saved=12 failed=0
+```
+
+The backend is a batch job: it exits with code `0` when done (Odoo/DB keep running).
+
+## Verify the data
+
+```bash
+docker compose exec app_db psql -U sync -d sync_db \
+ -c "select operation_type, status, records_received, records_saved, records_updated from sync_runs order by id;"
+```
+
+Row counts:
+
+```bash
+docker compose exec app_db psql -U sync -d sync_db \
+ -c "select 'contacts', count(*) from contacts union all select 'products', count(*) from products union all select 'sale_orders', count(*) from sale_orders union all select 'sale_order_lines', count(*) from sale_order_lines;"
+```
+
+## Re-run (idempotency)
+
+```bash
+docker compose up
+```
+
+The second run reports `updated` instead of `saved` — no duplicates are created.
+
+## Reset everything
+
+```bash
+docker compose down -v # also removes the database volumes
+```
+
+## Run locally (without Docker)
+
+```bash
+cp .env.example .env # point it at your Odoo + PostgreSQL
+pip install -e .
+alembic upgrade head
+python -m app.main
+```
+
+## Ports
+
+- Odoo UI: http://localhost:8069 (login `admin` / `admin`)
+- Sync target PostgreSQL: `localhost:5433` (user `sync`, db `sync_db`)
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..4a84166
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,34 @@
+[project]
+name = "education"
+version = "0.1.0"
+description = "Odoo to PostgreSQL synchronization service"
+readme = "README.md"
+requires-python = ">=3.12"
+
+dependencies = [
+ "SQLAlchemy==2.0.46",
+ "alembic==1.18.4",
+ "psycopg[binary]",
+ "pydantic==2.12.5",
+ "dependency-injector==4.48.3",
+ "pydantic-settings==2.13.1",
+ "python-dotenv",
+ "pytest",
+ "pytest-cov",
+]
+
+[tool.setuptools]
+packages = ["app"]
+
+[tool.setuptools.package-dir]
+app = "app"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["app"]
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
\ No newline at end of file
diff --git a/scripts/seed_odoo.py b/scripts/seed_odoo.py
new file mode 100644
index 0000000..2c5cb9e
--- /dev/null
+++ b/scripts/seed_odoo.py
@@ -0,0 +1,140 @@
+"""Seed the Odoo instance with test data (idempotent).
+
+Runs standalone and reads ODOO_* from the environment. Used by the
+`odoo_seed` service so that `docker compose up` produces a populated
+Odoo for the sync to read from. Safe to run repeatedly.
+"""
+import os
+import time
+import xmlrpc.client
+
+
+ODOO_URL = os.getenv("ODOO_URL", "http://localhost:8069")
+ODOO_DB = os.getenv("ODOO_DB_NAME", "odoo_test")
+ODOO_USER = os.getenv("ODOO_USERNAME", "admin")
+ODOO_PASSWORD = os.getenv("ODOO_PASSWORD", "admin")
+
+
+CONTACTS = [
+ {"name": "Ali Ahmadi", "email": "ali.ahmadi@test.com",
+ "phone": "+98 21 8877 0001", "mobile": "+98 912 345 6789"},
+ {"name": "Reza Karimi", "email": "reza@test.com",
+ "phone": "+98 21 4411 2233", "mobile": "+98 912 333 4455"},
+ {"name": "Sara Mohammadi", "email": "sara@test.com",
+ "phone": "+98 71 3222 3344", "mobile": "+98 912 999 8877"},
+ {"name": "TechVision Co", "email": "info@techvision.test",
+ "phone": "+98 21 8877 6655", "mobile": "+98 912 123 4567"},
+ {"name": "Pars Data Solutions", "email": "contact@parsdata.test",
+ "phone": "+98 71 3222 1144", "mobile": "+98 912 555 6677"},
+]
+
+PRODUCTS = [
+ {"name": "Laptop Dell XPS", "default_code": "LAP-001",
+ "list_price": 2500.0, "type": "consu"},
+ {"name": "Mechanical Keyboard", "default_code": "KEY-001",
+ "list_price": 120.0, "type": "consu"},
+ {"name": "Wireless Mouse", "default_code": "MOU-001",
+ "list_price": 45.0, "type": "consu"},
+ {"name": '27" Monitor', "default_code": "MON-001",
+ "list_price": 320.0, "type": "consu"},
+ {"name": "USB-C Dock", "default_code": "DOC-001",
+ "list_price": 180.0, "type": "consu"},
+]
+
+# ref, customer email, [(product default_code, qty, unit_price), ...]
+ORDERS = [
+ {"ref": "SEED-1", "customer": "info@techvision.test",
+ "lines": [("LAP-001", 2, 2500.0), ("MOU-001", 3, 45.0)]},
+ {"ref": "SEED-2", "customer": "contact@parsdata.test",
+ "lines": [("MON-001", 1, 320.0), ("KEY-001", 4, 120.0)]},
+ {"ref": "SEED-3", "customer": "reza@test.com",
+ "lines": [("DOC-001", 5, 180.0)]},
+]
+
+
+def wait_for_odoo(common, retries=60, delay=5):
+ for attempt in range(1, retries + 1):
+ try:
+ common.version()
+ print(f"Odoo reachable (attempt {attempt})")
+ return
+ except Exception as exc:
+ print(f"Waiting for Odoo... ({attempt}/{retries}): {exc}")
+ time.sleep(delay)
+ raise RuntimeError("Odoo did not become reachable in time")
+
+
+def main():
+ common = xmlrpc.client.ServerProxy(f"{ODOO_URL}/xmlrpc/2/common")
+ wait_for_odoo(common)
+
+ uid = common.authenticate(ODOO_DB, ODOO_USER, ODOO_PASSWORD, {})
+ if not uid:
+ raise RuntimeError("Odoo authentication failed")
+
+ models = xmlrpc.client.ServerProxy(f"{ODOO_URL}/xmlrpc/2/object")
+
+ def execute(model, method, *args):
+ return models.execute_kw(
+ ODOO_DB, uid, ODOO_PASSWORD, model, method, list(args)
+ )
+
+ def get_or_create(model, domain, values):
+ found = execute(model, "search", domain)
+ if found:
+ return found[0]
+ return execute(model, "create", values)
+
+ # Installing sale_management with --without-demo does not add the admin
+ # user to the Sales group, so grant it before touching sale.order.
+ sales_group = models.execute_kw(
+ ODOO_DB, uid, ODOO_PASSWORD,
+ "ir.model.data", "search_read",
+ [[["name", "=", "group_sale_manager"],
+ ["module", "in", ["sales_team", "sale"]]]],
+ {"fields": ["res_id"], "limit": 1},
+ )
+ if sales_group:
+ execute("res.users", "write",
+ [uid], {"groups_id": [(4, sales_group[0]["res_id"])]})
+ print("granted Sales group to admin")
+
+ partner_ids = {}
+ for c in CONTACTS:
+ partner_ids[c["email"]] = get_or_create(
+ "res.partner", [["email", "=", c["email"]]], c
+ )
+ print(f"contacts ready: {len(partner_ids)}")
+
+ product_ids = {}
+ for p in PRODUCTS:
+ product_ids[p["default_code"]] = get_or_create(
+ "product.product", [["default_code", "=", p["default_code"]]], p
+ )
+ print(f"products ready: {len(product_ids)}")
+
+ created = 0
+ for o in ORDERS:
+ if execute("sale.order", "search",
+ [["client_order_ref", "=", o["ref"]]]):
+ continue
+ order_lines = [
+ (0, 0, {
+ "product_id": product_ids[code],
+ "product_uom_qty": qty,
+ "price_unit": price,
+ })
+ for code, qty, price in o["lines"]
+ ]
+ execute("sale.order", "create", {
+ "partner_id": partner_ids[o["customer"]],
+ "client_order_ref": o["ref"],
+ "order_line": order_lines,
+ })
+ created += 1
+ print(f"sale orders created this run: {created}")
+ print("Seed complete.")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/application/mappers/test_mappers.py b/tests/application/mappers/test_mappers.py
new file mode 100644
index 0000000..244a977
--- /dev/null
+++ b/tests/application/mappers/test_mappers.py
@@ -0,0 +1,69 @@
+from datetime import datetime
+from decimal import Decimal
+
+from app.application.dto.contact_dto import ContactDTO
+from app.application.dto.product_dto import ProductDTO
+from app.application.dto.sale_order_dto import SaleOrderDTO
+from app.application.dto.sale_order_line_dto import SaleOrderLineDTO
+from app.application.mappers.contact_mapper import ContactMapper
+from app.application.mappers.product_mapper import ProductMapper
+from app.application.mappers.sale_order_mapper import SaleOrderMapper
+from app.application.mappers.sale_order_line_mapper import SaleOrderLineMapper
+from app.domain.entities.contact import Contact
+from app.domain.entities.product import Product
+from app.domain.entities.sale_order import SaleOrder
+from app.domain.entities.sale_order_line import SaleOrderLine
+
+
+def test_contact_mapper_to_entity():
+ dto = ContactDTO(odoo_id=1, name="Ali", email="a@x.com",
+ phone="021", mobile="0912")
+ entity = ContactMapper.to_entity(dto)
+
+ assert isinstance(entity, Contact)
+ assert entity.odoo_id == 1
+ assert entity.name == "Ali"
+ assert entity.email == "a@x.com"
+ assert entity.phone == "021"
+ assert entity.mobile == "0912"
+
+
+def test_product_mapper_to_entity():
+ dto = ProductDTO(odoo_id=2, name="Laptop", internal_reference="LAP-001",
+ sale_price=Decimal("2500.00"), product_type="consu")
+ entity = ProductMapper.to_entity(dto)
+
+ assert isinstance(entity, Product)
+ assert entity.odoo_id == 2
+ assert entity.internal_reference == "LAP-001"
+ assert entity.sale_price == Decimal("2500.00")
+ assert entity.product_type == "consu"
+
+
+def test_sale_order_mapper_to_entity():
+ dt = datetime(2026, 7, 24, 10, 0, 0)
+ dto = SaleOrderDTO(odoo_id=3, order_number="S00001", customer_id=7,
+ order_date=dt, state="sale",
+ total_amount=Decimal("100.00"))
+ entity = SaleOrderMapper.to_entity(dto)
+
+ assert isinstance(entity, SaleOrder)
+ assert entity.order_number == "S00001"
+ assert entity.customer_id == 7
+ assert entity.order_date == dt
+ assert entity.state == "sale"
+ assert entity.total_amount == Decimal("100.00")
+
+
+def test_sale_order_line_mapper_to_entity():
+ dto = SaleOrderLineDTO(odoo_id=4, sale_order_id=3, product_id=2,
+ quantity=2.0, unit_price=Decimal("50.00"),
+ subtotal=Decimal("100.00"))
+ entity = SaleOrderLineMapper.to_entity(dto)
+
+ assert isinstance(entity, SaleOrderLine)
+ assert entity.sale_order_id == 3
+ assert entity.product_id == 2
+ assert entity.quantity == 2.0
+ assert entity.unit_price == Decimal("50.00")
+ assert entity.subtotal == Decimal("100.00")
diff --git a/tests/application/use_cases/test_sync_entity_use_case.py b/tests/application/use_cases/test_sync_entity_use_case.py
new file mode 100644
index 0000000..6f40ab8
--- /dev/null
+++ b/tests/application/use_cases/test_sync_entity_use_case.py
@@ -0,0 +1,153 @@
+from dataclasses import dataclass
+
+from app.application.use_cases.sync_entity_use_case import SyncEntityUseCase
+from app.domain.entities.sync_run import SyncStatus
+from app.domain.entities.sync_log import SyncLogLevel
+
+
+@dataclass
+class FakeEntity:
+ odoo_id: int
+
+
+class FakeSource:
+ def __init__(self, entities=None, error=None):
+ self._entities = entities or []
+ self._error = error
+
+ def sync(self):
+ if self._error:
+ raise self._error
+ return self._entities
+
+
+class FakeEntityRepo:
+ def __init__(self, existing_ids=(), fail_on=()):
+ self.saved = []
+ self.updated = []
+ self._existing = set(existing_ids)
+ self._fail_on = set(fail_on)
+
+ def get_by_odoo_id(self, odoo_id):
+ return FakeEntity(odoo_id) if odoo_id in self._existing else None
+
+ def save(self, entity):
+ if entity.odoo_id in self._fail_on:
+ raise ValueError(f"save failed for {entity.odoo_id}")
+ self.saved.append(entity.odoo_id)
+
+ def update(self, entity):
+ if entity.odoo_id in self._fail_on:
+ raise ValueError(f"update failed for {entity.odoo_id}")
+ self.updated.append(entity.odoo_id)
+
+
+class FakeSyncRunRepo:
+ def __init__(self):
+ self.logs = []
+ self.finished = None
+ self._seq = 0
+
+ def create(self, run):
+ self._seq += 1
+ run.id = self._seq
+ return run
+
+ def finish(self, run):
+ self.finished = run
+
+ def add_log(self, log):
+ self.logs.append(log)
+
+
+def _use_case(source, repo, run_repo):
+ return SyncEntityUseCase("contacts", source, repo, run_repo)
+
+
+def test_all_new_records_are_saved():
+ repo = FakeEntityRepo()
+ run = _use_case(
+ FakeSource([FakeEntity(1), FakeEntity(2), FakeEntity(3)]),
+ repo,
+ FakeSyncRunRepo(),
+ ).execute()
+
+ assert run.records_received == 3
+ assert run.records_saved == 3
+ assert run.records_updated == 0
+ assert run.records_failed == 0
+ assert run.status == SyncStatus.SUCCESS
+ assert repo.saved == [1, 2, 3]
+
+
+def test_existing_records_are_updated_not_duplicated():
+ repo = FakeEntityRepo(existing_ids={1, 3})
+ run = _use_case(
+ FakeSource([FakeEntity(1), FakeEntity(2), FakeEntity(3)]),
+ repo,
+ FakeSyncRunRepo(),
+ ).execute()
+
+ assert run.records_saved == 1
+ assert run.records_updated == 2
+ assert run.status == SyncStatus.SUCCESS
+ assert repo.saved == [2]
+ assert repo.updated == [1, 3]
+
+
+def test_record_error_is_isolated_logged_and_processing_continues():
+ repo = FakeEntityRepo(fail_on={2})
+ run_repo = FakeSyncRunRepo()
+ run = _use_case(
+ FakeSource([FakeEntity(1), FakeEntity(2), FakeEntity(3), FakeEntity(4)]),
+ repo,
+ run_repo,
+ ).execute()
+
+ assert run.records_received == 4
+ assert run.records_saved == 3
+ assert run.records_failed == 1
+ assert run.status == SyncStatus.PARTIAL
+ # record 4 was processed even though record 2 failed
+ assert repo.saved == [1, 3, 4]
+ assert len(run_repo.logs) == 1
+ assert run_repo.logs[0].odoo_id == 2
+ assert run_repo.logs[0].level == SyncLogLevel.ERROR
+
+
+def test_all_records_failing_yields_failed_status():
+ repo = FakeEntityRepo(fail_on={1, 2})
+ run_repo = FakeSyncRunRepo()
+ run = _use_case(
+ FakeSource([FakeEntity(1), FakeEntity(2)]),
+ repo,
+ run_repo,
+ ).execute()
+
+ assert run.records_failed == 2
+ assert run.records_saved == 0
+ assert run.status == SyncStatus.FAILED
+ assert len(run_repo.logs) == 2
+
+
+def test_empty_source_is_success():
+ run = _use_case(
+ FakeSource([]), FakeEntityRepo(), FakeSyncRunRepo()
+ ).execute()
+
+ assert run.records_received == 0
+ assert run.status == SyncStatus.SUCCESS
+
+
+def test_fetch_failure_fails_the_run_and_is_logged():
+ run_repo = FakeSyncRunRepo()
+ run = _use_case(
+ FakeSource(error=RuntimeError("odoo down")),
+ FakeEntityRepo(),
+ run_repo,
+ ).execute()
+
+ assert run.status == SyncStatus.FAILED
+ assert run.records_received == 0
+ assert len(run_repo.logs) == 1
+ assert run_repo.logs[0].level == SyncLogLevel.ERROR
diff --git a/tests/domain/entities/test_contact.py b/tests/domain/entities/test_contact.py
new file mode 100644
index 0000000..50d565c
--- /dev/null
+++ b/tests/domain/entities/test_contact.py
@@ -0,0 +1,18 @@
+from app.domain.entities.contact import Contact
+
+
+def test_create_contact():
+ contact = Contact(
+ odoo_id=1,
+ name="Ali Ahmadi",
+ email="ali@example.com",
+ phone="02112345678",
+ mobile="09121234567",
+ )
+
+ assert contact.odoo_id == 1
+ assert contact.name == "Ali Ahmadi"
+ assert contact.email == "ali@example.com"
+ assert contact.phone == "02112345678"
+ assert contact.mobile == "09121234567"
+
\ No newline at end of file
diff --git a/tests/domain/entities/test_product.py b/tests/domain/entities/test_product.py
new file mode 100644
index 0000000..14899e5
--- /dev/null
+++ b/tests/domain/entities/test_product.py
@@ -0,0 +1,19 @@
+from decimal import Decimal
+
+from app.domain.entities.product import Product
+
+
+def test_create_product():
+ product = Product(
+ odoo_id=10,
+ name="Laptop Dell",
+ internal_reference="LAP-001",
+ sale_price=Decimal("1500.00"),
+ product_type="product",
+ )
+
+ assert product.odoo_id == 10
+ assert product.name == "Laptop Dell"
+ assert product.internal_reference == "LAP-001"
+ assert product.sale_price == Decimal("1500.00")
+ assert product.product_type == "product"
diff --git a/tests/domain/entities/test_sale_order_line.py b/tests/domain/entities/test_sale_order_line.py
new file mode 100644
index 0000000..777a75f
--- /dev/null
+++ b/tests/domain/entities/test_sale_order_line.py
@@ -0,0 +1,21 @@
+from decimal import Decimal
+
+from app.domain.entities.sale_order_line import SaleOrderLine
+
+
+def test_create_sale_order_line():
+ line = SaleOrderLine(
+ odoo_id=500,
+ sale_order_id=100,
+ product_id=10,
+ quantity=2,
+ unit_price=Decimal("100.00"),
+ subtotal=Decimal("200.00"),
+ )
+
+ assert line.odoo_id == 500
+ assert line.sale_order_id == 100
+ assert line.product_id == 10
+ assert line.quantity == 2
+ assert line.unit_price == Decimal("100.00")
+ assert line.subtotal == Decimal("200.00")
\ No newline at end of file
diff --git a/tests/domain/entities/test_sale_roder.py b/tests/domain/entities/test_sale_roder.py
new file mode 100644
index 0000000..1476152
--- /dev/null
+++ b/tests/domain/entities/test_sale_roder.py
@@ -0,0 +1,22 @@
+from datetime import datetime
+from decimal import Decimal
+
+from app.domain.entities.sale_order import SaleOrder
+
+
+def test_create_sale_order():
+ order = SaleOrder(
+ odoo_id=100,
+ order_number="SO0001",
+ customer_id=1,
+ order_date=datetime(2026, 7, 23),
+ state="sale",
+ total_amount=Decimal("2000.00"),
+ )
+
+ assert order.odoo_id == 100
+ assert order.order_number == "SO0001"
+ assert order.customer_id == 1
+ assert order.state == "sale"
+ assert order.total_amount == Decimal("2000.00")
+
\ No newline at end of file
diff --git a/tests/domain/entities/test_sync_log.py b/tests/domain/entities/test_sync_log.py
new file mode 100644
index 0000000..c77c703
--- /dev/null
+++ b/tests/domain/entities/test_sync_log.py
@@ -0,0 +1,17 @@
+from app.domain.entities.sync_log import SyncLog, SyncLogLevel
+
+
+def test_create_sync_log():
+ log = SyncLog(
+ sync_run_id=1,
+ level=SyncLogLevel.ERROR,
+ message="failed to save record",
+ odoo_id=42,
+ )
+
+ assert log.sync_run_id == 1
+ assert log.level == SyncLogLevel.ERROR
+ assert log.message == "failed to save record"
+ assert log.odoo_id == 42
+ assert log.created_at is None
+ assert log.id is None
diff --git a/tests/domain/entities/test_sync_run.py b/tests/domain/entities/test_sync_run.py
new file mode 100644
index 0000000..6e3059d
--- /dev/null
+++ b/tests/domain/entities/test_sync_run.py
@@ -0,0 +1,21 @@
+from datetime import datetime
+
+from app.domain.entities.sync_run import SyncRun, SyncStatus
+
+
+def test_create_sync_run():
+ started = datetime(2026, 7, 24, 10, 0, 0)
+ run = SyncRun(
+ operation_type="contacts",
+ started_at=started,
+ )
+
+ assert run.operation_type == "contacts"
+ assert run.started_at == started
+ assert run.status == SyncStatus.RUNNING
+ assert run.records_received == 0
+ assert run.records_saved == 0
+ assert run.records_updated == 0
+ assert run.records_failed == 0
+ assert run.finished_at is None
+ assert run.id is None
diff --git a/tests/infrastructure/database/repositories/test_repositories.py b/tests/infrastructure/database/repositories/test_repositories.py
new file mode 100644
index 0000000..9935fef
--- /dev/null
+++ b/tests/infrastructure/database/repositories/test_repositories.py
@@ -0,0 +1,166 @@
+from datetime import datetime
+from decimal import Decimal
+
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import StaticPool
+
+import app.infrastructure.database.models # noqa: F401 (register metadata)
+from app.infrastructure.database.models.base import Base
+from app.infrastructure.database.models.sync_run import SyncRunModel
+from app.infrastructure.database.models.sync_log import SyncLogModel
+from app.domain.entities.contact import Contact
+from app.domain.entities.product import Product
+from app.domain.entities.sale_order import SaleOrder
+from app.domain.entities.sale_order_line import SaleOrderLine
+from app.domain.entities.sync_run import SyncRun, SyncStatus
+from app.domain.entities.sync_log import SyncLog, SyncLogLevel
+from app.infrastructure.database.repositories.contact_repository import (
+ SQLAlchemyContactRepository,
+)
+from app.infrastructure.database.repositories.product_repository import (
+ SQLAlchemyProductRepository,
+)
+from app.infrastructure.database.repositories.sale_order_repository import (
+ SQLAlchemySaleOrderRepository,
+)
+from app.infrastructure.database.repositories.sale_order_line_repository import (
+ SQLAlchemySaleOrderLineRepository,
+)
+from app.infrastructure.database.repositories.sync_run_repository import (
+ SQLAlchemySyncRunRepository,
+)
+
+
+class InMemoryConnection:
+ """Test double for IDBConnection backed by shared in-memory SQLite."""
+
+ def __init__(self):
+ self._engine = create_engine(
+ "sqlite://",
+ connect_args={"check_same_thread": False},
+ poolclass=StaticPool,
+ )
+ Base.metadata.create_all(self._engine)
+ self._session_factory = sessionmaker(bind=self._engine)
+
+ def get_session(self):
+ return self._session_factory()
+
+ def get_session_generator(self):
+ session = self.get_session()
+ try:
+ yield session
+ finally:
+ session.close()
+
+ def dispose(self):
+ self._engine.dispose()
+
+
+@pytest.fixture
+def db():
+ conn = InMemoryConnection()
+ yield conn
+ conn.dispose()
+
+
+def test_contact_repository_save_get_update(db):
+ repo = SQLAlchemyContactRepository(db)
+
+ assert repo.get_by_odoo_id(1) is None
+
+ repo.save(Contact(odoo_id=1, name="Ali", email="a@x.com",
+ phone="021", mobile="0912"))
+ assert repo.get_by_odoo_id(1) == Contact(
+ odoo_id=1, name="Ali", email="a@x.com", phone="021", mobile="0912"
+ )
+
+ repo.update(Contact(odoo_id=1, name="Ali Updated", email="new@x.com",
+ phone="022", mobile="0913"))
+ updated = repo.get_by_odoo_id(1)
+ assert updated.name == "Ali Updated"
+ assert updated.email == "new@x.com"
+
+
+def test_product_repository_save_get_update(db):
+ repo = SQLAlchemyProductRepository(db)
+
+ repo.save(Product(odoo_id=1, name="Laptop", internal_reference="LAP-001",
+ sale_price=Decimal("2500.00"), product_type="consu"))
+ product = repo.get_by_odoo_id(1)
+ assert product.name == "Laptop"
+ assert product.sale_price == Decimal("2500.00")
+
+ repo.update(Product(odoo_id=1, name="Laptop v2",
+ internal_reference="LAP-001",
+ sale_price=Decimal("2600.00"), product_type="consu"))
+ assert repo.get_by_odoo_id(1).sale_price == Decimal("2600.00")
+
+
+def test_sale_order_repository_save_get_update(db):
+ repo = SQLAlchemySaleOrderRepository(db)
+ dt = datetime(2026, 7, 24, 10, 0, 0)
+
+ repo.save(SaleOrder(odoo_id=1, order_number="S00001", customer_id=7,
+ order_date=dt, state="sale",
+ total_amount=Decimal("100.00")))
+ order = repo.get_by_odoo_id(1)
+ assert order.order_number == "S00001"
+ assert order.state == "sale"
+
+ repo.update(SaleOrder(odoo_id=1, order_number="S00001", customer_id=7,
+ order_date=dt, state="done",
+ total_amount=Decimal("100.00")))
+ assert repo.get_by_odoo_id(1).state == "done"
+
+
+def test_sale_order_line_repository_save_get_update(db):
+ repo = SQLAlchemySaleOrderLineRepository(db)
+
+ repo.save(SaleOrderLine(odoo_id=1, sale_order_id=10, product_id=20,
+ quantity=2.0, unit_price=Decimal("50.00"),
+ subtotal=Decimal("100.00")))
+ line = repo.get_by_odoo_id(1)
+ assert line.sale_order_id == 10
+ assert line.quantity == 2.0
+
+ repo.update(SaleOrderLine(odoo_id=1, sale_order_id=10, product_id=20,
+ quantity=5.0, unit_price=Decimal("50.00"),
+ subtotal=Decimal("250.00")))
+ assert repo.get_by_odoo_id(1).quantity == 5.0
+
+
+def test_sync_run_repository_lifecycle(db):
+ repo = SQLAlchemySyncRunRepository(db)
+
+ run = repo.create(SyncRun(operation_type="contacts",
+ started_at=datetime.now()))
+ assert run.id is not None
+
+ repo.add_log(SyncLog(sync_run_id=run.id, level=SyncLogLevel.ERROR,
+ message="boom", odoo_id=42))
+
+ run.records_received = 5
+ run.records_saved = 4
+ run.records_failed = 1
+ run.finished_at = datetime.now()
+ run.status = SyncStatus.PARTIAL
+ repo.finish(run)
+
+ session = db.get_session()
+ model = session.get(SyncRunModel, run.id)
+ assert model.status == "partial"
+ assert model.records_failed == 1
+ assert model.finished_at is not None
+
+ logs = (
+ session.query(SyncLogModel)
+ .filter_by(sync_run_id=run.id)
+ .all()
+ )
+ assert len(logs) == 1
+ assert logs[0].level == "error"
+ assert logs[0].odoo_id == 42
+ session.close()
-
-Book land accounting feature
- -
این ماژول امکانات حسابداری را اضافه میکند
-Table of contents
-
-
-
--
-
- Known issues / Roadmap -
- V2.0.0 -
- Changelog -
- Bug Tracker -
- Credits
-
-
- Authors -
- Maintainers -
-
-
-V2.0.0
--
-
- connect to invoice -
-
-Changelog
-
-
-Bug Tracker
-Bugs are tracked on GitHub Issues. -In case of trouble, please check there if your issue has already been reported. -If you spotted it first, help us to smash it by providing a detailed and welcomed -feedback.
-Do not contact contributors directly about support or help with technical issues.
-
-
-Credits
-
-
-Authors
--
-
- Odoonix -
-
-Maintainers
-This module is part of the odoonix/education project on GitHub.
-You are welcome to contribute.
-