123 lines
4.1 KiB
Python
123 lines
4.1 KiB
Python
"""L'assemblage commun aux deux lanceurs — sans jamais ouvrir de fenêtre ni de micro.
|
|
|
|
Le transcripteur réel charge un modèle (opération lourde, parfois absente sur
|
|
la machine de test) : on injecte donc toujours un `choisir_transcripteur` et
|
|
un `detecter_moteur` doublés. L'overlay réel (Cocoa ou Qt), lui, est fait pour
|
|
être construit sans effet visible tant que `show()` n'est pas appelé — les
|
|
tests le laissent donc réel, et vérifient justement qu'aucune fenêtre ne
|
|
s'affiche.
|
|
"""
|
|
import os
|
|
import tempfile
|
|
|
|
from assemblage import acquerir_verrou, construire
|
|
from controller import ZonzaController
|
|
from systeme import choisir_systeme
|
|
|
|
|
|
class _TranscripteurFactice:
|
|
def __init__(self, modele, langue, amorce):
|
|
self.modele = modele
|
|
self.langue = langue
|
|
self.amorce = amorce
|
|
|
|
def warmup(self):
|
|
pass
|
|
|
|
def transcrire(self, audio):
|
|
return "texte factice"
|
|
|
|
|
|
def _choisir_transcripteur_factice(nom, modele, langue, amorce):
|
|
return _TranscripteurFactice(modele, langue, amorce)
|
|
|
|
|
|
def _tmp_verrou():
|
|
return os.path.join(tempfile.mkdtemp(), "instance.lock")
|
|
|
|
|
|
# --- construire() ------------------------------------------------------------
|
|
|
|
def test_construire_rend_un_controleur_cable_sur_les_bons_objets():
|
|
resultat = construire(
|
|
plateforme="darwin",
|
|
detecter_moteur=lambda: "mlx",
|
|
choisir_transcripteur=_choisir_transcripteur_factice,
|
|
)
|
|
assert isinstance(resultat["controller"], ZonzaController)
|
|
# le contrôleur pointe vers CE système, CE transcripteur, CET overlay —
|
|
# pas une copie recréée à côté.
|
|
assert resultat["controller"].systeme is resultat["systeme"]
|
|
assert resultat["controller"].transcripteur is resultat["transcripteur"]
|
|
assert resultat["controller"].pulse is resultat["overlay"]
|
|
assert isinstance(resultat["transcripteur"], _TranscripteurFactice)
|
|
|
|
|
|
def test_construire_fonctionne_aussi_pour_win32():
|
|
resultat = construire(
|
|
plateforme="win32",
|
|
detecter_moteur=lambda: "faster-cpu",
|
|
choisir_transcripteur=_choisir_transcripteur_factice,
|
|
)
|
|
from interface.qt import OverlayQt
|
|
assert isinstance(resultat["overlay"], OverlayQt)
|
|
|
|
|
|
def test_construire_transmet_run_on_main_et_on_state():
|
|
appels = []
|
|
resultat = construire(
|
|
plateforme="darwin",
|
|
run_on_main=lambda fn: appels.append(fn) or fn(),
|
|
on_state=lambda s: appels.append(s),
|
|
detecter_moteur=lambda: "mlx",
|
|
choisir_transcripteur=_choisir_transcripteur_factice,
|
|
)
|
|
resultat["controller"].on_state("recording")
|
|
assert "recording" in appels
|
|
|
|
|
|
def test_construire_ne_leve_aucune_erreur_de_config():
|
|
# validate_config(CONFIG) est appelée à l'intérieur : si elle levait, le
|
|
# test échouerait ici plutôt qu'au premier lancement réel.
|
|
construire(
|
|
plateforme="darwin",
|
|
detecter_moteur=lambda: "mlx",
|
|
choisir_transcripteur=_choisir_transcripteur_factice,
|
|
)
|
|
|
|
|
|
# --- acquerir_verrou() --------------------------------------------------------
|
|
|
|
def test_acquerir_verrou_rend_un_handle_pour_la_premiere_instance():
|
|
systeme = choisir_systeme()
|
|
handle = acquerir_verrou(systeme, _tmp_verrou())
|
|
assert handle is not None
|
|
|
|
|
|
def test_acquerir_verrou_refuse_une_seconde_instance():
|
|
systeme = choisir_systeme()
|
|
chemin = _tmp_verrou()
|
|
premier = acquerir_verrou(systeme, chemin)
|
|
assert premier is not None
|
|
assert acquerir_verrou(systeme, chemin) is None
|
|
|
|
|
|
def test_acquerir_verrou_sans_chemin_utilise_le_dossier_de_donnees_du_systeme():
|
|
# Pas de deuxième prise ici (on toucherait le verrou réel de l'utilisateur) :
|
|
# on vérifie seulement que le chemin par défaut est bien dérivé du système.
|
|
class _SystemeSonde:
|
|
def __init__(self):
|
|
self.chemin_demande = None
|
|
|
|
def dossier_donnees(self):
|
|
return "/tmp/zonza-sonde"
|
|
|
|
def acquerir_verrou_instance(self, chemin):
|
|
self.chemin_demande = chemin
|
|
return "handle-factice"
|
|
|
|
sonde = _SystemeSonde()
|
|
resultat = acquerir_verrou(sonde)
|
|
assert resultat == "handle-factice"
|
|
assert sonde.chemin_demande == "/tmp/zonza-sonde/instance.lock"
|