STRATLEARN
Disponible

De QA fonctionnel à QA Automation Engineer

Le parcours complet

Un parcours de reconversion construit sur un vrai framework, de vraies user stories et une équipe QA simulée. Vous n’écoutez pas parler d’automatisation : vous automatisez quatre applications de bout en bout, et votre code est relu.

Objectifs opérationnels

Ce que vous saurez faire à l’issue de la formation.

  • Écrire et maintenir des tests automatisés en Java sur une application web réelle
  • Choisir le niveau de test pertinent — unitaire, API ou interface — et le justifier
  • Concevoir une architecture de framework qui reste maintenable à trois ans
  • Diagnostiquer et corriger un test instable sans recourir à la réexécution
  • Isoler les données de test pour rendre une suite exécutable en parallèle
  • Intégrer une suite à une chaîne d’intégration continue et en lire les rapports

Prérequis

Ce qu’il faut avoir avant de commencer.

  • Expérience du test fonctionnel : conception de cas de test, recette, non-régression
  • Aucun prérequis en développement — le module Java part de zéro
  • Un poste sur lequel vous pouvez installer un JDK et un éditeur

Public visé

À qui cette formation s’adresse.

  • Testeurs et testeuses fonctionnels souhaitant évoluer vers l’automatisation
  • Équipes QA amorçant l’industrialisation de leurs tests
  • Responsables qualité voulant comprendre ce que fait réellement un automaticien

Programme

