Estrategia de ramificación de Git integrada con pruebas / proceso de control de calidad

¡Nuestro equipo de desarrollo ha estado utilizando la estrategia de ramificación de GitFlow y ha sido excelente!

Recientemente reclutamos un par de probadores para mejorar la calidad de nuestro software. La idea es que un probador pruebe o controle cada característica.

En el pasado, los desarrolladores trabajan en características en ramas de características separadas y las fusionan de nuevo con la developrama cuando terminan. El desarrollador probará su trabajo él mismo en esa featurerama. Ahora con los probadores, comenzamos a hacer esta pregunta

¿En qué rama debe probar el probador las nuevas funciones?

Obviamente, hay dos opciones:

• en la rama de características individuales
• en la developrama

Prueba en la rama de desarrollo

Inicialmente, creíamos que este es el camino seguro porque:

• La función se prueba con todas las demás funciones fusionadas con la developrama desde que comenzó su desarrollo.
• Cualquier conflicto puede ser detectado más temprano que tarde
• Facilita el trabajo del probador, solo está tratando con una rama ( develop) en todo momento. No necesita preguntarle al desarrollador qué rama es para qué característica (las ramas de características son ramas personales administradas exclusiva y libremente por desarrolladores relevantes)

El mayor problema con esto es:

• La developrama está contaminada con insectos.

  Cuando el probador encuentra errores o conflictos, los informa al desarrollador, que soluciona el problema en la rama de desarrollo (la rama de características se abandonó una vez fusionada), y podría haber más correcciones necesarias después. Múltiples confirmaciones o fusiones de subsecuencia (si una rama se developvuelve a crear fuera de la rama para corregir los errores), hace posible deshacer la función desde la developrama muy difícil si es posible. Hay múltiples características que se fusionan y se fijan en la developsucursal en diferentes momentos. Esto crea un gran problema cuando queremos crear una versión con solo algunas de las características de la developrama

Prueba en la rama de funciones

Así que pensamos nuevamente y decidimos que deberíamos probar características en las ramas de características. Antes de probar, fusionamos los cambios de la developrama a la rama característica (ponerse al día con la developrama). Esto es bueno:

• Todavía prueba la característica con otras características en la corriente principal
• El desarrollo adicional (por ejemplo, corrección de errores, resolución de conflictos) no contaminará la developrama;
• Puede decidir fácilmente no lanzar la función hasta que esté completamente probada y aprobada;

Sin embargo, hay algunos inconvenientes

• El probador debe fusionar el código, y si hay algún conflicto (muy probable), tiene que pedirle ayuda al desarrollador. Nuestros probadores se especializan en pruebas y no son capaces de codificar.
• una característica podría probarse sin la existencia de otra nueva característica. Por ejemplo, las características A y B están bajo prueba al mismo tiempo, las dos características no se conocen entre sí porque ninguna de ellas se ha fusionado con la developrama. Esto significa que tendrá que probar contra la developrama nuevamente cuando ambas características se fusionen con la rama desarrollada de todos modos. Y debes recordar probar esto en el futuro.
• Si las características A y B se prueban y aprueban, pero cuando se fusiona se identifica un conflicto, los dos desarrolladores de ambas características creen que no es su culpa / trabajo porque su característica se ramificó después de la prueba. Hay un gasto adicional en la comunicación y, a veces, quien resuelve el conflicto se siente frustrado.

Arriba está nuestra historia. Con recursos limitados, me gustaría evitar probar todo en todas partes. Todavía estamos buscando una mejor manera de lidiar con esto. Me encantaría saber cómo otros equipos manejan este tipo de situaciones.

La forma en que lo hacemos es la siguiente:

Probamos las ramas de características después de fusionar el último código de rama de desarrollo en ellas. La razón principal es que no queremos "contaminar" el código de sucursal de desarrollo antes de que se acepte una característica. En caso de que una característica no sea aceptada después de la prueba, pero nos gustaría lanzar otras características ya fusionadas en el desarrollo que sería un infierno. Develop es una rama desde la que se realiza un lanzamiento y, por lo tanto, debería estar en un estado liberable. La versión larga es que probamos en muchas fases. Más analíticamente:

