TDD pour le traitement par lots: comment faire?

J'aime "rouge / vert / refactor" pour RoR, etc. très bien.

Mon travail de jour implique le traitement par lots de très gros fichiers de tiers en python et d'autres outils personnalisés.

Le désabonnement des attributs de ces fichiers est élevé, il y a donc beaucoup de correctifs / améliorations appliqués assez fréquemment.

Les tests de régression via un ensemble connu de données de test avec les résultats attendus n'existent pas. La chose la plus proche est en cours d'exécution par rapport au dernier lot avec de nouveaux cas de test codés à la main, assurez-vous qu'ils ne explosent pas, puis appliquez des tests statistiques et des vérifications ponctuelles pour voir si les données semblent toujours correctes.

Q >> Comment intégrer les principes TDD dans ce type d'environnement?

Juste un FYI: le test unitaire n'est pas équivalent au TDD. TDD est un processus dont le test unitaire est un élément.

Cela dit, si vous envisagez de mettre en œuvre des tests unitaires, vous pouvez faire un certain nombre de choses:

Tous les nouveaux codes / améliorations sont testés

De cette façon, vous n'avez pas à parcourir et à tester tout ce qui existe déjà, de sorte que la bosse initiale de la mise en œuvre des tests unitaires est beaucoup plus petite.

Testez des données individuelles

Tester quelque chose qui peut contenir de grandes quantités de données peut entraîner de nombreux cas marginaux et des lacunes dans la couverture des tests. Considérez plutôt l'option 0, 1, many. Testez un «lot» avec 0 éléments, 1 élément et plusieurs éléments. Dans le cas d'un élément, testez les différentes permutations dans lesquelles les données de cet élément peuvent se trouver.

À partir de là, testez les cas de bord (limites supérieures de la taille des éléments individuels et quantité d'éléments dans le lot). Si vous exécutez les tests régulièrement et que vous avez des tests de longue durée (grands lots?), La plupart des exécuteurs de test autorisent la catégorisation afin que vous puissiez exécuter ces cas de test séparément (tous les soirs?).

Cela devrait vous donner une base solide.

Utilisation de données réelles

L'alimentation des données «réelles» précédemment utilisées comme vous le faites maintenant n'est pas une mauvaise idée. Complétez-le simplement avec des données de test bien formées afin de connaître immédiatement les points de défaillance spécifiques. En cas d'échec de traitement des données réelles, vous pouvez inspecter les résultats du traitement par lots, produire un test unitaire pour répliquer l'erreur, puis vous êtes de retour en rouge / vert / refactor avec des cas de régression utiles.

C'est la même chose que tout autre environnement.

Séparez la logique dans son plus petit niveau de granularité. Cela vous donnera un ensemble de règles pour le processus, chaque règle couvrira un élément de logique requis pour votre processus.

Ensuite, écrivez un test pour chaque règle. Ces tests échoueront. Écrivez le code pour corriger le test.

Le test de régression avec des données de test connues dont vous parlez n'est pas un test unitaire. Ce serait un test d'intégration, différent de TDD. Avec TDD, vous pouvez avoir un seul test pour tester que vous pouvez charger un fichier, mais généralement aucun autre test ne s'approcherait réellement d'un fichier de données avec des données de test. Au lieu de cela, vous simulez les données nécessaires à l'exercice d'une règle particulière à l'aide d'un objet moqueur.

Commencez avec une bonne stratégie logicielle, puis appliquez TDD.

(Avertissement: j'ai peut-être mal compris "désabonnement", ou TDD, ou les deux.)

Voici ma stratégie suggérée pour le traitement par lots de "données sales": Spécifier-Triage-Exécuter.

• Rédiger une spécification des données d'une manière stricte et étroite, mais couvrira la majorité (disons, 80% ou plus) des données entrantes. Appelez cette spécification 1 .
• Développer un module de triage (TDD si vous le souhaitez) qui décide si un enregistrement répond à la spécification 1.
  • Assurez-vous que le module fonctionne très rapidement.
  • Le module doit retourner vrai / faux: soit il respecte toutes les règles, soit il ne le fait pas.
• Développez un module d' exécution (TDD si vous le souhaitez) qui analyse un enregistrement connu pour répondre à la spécification 1, effectuant toutes les tâches nécessaires à vos clients.
• Appliquez le triage 1 sur toutes les données entrantes.
  • Le résultat est une valeur booléenne pour chaque enregistrement. Cela sépare fondamentalement les données entrantes en: Spécification 1 ou Inconnu.
  • Appliquez Exécuter 1 sur les données de spécification 1, chaque fois que le client en a besoin.
• Assouplissez les règles de la spécification 1 afin d'admettre 80% des données restantes. Appelez cette spécification 2 .
• Développer le triage 2 et exécuter 2 . Appliquez-le à toutes les données qui ne répondent pas à la spécification 1.
• Répétez l'opération pour autant de niveaux que nécessaire, jusqu'à ce que les données restantes soient suffisamment petites pour pouvoir être traitées manuellement tous les jours.

L'astuce de l'efficacité:

Enregistrez tous les résultats de triage (historiques ou actuels) associés à un enregistrement. Si aucun module de triage n'est modifié depuis la dernière exécution, il n'est pas nécessaire de l'exécuter à nouveau sur les anciennes données.

Le tidbit "vous devez savoir ce que vous voulez construire avant de faire TDD":

La spécification-triage-exécution est une façon de maintenir les exigences gérables à chaque niveau et permet une croissance future.

(Si quelqu'un connaît les termes standard corrects pour ces trois étapes, faites-le moi savoir, je modifierai mes réponses.)