15 modules · 348 chapitres · 69 rédigés

  1. M1

    Bienvenue et méthode de travail

    Le contrat pédagogique du parcours : ce qu’il couvre, comment travailler seul, à quel rythme, et où demander de l’aide quand ça bloque.

    • Bienvenue : ce que couvre ce parcours et comment il fonctionneLecture10 min
    • Apprendre seul : organiser ses sessions et la règle des 20 minutesAccès libreLecture12 min
    • Ce que ce parcours couvre, et ce qu’il ne couvre pasLecture10 min
    • Pré-requis : test de positionnementQuiz12 min
    • Le parcours module par module et la charge de travail réelleLecture10 min

  2. M2

    Votre poste de travail

    Installer une fois pour toutes le JDK 11, VS Code et Maven, vérifier que la chaîne fonctionne de bout en bout, et réparer les pannes d’installation les plus fréquentes.

    • Installer le JDK 11 et vérifier l’installationAccès libreExercice20 min
    • Installer VS Code et l’Extension Pack for Java, premier programmeAccès libreExercice20 min
    • Installer Maven et vérifier la chaîne complèteAccès libreExercice18 min
    • Dépannage : les 10 erreurs d’installation les plus fréquentesAccès libreRessource12 min

  3. M3

    Culture QA : le métier, le vocabulaire, les repères

    Situer l’automatisation dans le processus de test : les sept activités, les niveaux, les environnements, les types, et le vocabulaire employé au quotidien dans une équipe.

    • Le métier d’automaticien de tests : missions et compétencesAccès libreLecture15 min
    • Le processus de test : les sept activitésLecture15 min
    • Choisir ce que l’on automatise : le processus et ses critèresLecture12 min
    • Exercice : quels cas de test automatiser ?Exercice20 min
    • Niveaux de test, environnements et types de testLecture15 min
    • Exercice : remplir la matrice niveaux × typesExercice15 min
    • QM, QA, QC et Testing : qui fait quoiLecture12 min
    • Full Stack QA : l’étendue du métierLecture10 min
    • Ce qui change la QA : IA, tests continus, shift-left, cloudLecture15 min
    • Métiers et trajectoires après le Niveau 1Lecture10 min
    • Les ressources de référence, et comment chercher seulRessource12 min
    • Quiz de validation du moduleQuiz15 min

  4. M4

    Logique et algorithmique

    Poser un algorithme avant d’écrire la moindre ligne de code : variables, conditions, boucles, tableaux, fonctions et récursivité. Le socle que les modules Java et Selenium supposent acquis.

    • Pourquoi l’algorithmique quand on automatise des testsLecture8 min
    • Comment un ordinateur traite et stocke l’informationLecture10 min
    • Le binaire, sans mathématiquesLecture10 min
    • Algorithme ou programme ? La recette et le platLecture10 min
    • Exercice : votre premier algorithme en langage naturelExercice15 min
    • La carte de référence du pseudo-langage du coursRessource10 min
    • Variables : type, nom, valeurLecture12 min
    • Portée des variables : globale ou localeLecture10 min
    • Opérateurs arithmétiques, et le piège du signe =Lecture12 min
    • Opérateurs logiques ET, OU, NON et tables de véritéLecture12 min
    • Exercice : évaluer des expressionsExercice15 min
    • Quiz : bases, variables et opérateursÀ paraîtreQuiz10 min
    • Les conditions : Si, Alors, SinonLecture15 min
    • Conditions imbriquées et ordre des testsLecture12 min
    • Exercice : conditions et tranches tarifairesExercice15 min
    • La boucle TantQueLecture12 min
    • La boucle PourLecture12 min
    • Boucles imbriquéesLecture12 min
    • Méthode : tracer une exécution au tableau de traceExercice20 min
    • Quiz : structures de contrôleÀ paraîtreQuiz10 min
    • Les tableaux : déclaration, indices, accèsLecture12 min
    • Modifier et parcourir un tableauLecture12 min
    • Tableaux à deux dimensionsLecture15 min
    • Exercice : tableaux 1D et 2DExercice20 min
    • TP guidé 1 : coût énergétique mensuelExercice20 min
    • TP guidé 2 : coût énergétique annuel avec tableauxExercice20 min
    • Les fonctions prédéfiniesLecture8 min
    • Fonction ou procédure ?Lecture12 min
    • Déclarer une fonction : signature, corps, retourLecture15 min
    • Appeler une fonction : paramètre, argument, valeur ou référenceLecture15 min
    • Exercice : transformer un script linéaire en fonctionsExercice20 min
    • TP guidé 3 : gestion des notes d’étudiantsExercice20 min
    • La récursivité : cas de base et cas récursifLecture15 min
    • Exercice : dérouler une récursionExercice15 min
    • Quiz : fonctions et récursivitéÀ paraîtreQuiz10 min
    • Compilation, interprétation, et le cas particulier de JavaLecture15 min
    • TP 4 : dérouler un programme à la mainExercice15 min
    • Factorisation : DRY, KISS, modularitéLecture12 min
    • TP 5 : factoriser le calcul de remiseExercice15 min
    • Clean code : nommer, découper, rendre testableLecture12 min
    • Complexité temporelle et spatialeLecture12 min
    • Types de langages : paradigmes, niveaux, usages et stack techniqueLecture15 min
    • TP 6, partie 1 : températures, maximum et minimumExercice20 min
    • TP 6, partie 2 : moyenne, médiane et affichage des statistiquesExercice20 min
    • TP 7, partie 1 : réservation de cinéma, la conceptionExercice20 min
    • TP 7, partie 2 : réservation de cinéma, l’implémentationExercice20 min
    • QCM final du moduleÀ paraîtreQuiz20 min
    • Fiche de révision algorithmiqueRessource10 min
    • Passerelle : du pseudo-langage à JavaLecture12 min

  5. M5

    Java : les fondations

    Écrire, compiler et exécuter un programme Java 11, le déboguer pas à pas dans VSCode et corriger les erreurs signalées par le compilateur comme celles qui surviennent à l’exécution.

    • Ce que vous saurez faire à la fin de ce moduleÀ paraîtreLecture10 min
    • JVM, JRE, JDK : qui fait quoiÀ paraîtreLecture12 min
    • Histoire de Java et raison du choix de Java 11À paraîtreLecture10 min
    • Configurer VSCode pour JavaÀ paraîtreLecture15 min
    • Point de contrôle : l’installationÀ paraîtreQuiz8 min
    • BonjourMonde : votre premier programmeÀ paraîtreExercice15 min
    • Anatomie d’un fichier .javaÀ paraîtreLecture12 min
    • Quand ça ne compile pas : lire un message d’erreurÀ paraîtreLecture15 min
    • Variables et types primitifsÀ paraîtreLecture15 min
    • String et char : les pièges d’affichageÀ paraîtreLecture12 min
    • Exercice guidé : déclarer, calculer, afficherÀ paraîtreExercice12 min
    • Opérateurs arithmétiques et division entièreÀ paraîtreLecture14 min
    • Opérateurs de comparaison et opérateurs logiquesÀ paraîtreLecture12 min
    • Quiz : syntaxe de baseÀ paraîtreQuiz10 min
    • Conditions : if, else, else ifÀ paraîtreLecture12 min
    • switch : quand le préférer à une cascade de ifÀ paraîtreLecture12 min
    • TP1 — Calcul du coût énergétique mensuelÀ paraîtreExercice20 min
    • La boucle whileÀ paraîtreLecture12 min
    • La boucle for et la boucle for-eachÀ paraîtreLecture15 min
    • Boucles imbriquées sans se tromperÀ paraîtreLecture12 min
    • Quiz : structures de contrôleÀ paraîtreQuiz10 min
    • Les tableaux à une dimensionÀ paraîtreLecture15 min
    • ArrayIndexOutOfBoundsException : l’erreur d’indiceÀ paraîtreLecture10 min
    • Les tableaux à deux dimensionsÀ paraîtreLecture15 min
    • TP2 — Facture annuelle avec tableauxÀ paraîtreExercice20 min
    • Écrire une méthode : signature, paramètres, retourÀ paraîtreLecture15 min
    • Appeler une méthode et suivre le passage par valeurÀ paraîtreLecture15 min
    • static ou pas static : le piège numéro 1À paraîtreLecture15 min
    • TP3 — Gestion des notes d’étudiantsÀ paraîtreExercice20 min
    • TP4 — Lire un programme et prévoir sa sortieÀ paraîtreExercice12 min
    • TP5 — Factoriser un programme en méthodesÀ paraîtreExercice18 min
    • TP6 — Statistiques de températuresÀ paraîtreExercice20 min
    • Déboguer pas à pas dans VSCodeÀ paraîtreLecture15 min
    • Conventions de nommage et lisibilité du code JavaÀ paraîtreLecture12 min
    • Les paradigmes de programmationÀ paraîtreLecture10 min
    • Aide-mémoire Java : les fondationsÀ paraîtreRessource8 min
    • Évaluation finale du moduleÀ paraîtreQuiz18 min

  6. M6

    Programmation orientée objet

    Modéliser une hiérarchie de classes en Java et la coder : encapsulation, héritage, polymorphisme, abstraction — jusqu’à un premier Page Object.

    • Pourquoi la POO existeÀ paraîtreLecture12 min
    • Glossaire POO : français, anglais, JavaÀ paraîtreRessource8 min
    • Quiz d’entrée : procédural ou objet ?À paraîtreQuiz8 min
    • L’environnement de travail : un fichier, une classeÀ paraîtreLecture15 min
    • Écrire une première classeÀ paraîtreLecture15 min
    • Créer des objets : new, référence, nullÀ paraîtreLecture15 min
    • Exercice : la classe LivreÀ paraîtreExercice20 min
    • Visibilité : private, package-private, protected, publicÀ paraîtreLecture15 min
    • Getters et settersÀ paraîtreLecture12 min
    • Constructeurs et mot-clé thisÀ paraîtreLecture18 min
    • Exercice : un CompteBancaire qu’on ne peut pas casserÀ paraîtreExercice20 min
    • Quiz : encapsulation et constructeursÀ paraîtreQuiz10 min
    • Surcharge de méthodesÀ paraîtreLecture12 min
    • static : ce qui appartient à la classeÀ paraîtreLecture18 min
    • Héritage : extends et superÀ paraîtreLecture18 min
    • Redéfinir une méthode : @OverrideÀ paraîtreLecture15 min
    • Exercice : Vehicule, Voiture, MotoÀ paraîtreExercice20 min
    • Polymorphisme : une référence parente, plusieurs comportementsÀ paraîtreLecture18 min
    • Exercice : calculer une masse salariale polymorpheÀ paraîtreExercice20 min
    • Classes abstraitesÀ paraîtreLecture12 min
    • Interfaces en Java 11À paraîtreLecture18 min
    • Interface ou classe abstraite : comment choisirÀ paraîtreLecture12 min
    • Exercice : le GarageÀ paraîtreExercice20 min
    • Quiz : héritage, polymorphisme, abstractionÀ paraîtreQuiz12 min
    • Relations entre objets : composition, agrégation, associationÀ paraîtreLecture15 min
    • Le minimum vital sur List<T>À paraîtreLecture15 min
    • Exercice : mini-bibliothèque (Livre, Membre, Emprunt)À paraîtreExercice20 min
    • toString, equals et le piège du ==À paraîtreLecture15 min
    • Packages et importÀ paraîtreLecture12 min
    • Exceptions : try, catch, finallyÀ paraîtreLecture18 min
    • throws, exceptions vérifiées et exceptions personnaliséesÀ paraîtreLecture15 min
    • AnnotationsÀ paraîtreLecture12 min
    • Ce que la POO change dans un projet de testÀ paraîtreLecture12 min
    • Un premier Page ObjectÀ paraîtreLecture20 min
    • Exercice guidé : LoginPage sur SwagLabsÀ paraîtreExercice20 min
    • Évaluation finale du moduleÀ paraîtreQuiz20 min
    • Kit du module : mémo, corrigés, projet de référenceÀ paraîtreRessource10 min

  7. M7

    Consolidation : sept mini-projets Java

    Un seul projet Maven qui grossit de mini-projet en mini-projet : sept énoncés, sept corrigés, et les quatorze concepts POO remis en service sur du code qui compile.

    • Ce que vous allez construireÀ paraîtreLecture10 min
    • Rappel express : les 14 concepts POO en fichesÀ paraîtreLecture14 min
    • Auto-diagnostic : êtes-vous prêt ?À paraîtreQuiz10 min
    • Votre atelier : projet, packages, exécutionÀ paraîtreLecture15 min
    • Décoder les erreurs du compilateur JavaÀ paraîtreLecture14 min
    • Fiche : les 8 types primitifsÀ paraîtreRessource8 min
    • Choisir sa collection : List, Set, MapÀ paraîtreLecture16 min
    • Mini-projet 1 : gestion d’une bibliothèqueÀ paraîtreExercice20 min
    • Correction commentée du mini-projet 1À paraîtreLecture12 min
    • Mini-projet 2 : calculatrice et surchargeÀ paraîtreExercice18 min
    • Correction du mini-projet 2 : les exceptionsÀ paraîtreLecture14 min
    • Quiz : surcharge, redéfinition, exceptionsÀ paraîtreQuiz10 min
    • Mini-projet 3 : système de paiementÀ paraîtreExercice18 min
    • Correction du mini-projet 3 : à quoi sert l’interfaceÀ paraîtreLecture12 min
    • Modéliser avant de coderÀ paraîtreLecture15 min
    • Classe abstraite ou interface ? Héritage ou composition ?À paraîtreLecture12 min
    • Mini-projet 4 (1/2) : la hiérarchie PersonneÀ paraîtreExercice20 min
    • Mini-projet 4 (2/2) : interface Diplome, Ecole et scénario mainÀ paraîtreExercice20 min
    • Correction du mini-projet 4À paraîtreLecture14 min
    • Mini-projet 5 (1/2) : la hiérarchie ProduitÀ paraîtreExercice20 min
    • Mini-projet 5 (2/2) : Stock, Magasin, EmployeÀ paraîtreExercice20 min
    • Correction du mini-projet 5 : les collections imbriquéesÀ paraîtreLecture14 min
    • static et annotations, pour de vraiÀ paraîtreLecture12 min
    • Mini-projet 6 : Entreprise, Ecole et MagasinÀ paraîtreExercice20 min
    • Mini-projet 7 : gestion d’un zoo, le projet finalÀ paraîtreExercice20 min
    • Débogage : 5 bugs à trouverÀ paraîtreExercice18 min
    • De la POO au framework de testÀ paraîtreLecture14 min
    • Quiz bilan du moduleÀ paraîtreQuiz12 min
    • Banque d’entraînement : 14 exercices POOÀ paraîtreRessource10 min

  8. M8

    Selenium : comprendre l’outil et préparer le projet

    Ce que Selenium fait, et ce qu’il laisse aux autres outils. Lire le DOM en testeur, monter le projet Maven de test, exécuter le premier script qui ouvre un navigateur et le referme proprement.

    • Décider si un test mérite d’être automatiséÀ paraîtreLecture10 min
    • Selenium n’est pas un framework de testÀ paraîtreLecture12 min
    • Comment WebDriver pilote réellement un navigateurÀ paraîtreLecture12 min
    • Quiz — situer Selenium dans son écosystèmeÀ paraîtreQuiz8 min
    • Le DOM vu par un testeurÀ paraîtreLecture15 min
    • Inspecter une page avec les DevToolsAccès libreExercice18 min
    • Créer le projet Maven de testÀ paraîtreExercice18 min
    • Premier script : ouvrir, lire, fermerAccès libreExercice15 min
    • Diagnostiquer les 8 erreurs de démarrageÀ paraîtreRessource15 min

  9. M9

    Localiser un élément : DOM, XPath, CSS

    Écrire des localisateurs qui survivent au prochain changement de page. Quatre chapitres sur XPath, un sur les sélecteurs CSS, et un atelier en console pour les ancrer.

    • La classe By : les 8 stratégiesÀ paraîtreLecture15 min
    • Choisir un localisateur qui résiste au tempsÀ paraîtreLecture12 min
    • XPath 1 : chemins absolus, chemins relatifs, et le piège du //À paraîtreLecture18 min
    • XPath 2 : prédicats, attributs, texteÀ paraîtreLecture18 min
    • XPath 3 : position, et la parenthèse qui change toutÀ paraîtreLecture15 min
    • XPath 4 : les axes, remonter et se déplacer dans le DOMÀ paraîtreLecture15 min
    • Ce que XPath sait faire et que Selenium refuseÀ paraîtreLecture10 min
    • Atelier : 12 XPath validés dans la consoleAccès libreExercice20 min
    • Les sélecteurs CSS, et quand les préférer à XPathÀ paraîtreLecture18 min
    • Quiz : choisir le bon localisateurÀ paraîtreQuiz12 min

  10. M10

    Agir, vérifier, fiabiliser

    Piloter les éléments d’une page, écrire des assertions qui font réellement échouer un test, et venir à bout des tests qui passent une fois sur deux.

    • findElement et findElementsÀ paraîtreLecture15 min
    • Agir sur un élément : clear, sendKeys, click, submit, getTextÀ paraîtreLecture15 min
    • TP guidé : s’authentifier sur OrangeHRMÀ paraîtreExercice20 min
    • TP guidé : lire et modifier une ficheÀ paraîtreExercice20 min
    • WebElement : les méthodes d’état et d’inspectionÀ paraîtreLecture15 min
    • Listes déroulantes : Select natif et faux selectÀ paraîtreLecture18 min
    • TP : formulaire multi-champs et vérification de ligneÀ paraîtreExercice20 min
    • La classe Actions : clavier et sourisÀ paraîtreLecture18 min
    • TP : survol, clic droit et glisser-déposerÀ paraîtreExercice20 min
    • Vérifier n’est pas asserterÀ paraîtreLecture12 min
    • Assertions JUnit et TestNG : choisir et ne pas inverserÀ paraîtreLecture15 min
    • Assertions douces et messages d’échecÀ paraîtreLecture12 min
    • TP : transformer un scénario en test assertifÀ paraîtreExercice20 min
    • Pourquoi un test passe une fois sur deuxÀ paraîtreLecture12 min
    • Le wait impliciteÀ paraîtreLecture12 min
    • Wait explicite et ExpectedConditionsÀ paraîtreLecture18 min
    • Fluent wait, Thread.sleep et le mélange interditÀ paraîtreLecture15 min
    • TP : fiabiliser un test instableÀ paraîtreExercice20 min
    • Quiz — synchronisationÀ paraîtreQuiz10 min
    • Piloter la fenêtre du navigateurÀ paraîtreLecture10 min
    • ChromeOptions : incognito, headless, téléchargementsÀ paraîtreLecture15 min
    • TP : exécuter la même suite en headlessÀ paraîtreExercice15 min

  11. M11

    Industrialiser : TestNG, Maven et Page Object Model

    Passer de scripts isolés à un framework : cycle de vie des tests, jeux de données, rapports d’exécution et Page Object Model.

    • TestNG : les annotations et l’ordre d’exécutionÀ paraîtreLecture15 min
    • testng.xml : suites, groupes et exécution parallèleÀ paraîtreExercice18 min
    • Paramétrer un test : @Parameters et @DataProviderÀ paraîtreLecture15 min
    • Maven : cycle de vie et lancement des testsÀ paraîtreLecture15 min
    • Allure : le rapport et la capture d’écran sur échecÀ paraîtreLecture15 min
    • Générer des jeux de données sans collisionÀ paraîtreLecture10 min
    • Le Page Object Model : séparer la page du testÀ paraîtreLecture18 min
    • Lire l’architecture du framework PandoraÀ paraîtreLecture20 min
    • Ce que Selenium ne sait pas faireÀ paraîtreLecture12 min
    • Projet fil rouge : une campagne de bout en boutÀ paraîtreExercice20 min
    • Examen final du moduleÀ paraîtreQuiz20 min

  12. M12

    Le framework Pandora

    Le framework d’automatisation utilisé chez STRATEST : préparer son poste, lire l’architecture, écrire des cas de test, lancer une campagne et exploiter le rapport qu’elle produit.

    • Pourquoi un framework plutôt que des scripts SeleniumÀ paraîtreLecture12 min
    • Installer Maven et AllureÀ paraîtreLecture18 min
    • Checklist : mon poste est-il prêt ?À paraîtreExercice15 min
    • Créer le projet Maven dans VSCodeÀ paraîtreLecture15 min
    • Greffer le package Pandora sur le projetÀ paraîtreLecture12 min
    • Lire l’arborescence PandoraÀ paraîtreLecture15 min
    • Le cœur du framework : TestBase, Factory, UtilitiesÀ paraîtreLecture18 min
    • Le Listener et la capture d’écran automatiqueÀ paraîtreLecture12 min
    • Pojo : centraliser ses locatorsÀ paraîtreExercice15 min
    • Quiz : l’architecture de PandoraÀ paraîtreQuiz10 min
    • Le cycle de vie TestNG : les huit annotationsÀ paraîtreLecture18 min
    • Écrire son premier cas de test PandoraÀ paraîtreExercice20 min
    • Suites TestNG et campagnes MavenÀ paraîtreLecture15 min
    • Lancer une campagne en ligne de commandeÀ paraîtreExercice15 min
    • Récupérer un paramètre -D dans son codeÀ paraîtreLecture12 min
    • Lire un rapport AllureÀ paraîtreExercice15 min
    • Surefire, JUnit et les logsÀ paraîtreLecture10 min
    • Quiz : exécution et reportingÀ paraîtreQuiz10 min
    • Groupes TestNG et dépendances entre testsÀ paraîtreLecture15 min
    • DataProvider : piloter un test par les donnéesÀ paraîtreExercice18 min
    • Assertions TestNG et pilotage d’un testÀ paraîtreLecture15 min
    • Iframes, onglets et fenêtres : changer de contexteÀ paraîtreExercice18 min
    • Cookies et alertes JavaScriptÀ paraîtreLecture12 min
    • La classe ActionsÀ paraîtreExercice18 min
    • JavascriptExecutor : le dernier recoursÀ paraîtreLecture15 min
    • Upload de fichier : sendKeys d’abord, Robot ensuiteÀ paraîtreLecture15 min
    • Ajouter une dépendance MavenÀ paraîtreLecture10 min
    • Mon test ne passe pas : guide de dépannageÀ paraîtreRessource18 min
    • Projet fil rouge : une campagne complèteÀ paraîtreExercice20 min

  13. M13

    Mises en situation : quatre applications réelles

    Vingt-six user stories, quatre applications. Dériver les cas de test, coder les Page Objects, réparer ce qui casse, puis livrer une campagne complète avec son rapport.

    • Ce qui change : du TP guidé au projet réelÀ paraîtreLecture10 min
    • Les quatre projets, leur ordre et sa raisonÀ paraîtreLecture10 min
    • Lire une user story et en extraire des cas de testÀ paraîtreLecture15 min
    • Exercice : dériver les cas de test de l’US1 Swag LabsÀ paraîtreExercice20 min
    • La matrice de couverture : user stories et cas de testÀ paraîtreExercice15 min
    • Le squelette de projet imposéÀ paraîtreLecture15 min
    • Exercice : monter le projet socle et le faire tournerÀ paraîtreExercice20 min
    • Le Page Object Model en 20 minutesÀ paraîtreLecture20 min
    • Exercice : un premier Page ObjectÀ paraîtreExercice20 min
    • Choisir un bon localisateurÀ paraîtreLecture15 min
    • Quiz : cadrage et socle techniqueÀ paraîtreQuiz10 min
    • Projet 1 — Swag Labs : l’application et son jeu de donnéesÀ paraîtreLecture12 min
    • Projet 1 — US1 : la page de connexionÀ paraîtreExercice20 min
    • Projet 1 — US1 : les cinq cas d’erreur et leurs textes exactsÀ paraîtreExercice20 min
    • Projet 1 — US2 : la page d’inventaireÀ paraîtreExercice20 min
    • Projet 1 — Isolation des tests et Reset App StateÀ paraîtreLecture15 min
    • Projet 1 — US3 : le tri des produitsÀ paraîtreExercice20 min
    • Projet 1 — US4 : le panier et son badgeÀ paraîtreExercice20 min
    • Projet 1 — US5 : le tunnel de commande, étape informationsÀ paraîtreExercice18 min
    • Projet 1 — US6 : récapitulatif, total et confirmationÀ paraîtreExercice20 min
    • Projet 1 — Corrigé commenté et revue de codeÀ paraîtreRessource20 min
    • Quiz : projet 1, Swag LabsÀ paraîtreQuiz10 min
    • Projet 2 — Rent a CAR : cadrage et carte des risquesÀ paraîtreLecture12 min
    • Projet 2 — US2 : recherche par dates et heuresÀ paraîtreExercice20 min
    • Projet 2 — US3 : trois vues, un seul jeu de testsÀ paraîtreExercice20 min
    • Projet 2 — US3 : parcourir un tableau paginé et triéÀ paraîtreExercice20 min
    • Projet 2 — US4 : popup de détail et ongletsÀ paraîtreExercice20 min
    • Projet 2 — US5 : Daily Schedule, double-clic et réservationÀ paraîtreExercice20 min
    • Projet 2 — US1 et US6 : tester une application multilingueÀ paraîtreExercice15 min
    • Quiz : projet 2, Rent a CARÀ paraîtreQuiz10 min
    • Projet 3 — Ce que Selenium sait faire, et ce qu’il ne sait pas faireÀ paraîtreLecture15 min
    • Projet 3 — Localiser des éléments graphiques SVGÀ paraîtreExercice18 min
    • Projet 3 — US3 : glisser-déposer, redimensionner, supprimerÀ paraîtreExercice20 min
    • Projet 3 — US1 : Open et Save, fichiers et dialogues natifsÀ paraîtreExercice20 min
    • Projet 3 — US2, US5, US6 et US7 : le reste de l’outilÀ paraîtreExercice20 min
    • Projet 3 — Rédiger une note de non-automatisationÀ paraîtreExercice15 min
    • Quiz : projet 3 et limites de SeleniumÀ paraîtreQuiz10 min
    • Projet 4 — Cahier des charges et livrable attenduÀ paraîtreLecture12 min
    • Projet 4 — US2 : le champ à autocomplétionÀ paraîtreExercice20 min
    • Projet 4 — US3 : carousel, survol et descriptionsÀ paraîtreExercice20 min
    • Projet 4 — US4 et US5 : destinations et fiche détailléeÀ paraîtreExercice20 min
    • Projet 4 — US6 : vérifier un effet visuelÀ paraîtreExercice18 min
    • Projet 4 — US7 : le formulaire de contact completÀ paraîtreExercice20 min
    • Changer de contexte : frames, fenêtres et alertesÀ paraîtreExercice18 min
    • Diagnostiquer un test qui échoueÀ paraîtreLecture18 min
    • Exercice : réparer six tests cassésÀ paraîtreExercice20 min
    • Stabiliser : en finir avec les tests intermittentsÀ paraîtreLecture18 min
    • La capture d’écran automatique en cas d’échecÀ paraîtreExercice15 min
    • Produire le rapport de campagne : Surefire et AllureÀ paraîtreExercice20 min
    • Organiser ses suites et exécuter en parallèleÀ paraîtreExercice18 min
    • Livrer un dépôt Git propreÀ paraîtreExercice15 min
    • Grille d’auto-évaluation et rendu finalÀ paraîtreRessource15 min
    • Quiz final de mise en situationÀ paraîtreQuiz15 min

  14. M14

    Se situer et entrer sur le marché

    Décider ce qui mérite d’être automatisé, choisir un outil et un langage, puis préparer son CV, son entretien technique et ses 90 premiers jours.

    • Pourquoi automatiser — et quand s’en abstenirÀ paraîtreLecture12 min
    • Calculer le point d’équilibre d’une suite automatiséeÀ paraîtreExercice15 min
    • Fonctionnel, non fonctionnel, pyramide des testsÀ paraîtreLecture15 min
    • Exercice : trier douze cas de test à automatiser ou nonÀ paraîtreExercice15 min
    • Quiz — rentabilité, limites et typologie des testsÀ paraîtreQuiz8 min
    • Panorama des outils d’automatisation webÀ paraîtreLecture15 min
    • Outils d’API, de performance, de mobile et de test visuelÀ paraîtreLecture15 min
    • Où s’exécutent les tests : CI/CD et intégration continueÀ paraîtreLecture12 min
    • Choisir son outil : grille de décision et trois études de casÀ paraîtreExercice20 min
    • Quel langage pour automatiser : Java, Python, JavaScript, C#À paraîtreLecture12 min
    • Quiz — outils et langagesÀ paraîtreQuiz8 min
    • Le parcours de certification ISTQBÀ paraîtreLecture14 min
    • Les niveaux du métier, de testeur junior à architecte de testÀ paraîtreLecture12 min
    • Construire son CV et son profil LinkedIn de QA automaticienÀ paraîtreExercice20 min
    • L’entretien technique : vingt questions et les réponses attenduesÀ paraîtreLecture15 min
    • La boîte à outils du QA automaticienÀ paraîtreRessource12 min
    • Trente ressources à garder sous la main, classées par usageÀ paraîtreRessource12 min
    • Organiser sa veille et situer ce que l’IA change dans le testÀ paraîtreLecture12 min
    • Mon plan à 90 jours après le Niveau 1À paraîtreExercice18 min
    • Quiz final du moduleÀ paraîtreQuiz10 min

  15. M15

    Évaluation finale

    Les épreuves, le barème, le score qui valide le Niveau 1, les corrigés commentés et le plan de reprise en cas d’échec.

    • Les épreuves, le barème et le nombre de tentativesÀ paraîtreLecture10 min
    • Test de positionnement d’entréeÀ paraîtreQuiz12 min
    • QCM — AlgorithmiqueÀ paraîtreQuiz15 min
    • Corrigé commenté — AlgorithmiqueÀ paraîtreLecture12 min
    • QCM — Java, les fondationsÀ paraîtreQuiz15 min
    • Corrigé commenté — Java, les fondationsÀ paraîtreLecture12 min
    • QCM — Programmation orientée objetÀ paraîtreQuiz15 min
    • Corrigé commenté — POU : les pièges de vocabulaireÀ paraîtreLecture15 min
    • QCM — Java intermédiaireÀ paraîtreQuiz15 min
    • QCM — HTML, DOM, XPath et sélecteurs CSSÀ paraîtreQuiz15 min
    • QCM Selenium 1 — composants, WebDriver, localisateursÀ paraîtreQuiz15 min
    • QCM Selenium 2 — attentes, Actions, Select, assertionsÀ paraîtreQuiz15 min
    • Corrigé commenté — Selenium et l’API Selenium 4À paraîtreLecture18 min
    • QCM outillage — Maven, JUnit, TestNG, structure de projetÀ paraîtreQuiz12 min
    • Exercice noté 1 — Déboguer un test qui mentÀ paraîtreExercice20 min
    • Exercice noté 2 — Écrire un test complet sur SwagLabsÀ paraîtreExercice20 min
    • Examen final, partie A — QCM auto-corrigéÀ paraîtreQuiz20 min
    • Examen final, partie B — Questions ouvertes et auto-évaluation guidéeÀ paraîtreExercice20 min
    • Examen final, partie C — Projet pratique évaluéÀ paraîtreExercice20 min
    • Le résultat, bloc par bloc, et le plan de repriseÀ paraîtreLecture10 min
    • Banque de révision et fiches d’erreurs fréquentesÀ paraîtreRessource10 min