1. El desarrollador crea una rama de características para cada nueva característica.
2. La rama de características se implementa (automáticamente) en nuestro entorno TEST con cada confirmación para que el desarrollador la pruebe.
3. Cuando el desarrollador termina la implementación y la característica está lista para ser probada, fusiona la rama de desarrollo en la rama de características y despliega la rama de características que contiene todos los últimos cambios de desarrollo en TEST.
4. El probador prueba en TEST. Cuando termina, "acepta" la historia y fusiona la rama característica en desarrollar. Dado que el desarrollador había fusionado previamente la rama de desarrollo en función, normalmente no esperamos demasiados conflictos. Sin embargo, si ese es el caso, el desarrollador puede ayudar. Este es un paso complicado, creo que la mejor manera de evitarlo es mantener las características tan pequeñas / específicas como sea posible. Las diferentes características tienen que fusionarse eventualmente, de una forma u otra. Por supuesto, el tamaño del equipo juega un papel en la complejidad de este paso.
5. La rama de desarrollo también se implementa (automáticamente) en TEST. Tenemos una política que, aunque las compilaciones de la rama de características pueden fallar, la rama de desarrollo nunca debe fallar.
6. Una vez que hemos alcanzado una congelación de funciones, creamos una versión de desarrollo. Esto se implementa automáticamente en STAGING. Se realizan extensas pruebas de extremo a extremo antes del despliegue de producción. (ok tal vez exagero un poco, no son muy extensos, pero creo que deberían serlo). Idealmente, los probadores / colegas beta, es decir, los usuarios reales deberían probar allí.

Que piensas de esta aproximación?

Antes de la prueba, fusionamos los cambios de la rama de desarrollo a la rama de características

No. No, especialmente si 'nosotros' es el probador de control de calidad. La fusión implicaría resolver posibles conflictos, lo cual es mejor para los desarrolladores (conocen su código) y no para el probador de control de calidad (que debe proceder a realizar las pruebas lo más rápido posible).

Haga que el desarrollador haga un cambio de base de su featurerama encimadevel y empuje esa featurerama (que ha sido validada por el desarrollador como compilando y trabajando sobre el develestado de la rama más reciente ).
Eso permite:

• Una integración muy simple en la rama de características (combinación trivial de avance rápido).
• o, como lo recomienda Aspasia a continuación en los comentarios , una solicitud de extracción (GitHub) o una solicitud de fusión (GitLab) : el mantenedor hace una fusión entre la rama PR / MR de la característica y develop, pero solo si GitHub / GitLab no detecta ningún conflicto.

Cada vez que el probador detecta un error, lo informará al desarrollador y eliminará la rama de la función actual.
El desarrollador puede:

• arreglar el error
• rebase encima de una rama de revelado recientemente obtenida (nuevamente, para asegurarse de que su código funcione en integración con otras características validadas)
• Empuja la featurerama.

Idea general: asegúrese de que la parte de fusión / integración sea realizada por el desarrollador, dejando la prueba al control de calidad.

El mejor enfoque es la integración continua , donde la idea general es fusionar las ramas de características en la rama del desarrollador con la mayor frecuencia posible. Esto reduce la sobrecarga de los dolores de fusión.

Confíe en las pruebas automatizadas tanto como sea posible y haga que las compilaciones se inicien automáticamente con las pruebas unitarias de Jenkins. Haga que los desarrolladores hagan todo el trabajo fusionando sus cambios en la rama principal y proporcionen pruebas unitarias para todo su código.

Los evaluadores / QA pueden participar en revisiones de código, marcar las pruebas unitarias y escribir pruebas de integración automatizadas para agregarlas al conjunto de regresión a medida que se completan las características.

Para obtener más información, consulte este enlace .

Usamos lo que llamamos "oro", "plata" y "bronce". Esto podría llamarse prod, puesta en escena y qa.

He venido a llamar a esto el modelo de crisol. Funciona bien para nosotros porque tenemos una gran necesidad de control de calidad en el aspecto comercial de las cosas, ya que los requisitos pueden ser difíciles de entender en comparación con los técnicos.

