1. La pyramide des tests en Odoo 19

Avant d'écrire une ligne, il faut savoir où tu places chaque test. Odoo 19 te donne trois niveaux, et la règle est la même que partout : plus un test est bas, plus il est rapide, plus tu en écris.

Concrètement, tu choisis la classe de base selon ce que tu testes :

• TransactionCase — dès que tu touches à l'ORM, à mail.thread, à une contrainte, à un wizard : c'est le défaut. Chaque test tourne dans son propre savepoint, rollback automatique à la fin.
• HttpCase — dès que tu testes une route, un endpoint JSON, une session authentifiée. Hérite de TransactionCase et ajoute un serveur HTTP interne plus un browser headless.
• SingleTransactionCase — rare, mais utile pour des tests read-only qui partagent une fixture lourde sans rollback entre eux.

Les tours (scénarios Chrome headless via start_tour()) restent au sommet : puissants mais lents et fragiles. On ne les couvre pas dans cet article — la valeur rapide est plus bas.

3. Tester l'ORM — TransactionCase

Premier pattern : un test qui vérifie la séquence auto-attribuée à la création d'un ticket (pattern HLP/%(range_year)s/%(range_number)04d).

# odooskills_helpdesk/tests/test_ticket.py
from odoo.exceptions import ValidationError
from odoo.tests import tagged

from .common import HelpdeskCommon


@tagged('post_install', '-at_install')
class TestTicket(HelpdeskCommon):

    def _make_ticket(self, **kwargs):
        """Fabrique un ticket de test en désactivant les mails."""
        defaults = {
            'name': 'Test Ticket',
            'partner_id': self.partner_customer.id,
        }
        defaults.update(kwargs)
        return self.env['helpdesk.ticket'].with_context(skip_mail=True).create(defaults)

    def test_create_ticket_assigns_sequence(self):
        """create() doit remplir `reference` avec le format HLP/..."""
        ticket = self._make_ticket(name='Ticket séquence')
        self.assertTrue(ticket.reference, "La référence ne doit pas être vide.")
        self.assertIn('HLP/', ticket.reference,
                      "La référence doit commencer par HLP/.")

    def test_unlink_ticket_done_state_raises(self):
        """unlink() sur un ticket résolu doit lever ValidationError."""
        ticket = self._make_ticket(name='Ticket résolu non supprimable')
        ticket.action_resolve()
        self.env.flush_all()
        self.env.invalidate_all()

        with self.assertRaises(ValidationError):
            ticket.unlink()

Trois points-clés de rigueur v19 illustrés ici :

• Le helper _make_ticket() — tu vas créer des tickets dans presque tous tes tests. Le centraliser évite la répétition et t'oblige à passer skip_mail=True systématiquement.
• @tagged('post_install', '-at_install') — on exclut at_install (défaut) et on ajoute post_install. Les tests tourneront uniquement une fois toutes les dépendances chargées. Sans ça, un test qui utilise mail.template ou une séquence peut échouer faute de data démo disponible.
• self.env.flush_all() + self.env.invalidate_all() — à appeler après une mutation (action_resolve) si l'assertion suivante lit un champ tracké, calculé ou en cascade. En v19 c'est explicite : l'ORM ne flush plus implicitement avant une lecture.

Le module odooskills_helpdesk lève ValidationError (pas UserError) dans sa contrainte unlink. Toujours vérifier l'exception exacte dans le modèle métier — si tu captures la mauvaise, ton assertRaises passera silencieusement à travers.

5. Tester les controllers — HttpCase

Pour les routes type='http' (pages) et type='json' (endpoints API), on monte d'un cran : HttpCase démarre un vrai serveur HTTP interne et te donne url_open() pour le frapper.

# odooskills_helpdesk/tests/test_controllers.py
import json

from odoo.tests import HttpCase, tagged, new_test_user