Accès libre

9 chapitres complets, sans créer de compte.

Des chapitres entiers, pas une bande-annonce. Vous jugez la pédagogie avant de nous donner quoi que ce soit.

Modalités et informations réglementaires

Modalités pédagogiques et techniques

Formation à distance, à votre rythme. Quinze modules, 348 chapitres, et une charge de travail réelle d’environ 87 heures — nettement plus que les 48 heures de la version en présentiel, parce qu’en autonomie vous tapez le code et le déboguez vous-même. Chapitres écrits, exercices sur votre poste, quiz de validation, et quatre applications à automatiser de bout en bout.

Modalités d’évaluation

Quiz de validation à la fin de chaque module, et évaluation des livrables de mise en situation : cas de test conçus, scripts automatisés produits, et capacité à justifier les choix d’architecture.

Délai d’accès

Accès ouvert sous 5 jours ouvrés après validation de l’inscription.

Accessibilité aux personnes en situation de handicap

Les formations sont suivies à distance, à votre rythme. Si une situation de handicap nécessite une adaptation — supports, rythme, modalités d’évaluation — contactez notre référent avant l’inscription pour que nous étudiions ensemble les aménagements possibles.

Indicateurs de résultats

Aucune promotion achevée à ce jour. Les indicateurs seront publiés dès la première session terminée.

Financement

La démarche de certification Qualiopi est engagée. À ce stade, les financements CPF et OPCO ne sont pas mobilisables. Prise en charge possible sur budget direct d’entreprise ou à titre individuel.

STRATLEARN est l’activité de formation de STRATEST SARL. Mentions légales