Les programmeurs devraient-ils aider les testeurs à concevoir des tests?

Dans quelle mesure les programmeurs devraient-ils aider les testeurs à concevoir des tests?

Je ne pense pas qu'ils devraient aider du tout. Mon inquiétude est que s'ils aident les testeurs à concevoir des tests pour leur propre code, ils «infecteront» les testeurs avec leurs propres préjugés et angles morts à propos de ce code.

Je pense que les exigences devraient être suffisantes pour donner les informations nécessaires aux testeurs pour créer leurs tests. S'il y a une partie de l'implémentation que les programmeurs trouvent inquiétante, alors je pense que c'est leur devoir d'implémenter des tests unitaires pour tester cette partie ou même d'exécuter leurs propres tests système informels pour tester cette partie.

Cependant, tous ceux que je connais ne sont pas d'accord avec cela (et je comprends certains de leurs points dans une certaine mesure). Qu'en pensent les autres? Est-ce discuté quelque part dans la littérature?

Je suis d'accord. Les programmeurs peuvent aider les testeurs à comprendre les spécifications fonctionnelles, à trouver des ressources pour la recherche, mais ne doivent pas polluer l'esprit des testeurs avec leurs propres idées sur la façon d'aborder les tests.

Je pense que les développeurs et les testeurs ont la possibilité de coexister pacifiquement dans le domaine de l'assurance qualité. :)

Plus précisément, je pense que les développeurs devraient être responsables du premier niveau de test - les tests unitaires et les tests d'intégration de base pour s'assurer que leur matériel fonctionne dans la plupart des cas avant de le remettre aux testeurs.

Il appartient aux testeurs de créer des tests d'acceptation basés sur des exigences totalement indépendantes des détails de mise en œuvre (ce que l'on appelle généralement les «tests de boîte noire»). S'il y a une différence dans la façon dont les testeurs et les développeurs comprennent les exigences, c'est un problème qui devrait être résolu soit par le chef de projet (le cas échéant), soit en s'assurant que tout le monde est sur la même page dans la phase de conception de la fonctionnalité.

Je pense que les tests et le développement sont des efforts de collaboration , donc bien sûr (IMO), les développeurs devraient donner des idées de test aux testeurs. Je ne pense pas que cela les infecte ou entache les testeurs. Le testeur, bien sûr, devrait améliorer ces tests avec de nombreuses autres approches de test.

Je suis également un grand fan de testeurs aidant les développeurs - j'ai réfléchi à des idées de conception avec des développeurs et je les ai jumelés avec eux pour corriger des bugs (et souligné les bugs et les corrections suggérées) plusieurs fois dans ma carrière, et je ne pense pas que je '' ai jamais entaché un développeur de testeurs.

Si vous ne le voyez pas comme un effort de collaboration, vous aurez juste du code "jeté par-dessus le mur" du développeur au test ... et vous vous retrouverez avec une qualité inférieure. C'est la vérité dans mon monde, mais (bien sûr), ymmv.

Selon moi, ce n'est pas le travail de QA de tester mon code. Le travail du testeur est de s'assurer que mon code remplit toutes les conditions requises pour cette tâche.

Quand je passe quelque chose à QA, je m'assure qu'ils connaissent la tâche que je faisais, pas les spécificités de mon code. Je ne passe jamais rien à QA qui contient des bogues de «tête d'os». Cela fait perdre mon temps, leur temps ... et à peu près tout le monde.

Lors de mon dernier emploi, nous avons impliqué l'AQ depuis le début. Cela faisait partie des séances de collecte des exigences, des réunions de projet et des réunions de conception également. Ils ont écouté et posé des questions et pendant que les développeurs écrivaient du code, ils rédigeaient leurs plans de test. Cela a très bien fonctionné et nous avons détecté de nombreux problèmes qui auraient probablement pu se glisser.

Je pense que vous êtes très mal tourné ici. J'ai été testeur et développeur, et j'ai grandement bénéficié en tant que testeur des conseils fournis par les développeurs sur des domaines qu'ils considéraient comme à haut risque ou fragiles; en tant que développeur, je veux que les testeurs trouvent les problèmes que je n'ai pas approfondis.

Il n'y avait pas de "pollution" à moins que votre code ne soit des eaux usées brutes, et ce pour une raison complètement différente.

Les exigences font un travail terrible de communication des problèmes techniques dont un professionnel de l'assurance qualité se soucierait, car elles n'élaborent au mieux que ce que les analystes commerciaux ont réussi à saisir. Les bons développeurs seront conscients que leur code est optimisé autour du "chemin heureux" et voudront savoir ce qu'ils ont laissé sans considération. Ils auront au moins une intuition de ce qui pourrait mal tourner et des domaines qu'ils aimeraient que le contrôle qualité explore. Ils savent également quelle est la vue d'ensemble du risque autour d'une caractéristique particulière en fonction de leur conception.

