Persistance des onglets ouverts : ordre et sélection
Avant-propos
Python : utiliser les fonctions lambda pour passer des arguments aux fonctions de callback.
Description
Lorsque la fenêtre Main s'affiche, elle devrait être dans le même état général que lors de sa dernière fermeture.
L'état général est un ensemble d'états :
utils.py > Utils.save_tabs()
← Sauvegarde.utils.py > Utils.restore_tabs()
← Restauration.l_tabs = [gr2, gr0, gr3, gr1]
# ← liste ordonnée des noms de graphes (c'est un exemple).active_tab = 2
# ← int: Index de l'onglet actif (commence à 0)./pc/params.conf
save_tabs()
: Créer la méthode utils.py > Utils.save_tabs()
restore_tabs()
: Créer la méthode utils.py > Utils.restore_tabs()
print()
provisoire pour vous assurer qu'elles sont bien appelées.save_tabs()
lors de la fermeture d'un onglet (à la fin de main.py > UiMain.close_graph()
).
save_tabs()
lors de l'ouverture ou du déplacement d'un onglet (sur l'événement currentChanged()
).
restore_tabs()
au lancement du programme, dans main.py > UiMain.__init__()
Vérification
test_memo_tabs()
. Remplacer tout le code de test_main.py
par celui-ci :
from PyQt5.QtWidgets import QApplication, QTabBar
from PyQt5.QtCore import QSettings, QRect, QTimer, Qt
from PyQt5.QtTest import QTest
from pc.main import UiMain, NewGraph
import pytest
import sys
import os
import random
class Main(UiMain):
""" Classe dérivée de la fenêtre à tester. """
def __init__(self, normal, dockable):
super().__init__()
self.premier_passage = normal is not None
self.dockable = dockable
self.sauvage = normal is False
self.settings_ante = QSettings(f"{os.getcwd()}{os.sep}ante.conf", QSettings.IniFormat)
def moveEvent(self, ev):
if not self.dockable:
super().moveEvent(ev)
def resizeEvent(self, ev):
if not self.dockable:
super().resizeEvent(ev)
def closeEvent(self, ev):
if self.premier_passage:
""" Premier passage : Mémorisation des états. """
self.settings_ante.setValue('Geometrie', self.geometry())
self.settings_ante.setValue('dockNodes visible', self.dockNodes.isVisible())
self.settings_ante.setValue('dockNodes détaché', self.dockNodes.isFloating())
self.settings_ante.setValue('dockNodes géométrie', self.dockNodes.geometry())
self.settings_ante.setValue('dockParams visible', self.dockParams.isVisible())
self.settings_ante.setValue('dockParams détaché', self.dockParams.isFloating())
self.settings_ante.setValue('dockParams géométrie', self.dockParams.geometry())
if not self.sauvage:
""" Non exécuté en mode 'sauvage'. """
super().closeEvent(ev)
# @pytest.mark.skip() # Commenter pour tester
class TestMain:
g_appli = QApplication(sys.argv)
tempo = QTimer()
tempo.setSingleShot(True)
@staticmethod
@pytest.fixture(scope="session", autouse=True)
def cleanup(request):
""" Appel final pour effacer les fichiers temporaires créés par les tests. """
def remove_files():
test_folder = os.getcwd() + os.sep
backups_folder = test_folder.replace('tests', 'backups')
files = [f"{test_folder}ante.conf", f"{test_folder}params.conf"]
folders = ['Test creation de graphe', 'test_graph_1', 'test_graph_2', 'test_graph_3']
for file in files:
if os.path.isfile(file):
os.remove(file)
for folder in folders:
if os.path.isdir(backups_folder + folder):
os.rmdir(backups_folder + folder)
request.addfinalizer(remove_files)
@staticmethod
def get_rect(t_x, t_y, t_w, t_h):
""" Retourne un QRect aléatoire. """
return QRect(random.randint(*t_x), random.randint(*t_y), random.randint(*t_w), random.randint(*t_h))
@staticmethod
def open_window(normal=None, dockable=False):
win = Main(normal, dockable)
if normal is not None:
win.settings_ante.clear()
win.show()
return win
def connect(self, function):
try:
self.tempo.timeout.disconnect()
except TypeError:
pass
self.tempo.timeout.connect(function)
def fenetre_modif(self, normal):
win = self.open_window(normal)
win.setGeometry(self.get_rect((50, 800), (50, 800), (300, 800), (300, 800)))
self.connect(win.close)
self.tempo.start(300) # {x}ms : On laisse le temps à la fenêtre main de mémoriser ses états.
""" Boucle d'exécution. """
self.g_appli.exec()
def fenetre_assert(self):
def geometry(qrect):
return f"x = {qrect.x()}, y = {qrect.y()}, largeur = {qrect.width()}, hauteur = {qrect.height()}"
win = self.open_window()
self.connect(win.close)
self.tempo.start(50)
geometry_ante = win.settings_ante.value('Geometrie', QRect(200, 200, 800, 600))
geometry_now = win.geometry()
print(
"\n- La fenêtre doit apparaître avec la même géométrie (taille et position) "
"que lors de sa dernière fermeture."
f"\n- Géométrie à la dernière fermeture : {geometry(geometry_ante)}."
f"\n- Géométrie à l'ouverture actuelle : {geometry(geometry_now)}."
)
assert geometry_now == geometry_ante
""" Boucle d'exécution. """
self.g_appli.exec()
""" *************************************************************************************** """
""" LES TESTS """
""" *************************************************************************************** """
@pytest.mark.skip() # Commenter pour tester
def test_ferme_normal(self):
""" Phase 1 : Affichage de la fenêtre, plusieurs déplacements et changements de taille, aléatoires.
Fermeture de la fenêtre, mémorisation de sa géométrie. """
self.fenetre_modif(normal=True) # True = Fermeture normale.
""" Phase 2: Réouverture de la fenêtre, lecture de sa géométrie, comparaison. """
self.fenetre_assert()
@pytest.mark.skip() # Commenter pour tester
def test_ferme_sauvage(self):
self.fenetre_modif(normal=False) # False = Fermeture sauvage.
self.fenetre_assert()
@pytest.mark.skip() # Commenter pour tester
def test_dock_state(self):
def update_dock():
self.connect(win.close)
self.tempo.start(500) # {x} ms : On laisse le temps à la fenêtre main de mémoriser ses états.
""" Modification des états des dockables, de façon aléatoire. """
for o_dock in [win.dockNodes, win.dockParams]:
x, y = win.x() + win.width() // 2, win.y() + win.height() // 2
o_dock.setFloating(random.choice([False, True]))
if o_dock.isFloating():
o_dock.setGeometry(self.get_rect((x - 50, x + 50), (y - 50, y + 50), (50, 400), (50, 400)))
else:
o_dock.setFixedWidth(random.randint(82, 200))
def state_dock():
self.connect(win.close) # Obligatoirement avant les asserts.
self.tempo.start(50)
""" Vérification des résultats. """
msg = 'DockNodes : Flottant (détaché).'
assert win.dockNodes.isFloating() == win.settings_ante.value('dockNodes détaché'), msg
res, qrect_now, qrect_ante = 0, win.dockNodes.geometry().getRect(), win.settings_ante.value(
'dockNodes géométrie').getRect()
if win.dockNodes.isFloating():
msg = 'DockNodes : Géométrie (x, y, w, h).'
for i in range(4):
""" Tolérence : on accepte 3 bonnes valeurs sur 4. """
res += qrect_now[i] == qrect_ante[i]
assert res > 2, msg
else:
msg = 'DockNodes : Largeur.' # 0=x, 1=y, 2=width, 3=height
assert qrect_now[2] == qrect_ante[2], msg # [2]=width
msg = 'DockParams : Flottant (détaché).'
assert win.dockParams.isFloating() == win.settings_ante.value('dockParams détaché'), msg
res, qrect_now, qrect_ante = 0, win.dockParams.geometry().getRect(), win.settings_ante.value(
'dockParams géométrie').getRect()
if win.dockParams.isFloating():
msg = 'DockParams : Géométrie (x, y, w, h).'
for i in range(4):
res += qrect_now[i] == qrect_ante[i]
assert res > 2, msg
else:
msg = 'DockParams : Largeur.'
assert qrect_now[2] == qrect_ante[2], msg
""" Phase 1 : Modification aléatoire des dockables (détaché ou attaché, position, taille, visibilité). """
win = self.open_window(normal=True)
update_dock()
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
""" Phase 2 : Ouverture fenêtre, lecture de l'état des dockables, assertions et fermeture. """
win = self.open_window()
state_dock()
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
@pytest.mark.skip() # Commenter pour tester
def test_dock_visible(self):
def update_dock():
self.connect(win.close)
self.tempo.start(300) # {x} ms : On laisse le temps à la fenêtre main de mémoriser ses états.
""" Modification des visibilités, de façon aléatoire. """
for o_dock in [win.dockNodes, win.dockParams]:
o_dock.setVisible(random.choice([False, True]))
def state_dock():
self.connect(win.close)
self.tempo.start(50) # Obligatoirement avant les asserts.
""" Vérification des résultats. """
try:
msg = 'DockNodes : Visibilité.'
assert win.dockNodes.isVisible() == win.settings_ante.value('dockNodes visible'), msg
msg = 'DockParams : Visibilité.'
assert win.dockParams.isVisible() == win.settings_ante.value('dockParams visible'), msg
except (Exception,):
pass
for i in range(4):
""" Phase 1 : Modification aléatoire des dockables (détaché ou attaché, position, taille, visibilité). """
win = self.open_window(normal=True, dockable=True)
update_dock()
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
""" Phase 2 : Ouverture fenêtre, lecture de l'état des dockables, assertions et fermeture. """
win = self.open_window()
state_dock()
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
@pytest.mark.skip()
def test_new_graph(self):
def write():
""" Écriture animée. """
new_graph.graph_name.setText(graph_name[:indx[0]])
indx[0] += 1
if indx[0] <= len(graph_name):
""" Écriture +1 caractère chaque xxx ms. """
self.tempo.start(100)
else:
""" Simulation de clic sur le bouton 'Ok'. """
self.connect(new_graph.accept)
self.tempo.start(1000)
graph_name = 'Test creation de graphe'
bk_folder = f"{os.getcwd()}{os.sep}..{os.sep}backups"
created_folder = bk_folder + os.sep + graph_name
win = self.open_window()
new_graph = NewGraph(win) # Type QDialog
indx = [0]
self.connect(write)
self.tempo.start()
new_graph.exec()
self.connect(win.close)
self.tempo.start(50) # Obligatoirement avant les asserts.
self.g_appli.exec()
""" Le dossier 'D:/Robot/backups/Test creation de graphe' doit avoir été créé. Vérification : """
assert os.path.isdir(created_folder), f"Le dossier '{created_folder}' n'a pas été créé."
@pytest.mark.skip()
def test_open_graph(self):
""" - État initial : à la création, il n'y a aucun onglet. Plus tard, il pourrait y en avoir un ou plusieurs.
- Création de 3 dossiers supplémentaires dans /backups : /test_graph_1, /test_graph_2 et /test_graph_3.
- Pour chaque dossier, appel de la méthode open_graph() :
- On vérifie que le dernier ajouté est sélectionné.
- On vérifie que la fenêtre Main a 3 onglets de plus dans sa zône centrale.
- On vérifie qu'ils sont déplaçables à la souris par drag & drop.
- On vérifie également qu'ils possèdent la croix de fermeture.
- Tentative d'ajout de /test_graph_2, qui est déjà présent :
- On vérifie le rejet de doublons.
- On vérifie néanmoins qu'il est sélectionné.
- Fermeture des 3 onglets => Vérification.
- Suppression des 3 dossiers de /backups.
"""
""" Ouverture et géométrie de la fenêtre Main. """
win = self.open_window()
win.setGeometry(QRect(100, 100, 900, 400))
self.connect(win.close)
self.tempo.start(800) # Fermeture différée.
""" Fermeture éventuelle des onglets. """
for i in range(3):
win.close_graph(0)
""" Création et affichage des onglets de 3 graphes. """
for i, dir_name in enumerate(['test_graph_1', 'test_graph_2', 'test_graph_3']):
created_folder = os.path.abspath(f"{os.getcwd()}{os.sep}..{os.sep}backups{os.sep}{dir_name}")
os.makedirs(created_folder, exist_ok=True) # Création dossier. Si ce dossier existe, pas d'erreur renvoyée.
win.open_graph(dir_name)
assert win.tabGraphs.currentIndex() == i, "L'onglet sélectionné n'est pas le dernier ajouté."
""" Asserts. """
nb_now = win.tabGraphs.count() # Le nombre d'onglets a augmenté de 3.
vrai = True
assert nb_now == 3, "L'ajout d'onglets a échoué."
assert win.tabGraphs.isMovable() == vrai, "Les onglets ne sont pas déplaçables à la souris."
assert win.tabGraphs.tabsClosable() == vrai, "Les onglets ne possèdent pas la croix de fermeture."
""" Tentative d'ouverture d'un graphe déjà ouvert. """
win.open_graph("test_graph_2")
assert nb_now == win.tabGraphs.count(), "La gestion des doublons ne fonctionne pas."
assert win.tabGraphs.currentIndex() == 1, "L'onglet sélectionné n'est pas celui du graphe choisi."
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
@pytest.mark.skip()
def test_close_graph(self):
""" - Ouverture de la fenêtre Main.
- Création de 3 dossiers dans /backups/ (qui contiendront les graphes).
- Pour chaque dossier, création d'un onglet dans la zône principale.
- Fermeture successive des 3 onglets.
- A chaque fois, on compte le nombre d'onglets restant.
- Les résultats à obtenir : 2, 1 puis 0.
"""
""" Ouverture et géométrie de la fenêtre Main. """
win = self.open_window()
win.setGeometry(QRect(200, 200, 900, 400))
self.connect(win.close)
self.tempo.start(800) # Fermeture différée.
""" Création et affichage des onglets de 3 graphes. """
for i, dir_name in enumerate(['test_graph_1', 'test_graph_2', 'test_graph_3']):
created_folder = os.path.abspath(f"{os.getcwd()}{os.sep}..{os.sep}backups{os.sep}{dir_name}")
os.makedirs(created_folder, exist_ok=True) # Création dossier. Si ce dossier existe, pas d'erreur renvoyée.
win.open_graph(dir_name)
nb_ante = win.tabGraphs.count()
""" Fermeture successive des 3 onglets. """
for i in range(1, 4):
close_button = win.tabGraphs.tabBar().tabButton(0, QTabBar.RightSide)
QTest.mouseClick(close_button, Qt.LeftButton, Qt.NoModifier)
nb_now = win.tabGraphs.count()
assert nb_now == nb_ante - i, "La fermeture des onglets a échoué."
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
# @pytest.mark.skip()
def test_memo_tabs(self):
""" - Phase 1 :
- Ouverture de la fenêtre Main.
- Fermeture éventuelle des onglets.
- Mélange de la liste ['test_graph_1', 'test_graph_2', 'test_graph_3']
- Création de 3 dossiers, selon la liste, dans /backups/ (qui contiendront les graphes).
- Pour chaque dossier, création d'un onglet dans la zône principale.
- Activation d'un aonglet au hasard.
- Mémorisation de l'état des onglets.
- Fermeture de la fenêtre Main.
- Phase 2 :
- Ouverture de la fenêtre Main.
- Assert : Comparaison de l'état des onglets avec celui mémorisé.
- Fermeture de la fenêtre Main, fin du test.
"""
""" Ouverture et géométrie de la fenêtre Main. """
win = self.open_window()
win.setGeometry(QRect(200, 200, 900, 400))
self.connect(win.close)
""" Fermeture éventuelle des onglets. """
for i in range(3):
win.close_graph(0)
""" Phase 1 : Création et affichage des onglets de 3 graphes. """
l_tabs_ante = ['test_graph_1', 'test_graph_2', 'test_graph_3']
random.shuffle(l_tabs_ante)
current_index_ante = random.randint(0, 2)
for i, dir_name in enumerate(l_tabs_ante):
created_folder = os.path.abspath(f"{os.getcwd()}{os.sep}..{os.sep}backups{os.sep}{dir_name}")
os.makedirs(created_folder, exist_ok=True) # Création dossier. Si ce dossier existe, pas d'erreur renvoyée.
win.open_graph(dir_name)
win.tabGraphs.setCurrentIndex(current_index_ante)
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.tempo.start(800) # Fermeture différée.
self.g_appli.exec()
""" Phase 2 : Ouverture de la fenêtre Main. """
win = self.open_window()
win.setGeometry(QRect(200, 200, 900, 400))
self.connect(win.close)
l_tabs_now = []
for i in range(win.tabGraphs.count()):
l_tabs_now.append(win.tabGraphs.widget(i).graph_name)
current_index_now = win.tabGraphs.currentIndex()
""" Asserts. """
fo = 'Fermeture, puis ouverture : '
if current_index_now >= 0:
assert current_index_now == current_index_ante, fo + "L'onglet sélectionné n'est pas le même."
assert len(l_tabs_now) == len(l_tabs_ante), fo + "Le nombre d'onglets n'est pas le même."
assert l_tabs_now == l_tabs_ante, fo + "L'ordre des onglets n'est pas le même."
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.tempo.start(800) # Fermeture différée.
self.g_appli.exec()
@pytest.mark.skip()
), sauf le dernier.Bon courage et bon coding !
Snippets
Bonjour les codeurs !