¿Deben mantenerse las classs de testing unitaria bajo control de versión con el rest del código?

Si creo un set de testings para un proyecto de desarrollo, ¿esas classs deberían mantenerse bajo control de versión con el rest del código del proyecto?

Sí, no hay ninguna razón para no ponerlos en control de la fuente. ¿Qué pasa si las testings cambian? ¿Qué pasa si las interfaces cambian, necesitando que las testings cambien?

Sí, todas las mismas razones por las que pones el código de producción en el control de fuente todavía se aplican a cualquier testing de unidad que escribas.

Es el clásico quién, dónde y por qué preguntas:

  • ¿Quién cambió el código?
  • ¿Cuándo lo cambiaron?
  • ¿Para qué lo cambiaron?

Estas preguntas son tan pertinentes para probar el código como lo son para el código de producción. Debes poner tu código de testing unitario en el repository.

Absolutamente. Las classs de testing deben mantenerse actualizadas con el código. Esto significa registrarlo y ejecutar las testings en continuous integration.

¡Absolutamente! Las classs de testing son código fuente y deben ser administradas como cualquier otro código fuente. Deberá modificarlos, realizar un seguimiento de las versiones y conocer el historial de mantenimiento.

También debe mantener los datos de testing bajo control de fuente a less que sea masivamente grande.

Las testings unitarias deben estar vinculadas a una base de código en su repository.

Sin otra razón que si tuviera que producir una versión de mantenimiento para una versión anterior, puede garantizar que, según la métrica de las testings de su unidad, su código no es peor de lo que era antes (y afortunadamente ahora es mejor).

De hecho si. ¿Cómo podría alguien pensar lo contrario?

Si usa las twigs de código, debe intentar que el código de testing encaje naturalmente en la línea de código principal para que, cuando se bifurque, las versiones correctas de las testings también se ramifiquen.

Sí, deberían. Las personas que consulten la última versión deberían poder probar el código en su máquina. Esto ayudará a identificar las dependencies faltantes y también puede proporcionarles documentation no oficial sobre cómo funciona el código.

Sí.

El código de testing es un código. Debe mantenerse, refactorizarse y versionarse. Es una parte de la fuente de su sistema.

Absolutamente, deberían ser tratados como ciudadanos de primera class de su código base. Necesitarán todo el amor y cuidado, es decir, el mantenimiento como lo hace cualquier pieza de código.

Sí, deberían. Debería verificar las testings y ejecutarlas cada vez que realice cambios en el código. Si los colocas en otro lugar, es mucho más problemático ejecutarlos.

Sí. Por todas las otras razones mencionadas aquí, además del hecho de que a medida que cambia la funcionalidad, su set de testings cambiará, y debería ser fácil get el set de testings correcto para cualquier versión, twig, etc. y tener las testings no solo en control de versiones, pero el mismo repository que tu código es la forma de lograrlo.

Sí, por todos los motivos anteriores también, si está utilizando un server de continuous integration que está "viendo" el control de su fuente, puede hacer que ejecute las últimas testings de unidad en cada confirmación.

Esto significa que una compilation fallada es el resultado de fallas en las testings de la unidad y del código no comstackdo.

Absolutamente. Es probable que descubra que a medida que cambia el código, es posible que las testings también tengan que cambiar, por lo que es probable que desee tener un logging de esos cambios, especialmente si las testings o el código dejan de funcionar de repente. 😉

Además, las cajas de testing de la unidad deben mantenerse lo más cerca posible del código real que están probando (la parte inferior del mismo file parece ser el estándar). Es tanto por conveniencia como por mantenimiento.

Para leer un poco más acerca de lo que hace una buena testing de unidad, revisa esta publicación de stackoverflow .