@tagged('post_install', '-at_install')
class TestControllers(HttpCase):

    def setUp(self):
        super().setUp()
        # User interne avec password CONNU pour authenticate()
        self.test_user = new_test_user(
            self.env,
            login='ctrl_test_user',
            password='ctrl_test_pass_123',
            groups='base.group_user,base.group_system',
        )
        self.partner = self.env['res.partner'].create({
            'name': 'Client Controller Test',
            'email': 'ctrl.test@example.com',
        })
        self.ticket = self.env['helpdesk.ticket'].with_context(skip_mail=True).create({
            'name': 'Ticket Controller Test',
            'partner_id': self.partner.id,
        })
        self.env.flush_all()
        self.ticket_ref = self.ticket.reference

    def _db_header(self):
        """En-tête X-Odoo-Database nécessaire aux requêtes sans session."""
        return {'X-Odoo-Database': self.env.cr.dbname}

    def test_ticket_page_public_status_200(self):
        """GET /helpdesk/status/<ref> avec référence valide → HTTP 200."""
        response = self.url_open(
            f'/helpdesk/status/{self.ticket_ref}',
            headers=self._db_header(),
        )
        self.assertEqual(response.status_code, 200)
        self.assertIn(self.ticket_ref.encode(), response.content)

    def test_json_create_ticket_authenticated(self):
        """POST /api/v1/tickets avec action=create → retourne id et reference."""
        self.authenticate('ctrl_test_user', 'ctrl_test_pass_123')

        payload = {
            'jsonrpc': '2.0',
            'method': 'call',
            'params': {
                'action': 'create',
                'name': 'Ticket via API JSON test',
                'partner_id': self.partner.id,
                'channel': 'email',
            },
        }
        response = self.url_open(
            '/api/v1/tickets',
            data=json.dumps(payload),
            headers={'Content-Type': 'application/json'},
        )
        self.assertEqual(response.status_code, 200)
        result = response.json().get('result', {})
        self.assertIn('id', result)
        self.assertIn('reference', result)

Quatre pièges à connaître :

1. Ne pas hériter de HelpdeskCommon pour les tests HTTP. HttpCase active un mode registry spécifique qui entre en conflit avec une double base. Hérite directement de HttpCase, crée tes fixtures dans setUp.
2. Le JSON-RPC Odoo demande l'enveloppe complète. Tu envoies {"jsonrpc": "2.0", "method": "call", "params": {...}} et tu reçois {"jsonrpc": "2.0", "result": {...}} (ou {"error": {...}} en cas d'échec). Omettre jsonrpc ou method fait répondre le dispatcher avec une erreur peu lisible.
3. En-tête X-Odoo-Database sur les routes publiques testées sans session authentifiée. Sans lui, Odoo ne sait pas sur quelle base dispatcher la requête dans un test multi-base.
4. CSRF OFF par défaut en type='json', ON en type='http'. Pour poster en HTTP POST depuis un test, soit tu ajoutes csrf=False sur la route (et tu sécurises autrement), soit tu récupères le token csrf_token via self.session.

7. On exécute la suite

La commande CLI classique :

venv/bin/python odoo/odoo-bin \
  -c config/odoo.conf \
  --addons-path=odoo/addons,addons/odooskills-blog/modules \
  -d vs19_odooskills_test \
  -u odooskills_helpdesk \
  --test-enable \
  --test-tags=/odooskills_helpdesk \
  --stop-after-init \
  --log-level=test

Trois drapeaux importants :

• --test-enable — active l'exécution des tests Python du module.
• --test-tags=/odooskills_helpdesk — restreint aux tests de ce module uniquement (le préfixe / cible un module, pas un tag).
• --stop-after-init — arrête le serveur dès que les tests sont finis, idéal pour CI.

Voici ce que tu dois voir quand c'est vert :

9. Et quand un test échoue ?

Le meilleur moyen de comprendre la lecture d'un échec, c'est d'en voir un volontairement. Imagine que tu aies oublié tracking=True sur le champ state — ton test qui assertait la présence d'un message de tracking tombe rouge :

Trois réflexes avant de toucher au test lui-même :

1. Lis le traceback du bas vers le haut. La dernière ligne indique quoi. Les lignes précédentes indiquent où.
2. Exécute un seul test. --test-tags=/odooskills_helpdesk:TestTicket.test_write_resolve_tracked_field isole le test concerné.
3. Vérifie les flush/invalidate avant l'assertion. 90 % des flaky tests v19 viennent d'un cache non synchronisé.