Où l'équipe QA doit-elle effectuer les tests dans le modèle de branchement Gitflow

Nous sommes une grande équipe (10-12 développeurs et 4 qa) travaillant sur plusieurs projets avec le même référentiel git. C'est un service Web backend basé sur Spring Boot. Nous recherchons une bonne stratégie de branchement et de déploiement git. nous avons également une équipe qa qui s'assure que nos fonctionnalités fonctionnent comme prévu (sans bug dans une certaine mesure).

Après avoir lu quelques articles, j'ai eu le sentiment que le modèle Gitflow fonctionnerait bien pour nous. Voici ma question.

Où notre équipe QA doit-elle tester nos fonctionnalités?

1. devraient-ils tester sur la branche de fonctionnalité, où ils soulèveraient des bugs et le développeur le corrigerait et une fois qu'il passerait le test d'assurance qualité, nous fusionnerions pour le développer. et QA effectuera à nouveau les tests d'intégration dans la branche develop.
2. devrions-nous fusionner toutes les fonctionnalités (après les tests unitaires et les tests de base du développeur) pour développer la branche et laisser le test qa partir de là. les correctifs et les tests auront également lieu lors du développement.

Je suis curieux de savoir quelle approche a bien fonctionné pour les autres.

Le contrôle qualité devrait probablement être testé deux fois.

Le premier test devrait porter sur les modifications spécifiques et être effectué sur la branche de fonctionnalité. Cela permet au QA de tester les modifications spécifiques et de voir que la modification particulière est terminée comme spécifié et se comporte comme prévu. Cela leur donne également un aperçu précoce de la deuxième série de tests, ce qui est réellement important pour l'AQ.

Venant de mon expérience dans divers environnements réglementés, le deuxième test doit être effectué sur une balise de la branche de développement qui correspond à une version, ou la branche de la version, ou peut-être la branche principale. Avant une version, QA devrait tester le code complet qui sera déployé avant d'être déployé et vous devriez pouvoir affirmer que tout ce qui a été testé par QA est exactement identique à ce qui est déployé en production. Ma préférence serait qu'après un gel de code, une balise soit appliquée à la branche release et que QA le testerait. Les modifications seraient effectuées dans une branche de développement, vérifiées ponctuellement, puis testées à nouveau dans une nouvelle balise sur la branche de publication. Ces balises sur la branche de publication correspondraient aux candidats de publication.

Je fais quelques hypothèses ici. Tout d'abord, vous disposez d'une couverture de test basée sur les développeurs quelque peu décente. Idéalement, il s'agirait de tests unitaires et d'intégration automatisés que les développeurs exécutent et font avant d'envoyer tout code sur n'importe quelle branche à QA. Les développeurs peuvent également vouloir effectuer des tests exploratoires autour de l'interface utilisateur pour s'assurer que les choses semblent correctes avant les tests d'assurance qualité. Deuxièmement, il y a une bonne coordination entre le développement et l'AQ pour planifier les changements incorporés afin d'assurer un temps d'AQ suffisant en fonction des fonctionnalités.

Grande question. Je ne pense pas qu'il y ait une réponse correcte «officielle» à cela. Cela dépend de la vitesse à laquelle vous pouvez tester.

Le problème essentiel est que chaque fusion, compilation ou même déploiement peut potentiellement créer un bug. Plus la chaîne que vous testez est avancée, plus vous êtes au courant des bogues, mais aussi plus vous devez tester à nouveau.

Afin de vous assurer que vous avez testé le logiciel que les clients utilisent, vous devez vraiment tester le déploiement en direct avant que le trafic des clients (en supposant une application Web) soit acheminé vers ces serveurs via un modèle de déploiement bleu / vert.

Mais évidemment, c'est un peu tard dans la journée pour être la première fois que vous vérifiez le code!

Si vous testez une branche de publication dans un environnement qa, vous pouvez prendre le risque et réduire les tests en direct aux tests de fumée uniquement. et appliquer des corrections de bogues à la branche de publication. Mais vous ne pouvez pas évaluer si une fonctionnalité est complète avant de créer une version

Si vous testez le développement, vous obtenez des mini-branches de correction de bogues. Les fonctionnalités sont toujours fusionnées avant d'être évaluées, et les fonctionnalités de la prochaine version peuvent entrer en collision avec le test de la version actuelle.

Si vous testez des branches de fonctionnalités, vous avez besoin d'un million d'environnements et devez orchestrer l'ordre des fusions et tester les approbations. plus beaucoup de nouveaux tests.

D'après mon expérience, je recommanderais:

test rapide de la branche de fonctionnalité sur la machine de développement. assurez-vous simplement que sa fonctionnalité est complète et que les testeurs / développeurs conviennent de la signification des exigences.

Tests quotidiens / tests automatisés sur la branche de développement déployée sur les serveurs qa. Vous permet de tester toutes les fonctionnalités ensemble et de dire quand vous êtes prêt à sortir.

Si toutes les fonctionnalités sont présentes mais que le test n'est pas terminé. par exemple, le sprint est terminé. créer une branche de publication et déployer dans un deuxième environnement qa. Cela permet de corriger / corriger les bogues de la version 1 en même temps que les fonctionnalités de la version 2.

(Les passionnés de Scrum diront que vous ne devriez mettre que des corrections de bugs dans le sprint 2 mais soyons pratiques)

Tests de fumée sur le déploiement vert / bleu en direct avant le basculement. Celles-ci sont super importantes car vous récupérerez des erreurs de configuration / d'environnement que personne ne recherche vraiment lors du développement.

Je suis d'accord avec Thomas Owens. Vous devriez probablement tester deux fois. Une fois sur la branche de fonctionnalité avant sa fusion et une fois sur votre branche principale avant de la libérer.

En fait, j'aime tellement ce flux de travail que j'ai créé un outil, Topico , qui crée et exécute automatiquement des versions jetables de votre application pour chaque demande d'extraction, chacune avec sa propre URL de test unique. Cela permet à votre équipe d'assurance qualité de tester les branches de fonctionnalités de manière isolée sans avoir besoin d'un certain type d'environnement de test dynamique configuré sur leur propre machine.

Cette approche signifie que seul le code ayant réussi les tests humains atteindra votre branche principale, préservant ainsi son intégrité.

J'ai introduit cela dans quelques sociétés et cela a beaucoup aidé nos cycles de sortie. Nous sommes maintenant en mesure de planifier avec précision les versions et nous comprenons mieux ce qui est susceptible de se retrouver dans la prochaine version et ce qui devra attendre une prochaine version. Cela vous donne beaucoup plus de confiance.