En tant que testeur en l'absence de conseils de l'équipe de développement, j'ai parfois opté pour une approche erronée qui a généré de bons rapports de bogues, mais n'a pas complètement utilisé les chemins de code à haut risque et les problèmes plus importants, qui auraient pu être évités grâce à une meilleure collaboration avec l'équipe de développement, expédiée aux clients.

Bien qu'un testeur ne devrait certainement pas se limiter à tester uniquement ce que le développeur dit est important, il ne sera pas endommagé en apprenant ce que les développeurs pensent du code. Parfois, ils peuvent affiner leur approche en fonction de leur connaissance de la mise en œuvre. Ce n'est que si un testeur est particulièrement myope qu'il considérera l'opinion du développeur sur les risques comme le dernier mot; ils ne fermeront pas complètement les choses que le développeur identifie comme à faible risque, mais ils investiront plus d'efforts dans des choses qui pourraient avoir un impact client plus élevé.

L'équipe QA est susceptible de voir des domaines qui ont une grande portée de test combinatoire que les cueilleurs d'exigences ou les développeurs d'un système, mais ils peuvent ne pas être au courant des composants du système qui ont un type de fragilité plus subtil qui bénéficie de la connaissance de la conception ou la mise en œuvre du système.

D'après mon expérience, la collaboration entre QA et développement produit des produits de meilleure qualité. Je ne recommanderais jamais de faire uniquement un transfert de boîte noire.

En tant que testeur, je n'ai aucune objection à ce que les programmeurs suggèrent des cas de test (bien que cela ne signifie pas que je m'en tiendrai uniquement à ces cas de test), ou décrivent les détails de l'implémentation. Parfois, il peut être très utile de demander à quelqu'un de dire "Je pense que ce bit peut être risqué, j'aimerais vraiment que vous testiez ce bit de manière assez approfondie". Connaître certains des détails de la mise en œuvre m'aide à appliquer des années d'expérience pour choisir les tests que je pense les plus susceptibles d'échouer. Parfois, une brève mention signifie que quelques tests zooment soudainement sur ma liste de priorités.

Est-ce que cela me souille? Je suis un peu chatouillé par l'idée de programmeurs qui s'efforcent chevaleresque de préserver la pureté de mon testeur, mais vraiment - non, c'est un mythe. Plus d'informations déclenchent généralement encore plus de questions pour moi, pas moins. Je suppose que c'est une question de mentalité - je ne trouve pas de bugs parce que je suis ignorant, je trouve des problèmes parce que je suis un type sceptique et méfiant qui est tout simplement trop têtu pour prendre quoi que ce soit en toute confiance. Sur chaque système que j'ai testé, j'ai trouvé que je trouve plus de problèmes, et plus "intéressants", plus j'en viens à comprendre.

J'aime revoir les plans de test et suggérer des cas de test supplémentaires auxquels QA n'aurait peut-être pas pensé. Je ne sais pas comment cela "infecterait les testeurs avec mes propres préjugés".

Je me suis retrouvé dans cette position étrange dont j'ai besoin pour implémenter et écrire des cas de test dans Selenium par la suite, car nous manquons de personnel d'assurance qualité. Je pense qu'un développement piloté par les tests serait extrêmement utile, mais il n'est pas encore adapté dans ma boutique.

Une chose que je trouve utile d'écrire des tests est que je trouve des bogues lorsque j'écris des tests. Je pense que dans une perspective différente pour m'aider à écrire du code plus robuste. Mais il est vrai que la couverture des tests pourrait être limitée. Dans ce cas, les AQ peuvent toujours nous faire savoir ce qu'ils aimeraient être couverts. Ou, nous pouvons ajouter passivement plus de tests lorsque nous voyons des erreurs.

Je fais de l'AQ, et contrairement à la plupart des domaines, savoir utiliser notre code est beaucoup plus difficile que d'apprendre n'importe quelle programmation tranquille. Nous comptons donc sur les développeurs pour nous fournir des cas de test pour leurs toutes nouvelles fonctionnalités de whizzbang, car nous ne saurions pas comment. Dans tous les cas, les problèmes d'AQ sont plus liés aux régressions et aux choses qui se cassent qu'aux tests originaux de nouvelles fonctionnalités. Dans tous les cas, lorsque le résultat est un calcul complexe, il est difficile de savoir ce qu'est une bonne réponse et ce qui est une mauvaise réponse, ou même si une terminaison anormale est une bonne ou une mauvaise chose.

En tout cas, un développeur, s'il est honnête, sait probablement quelque chose des vulnérabilités de ses bébés. Il sait probablement à quelles valeurs de paramètre, il doit sélectionner différents algorithmes ou domaines dans une recherche de table ou autre chose. Sachant que, s'il est sincère au sujet de tests rigoureux, il devrait être capable de générer une suite de tests de taille raisonnable couvrant une grande partie du code.