Cuando un error o característica está lista para probar, entra en "bronce". Esto desencadena una compilación jenkins que empuja el código a un entorno precompilado. Nuestros probadores (por cierto, no son súper técnicos) simplemente presionan un enlace y no les importa el control de la fuente. Esta compilación también ejecuta pruebas, etc. Hemos ido una y otra vez en esta compilación, empujando el código al entorno de prueba \ qa si las pruebas (unidad, integración, selenio) fallan. Si prueba en un sistema separado (lo llamamos plomo), puede evitar que los cambios se envíen a su entorno qa.

El temor inicial era que tendríamos muchos conflictos entre estas características. Sucede cuando la característica X hace que parezca que la característica Y se está rompiendo, pero es poco frecuente y realmente ayuda. Ayuda a obtener una amplia gama de pruebas fuera de lo que parece ser el contexto del cambio. Muchas veces, por suerte, descubrirá cómo su cambio afecta el desarrollo paralelo.

Una vez que una característica pasa el control de calidad, la movemos a "plateado" o puesta en escena. Se ejecuta una compilación y las pruebas se ejecutan nuevamente. Semanalmente empujamos estos cambios a nuestro "árbol de oro" o de producción y luego los implementamos en nuestro sistema de producción.

Los desarrolladores comienzan sus cambios desde el árbol de oro. Técnicamente, podría comenzar desde la puesta en escena, ya que subirán pronto.

Las soluciones de emergencia se dejan caer directamente en el árbol de oro. Si un cambio es simple y difícil de realizar un control de calidad, puede pasar directamente a la plata, que encontrará su camino hacia el árbol de pruebas.

Después de nuestro lanzamiento, empujamos los cambios en oro (prod) a bronce (prueba) solo para mantener todo sincronizado.

Es posible que desee volver a redactar antes de ingresar a su carpeta de ensayo. Hemos descubierto que purgar el árbol de pruebas de vez en cuando lo mantiene limpio. Hay momentos en que las características se abandonan en el árbol de prueba, especialmente si un desarrollador se va.

Para las grandes características de múltiples desarrolladores, creamos un repositorio compartido separado, pero lo fusionamos en el árbol de prueba de la misma manera cuando estamos listos. Las cosas tienden a rebotar desde el control de calidad, por lo que es importante mantener sus conjuntos de cambios aislados para que pueda agregar y luego fusionar / aplastar en su árbol de etapas.

"Hornear" también es un buen efecto secundario. Si tiene algún cambio fundamental que desea dejar reposar por un tiempo, hay un buen lugar para ello.

También tenga en cuenta que no mantenemos versiones anteriores. La versión actual es siempre la única versión. Aun así, es probable que tengas un árbol maestro para hornear en el que tus evaluadores o la comunidad puedan ver cómo interactúan los diferentes contribuyentes.

No confiaría solo en las pruebas manuales. Automatizaría la prueba de cada rama de características con Jenkins. Configuré un laboratorio VMWare para ejecutar pruebas de Jenkins en Linux y Windows para todos los navegadores. Es realmente una increíble solución de prueba multiplataforma, navegador cruzado Pruebo funcional / integración con Selenium Webdriver. Mis pruebas de selenio se ejecutan bajo Rspec. Y los escribí especialmente para que jRuby los cargue en Windows. Ejecuto pruebas unitarias tradicionales en Rspec y pruebas Javascript en Jasmine. Configuré pruebas sin cabeza con Phantom JS.

En nuestra empresa no podemos utilizar el desarrollo ágil y necesitamos la aprobación de cada cambio por parte de la empresa, esto causa muchos problemas.

Nuestro enfoque para trabajar con GIT es este;

Hemos implementado "Git Flow" en nuestra empresa. Usamos JIRA y solo los boletos JIRA aprobados deben ir a producción. Para la aprobación de la Prueba, la extendimos con una Rama de Prueba separada creada.

Los pasos para procesar un Boleto JIRA son:

1. Crear una nueva sucursal desde Develop-Branch
2. Hacer los cambios de código en la rama de características
3. Extraiga de la función los cambios en la rama Prueba / QA
4. Después de la aprobación comercial, llevamos el cambio de la rama de características al desarrollo
5. El desarrollo se realiza con frecuencia en una versión y, finalmente, en la rama maestra.

Dividir cada solicitud en una función propia garantiza que solo los cambios aprobados se envíen a producción.

El proceso completo se ve así: