Patrón “Humble Object”

Hace un tiempo escribí un post en el blog de Wave Engine sobre cómo podemos aplicar el patrón Humble Object para aislar dependencias en nuestro código y aquí tenéis la versión traducida al español.

CodedUI Test & Jenkins

He necesitado integrar la ejecución de tests de interfaz con CodedUI Test para una aplicación de WPF con Jenkins.

El problema es que para poder ejecutar los test de interfaz es necesario una sesión interactiva iniciada. Con esa sesión se ejecutarán los test de interfaz que necesitan interactuar con el ratón y teclado. Lamentablemente esta sesión está activa mientras tengas por ejemplo una conexión por escritorio remoto (RDC)  abierta, pero claro, no queremos tener que abrir una RDC para pasar los tests.

Pues ha sido duro pero lo he conseguido, y aquí os dejo los pasos que he hecho para hacerlo

Nota: El Jenkins que hemos usado NO se estaba ejecutando como servicio así que si tienes Jenkins corriendo como servicio no se si esto te puede ayudar.

Un detalle de la parametrización de CodedUITests con CSV

Hay un detalle que no nos cuentan en MSDN  Creating a Data-Driven Coded UI Test

Resulta que me he puesto a crear el primer test parametrizado y en mi csv tenía este contenido:

User,Passwd
1111,pass0000
7777776,4444

Cuando se ejecutaba el test, en la row del test paremetrizado que debería obtenerme el “pass0000”, me estaba obteniendo un string vacío:

Para que no ocurra esto, simplemente hay que modificar el archivo csv y añadirle comillas a los valores que queremos que nos devuelva:

User,Passwd
“1111”,”pass0000″
“7777776”,”4444″

Me ha traido loco durante dos horas, espero que a alguien más le sirva.

Juan María Laó Ramos

 

Primeros pasos con Xamarin.UITests para aplicaciones híbridas

Hemos tenido la oportunidad de empezar a “trastear” con Xamarin.UITest para validar la interfaz de usuario de una aplicación hecha con Cordova, y desplegarlo en Test Cloud para correr los tests en varios dispositivos físicos.

Vamos a partir de la base de que habéis creado un proyecto de Xamarin.UITest, lo primero que debemos hacer es arrancar un emulador o un dispositivo físico para desplegar la app y ejecutar los tests. Para arrancar la aplicación, una vez que el emulador o el dispositivo físico esté arrancado, sólo tenemos que añadir este código:

public class AppInitializer
{
    public static IApp StartApp(Platform platform, Xamarin.UITest.Configuration.AppDataMode mode = Xamarin.UITest.Configuration.AppDataMode.Auto)
    {
        if (platform == Platform.Android)
        {
            return ConfigureApp
                .Android
                .EnableLocalScreenshots()
                .ApkFile("../../../Apps/myapp.apk")
                .StartApp(mode);
        }

<pre><code>    return ConfigureApp
        .iOS
        .EnableLocalScreenshots()
        .AppBundle(&amp;quot;../../../Apps/myapp.app&amp;quot;)
        .StartApp(mode);
}
</code></pre>

}

Fijáos que vamos a testar la UI de una aplicación multiplataforma desarrollada con Cordova para iOS y Android, por lo que hemos decidido usar un único punto de entrada para ambas aplicaciones. El motivo de todo esto es crear un conjunto de tests multiplataforma para Android e iOS. Así que con esta simple clase, en cada clase de test que tengamos, el método de “Setup” será algo parecido a:

[SetUp]
public void BeforeEachTest()
{
    app = AppInitializer.StartApp(platform);
}

De este modo, podemos asumir que antes de que se ejecute cada test la aplicación estará arrancada para poder ir navegando por ella a partir de la pantalla de inicio. Así estamos listos para empezar a testar la interfaz de usuario.

El flujo de trabajo es simple:

1. Esperar hasta que el elemento con el que queremos interactuar aparece en la interfaz:Con esta línea estamos pidiéndole a la aplicación que se espere hasta que aparezca un div en el componente WebView. El método “WaitForElement” tiene varias sobrecargas con diferentes parámetros en los que le podemos modificar el timeout, etc. Esto puede ser útil en algunos casos, como por ejemplo, cuando el div se muestre después de una operación que pueda tardar más tiempo de lo normal

    this.app.WaitForElement(c => c.WebView().Css("div.MyStyleClass"));

1. Interactuar con la UI:Este método nos permite simular taps en la aplicación. La interfaz IApp de Xamarin.UITest ofrece bastantes métodos con los que podemos interactuar con la app como Scrolldown, PressEnter, PinchToZoomIn, etc…

this.app.Tap(c =&gt; c.WebView().Css("div.MyStyleClass "));</li>

1. Esperar a lo que queremos testar. Vamos a asumir que después de hacer tap en el div que hemos estado esperando, aparecerá otro div. Así que esperamos a que aparezca el segundo div:

this.app.WaitForElement(c => c.WebView().Css("div.MySecondDivClass"));

El test completo tiene esta pinta:

[Test]
public void AfterTappingDiv2MustBeShown()
{
    this.app.WaitForElement(c => c.WebView().Css("div.MyStyleClass"));
    this.app.Tap(c => c.WebView().Css("div.MyStyleClass"));
    this.app.WaitForElement(c => c.WebView().Css("div.MySecondDivClass"));
}

En este punto tenemos un test que podemos ejecutar en la misma aplicación en ambas plataformas, iOS y Android, y esperamos que en ambas plataformas se comporte de la misma forma.

En algunas ocasiones, por cada test que queramos hacer necesitaremos “ver” el código de la interfaz de usuario. Esto lo conseguimos usando el método “Repl()” que está en la interfaz IApp. Cuando invoquemos a este método aparecerá una consola en nuestro pc:

En esta consola podemos llamar a cualquier método de la interfaz IApp. Es muy útil ya que podemos usarlos para ir creando paso a paso los test que queremos ir haciendo.

Por ejemplo, si esperamos a un elemento que no aparecerá en la UI, la consola mostrará algo así:

Sin embargo, si el elemento existe, REPL nos mostrará el HTML del elemento.

Con esta funcionalidad tan simple somos capaces de transformar tests manuales en tests automáticos. Con esto conseguimos transformar un trabajo muy costoso en un trabajo totalmente automatizado.

Artículo original publicado en el blog Xamarin Team de Plainconcepts

Slides ALMdeando

Aquí os dejo las slides de la charla Making Better tests que vimos en el evento ALMdeando en Cartuja .NET

 Gracias a todos los asistentes.

Resumen de la Mesa redonda de TDD con Cartuja .NET

Ayer desde Cartuja .Net hicimos una mesa redonda sobre TDD y la conversación fue muy, pero que muy ilustradora sobre todo para mí.

Aquí mi resumen:

Tras hablar sobre las últimas novedades que habían aparecido en la comunidad .NET tras las presentaciones de #vsconnect y conseguir centrarnos, comenzamos con una explicación sobre qué es TDD muy corta, apenas 30 segundos:

“TDD consiste en que cuando vamos a escribir código, hacer primero un test que falle para el código que queremos escribir, luego el mínimo código que hace que el test se ponga verde, y refactorizar el código que hemos escrito”

Seguimos con la duda que yo tengo sobre ese ciclo, y es que, como ya comenté en otro post, el ciclo es incompleto, falta una primera fase de “pensar” antes incluso de escribir ese primer test.

Es decir, tomar muchas veces papel y lápiz, y dibujar la “arquitectura” que creemos debe ser. Una vez que tenemos separadas las responsabilidades que el sistema debe tener, cogemos una de esas clases y podemos empezar a aplicar TDD sobre esa clase.

Suele ocurrir que al escribir ese test y escribir el código se encuentran dependencias que antes no se habían tenido en cuenta. Es decir, responsabilidades ocultas y suele generar en otra clase que tendremos que mockear para poder seguir avanzando en el ciclo de TDD y avanzando en el nuestro trabajo.

Y aquí llego la primera disputa sobre el concepto de que “la arquitectura emerge“. Tras un rato de dialogo sobre eso, saqué la conclusión de que esa arquitectura que emerge no es la arquitectura del sistema completo, sino la arquitectura del contexto en el que está centrado ese test.

Mi conclusión particular sobre este punto, es que aplicando TDD nos obligamos a pensar en responsabilidades, nos obligamos a seguir el principio de una única responsabilidad y esto, paso a paso, test a test, nos ayuda a averiguar si aquella arquitectura que teníamos en la cabeza, que dibujamos con papel y lápiz en un primer momento es adecuada o no. Como corolario podemos decir que si nos resulta difícil seguir avanzando en ciclos cortos de test-code-refactor, hay que replantearse esa arquitectura ya que parece que esa elección no es adecuada, y eso es bueno, ya que al menos hemos encontrado una forma de no hacerlo.

Tras unas cuantas experiencias que compartimos, buenas y malas, continuamos con la conversación sobre las bonanzas del testing, integración continua, TFS, Team City, programación defensiva, y un largo etcétera. Todos estamos de acuerdo sobre las ventajas, sabemos que es bueno hacer test. Hasta que alguien nos hizo caer en la cuenta de que desde hacía un buen rato no estábamos hablando sobre TDD sino de testing. Así que recondujimos la conversación con el tema de la práctica y la maestría.

Obviamente no es lo mismo empezar a aplicar TDD que llevar tiempo aplicándola. La famosa curva de aprendizaje es en realidad así:

Tenemos un nivel de productividad (verde) y cuando empezamos hay una bajada de productividad importante y empezamos el camino de la práctica hasta que volvemos a alcanzar el mismo nivel de productividad que teníamos antes. En realidad esto pasa con todas las tecnologías y técnicas que aprendemos a lo largo de nuestra carrera, y es en esa parte de la curva cuando optamos por abandonar o seguir con el camino que hemos iniciado.

El problema con TDD es que para mentes como yo, ese proceso es duro y es muy fácil desistir y abandonar, el lado oscuro siempre nos tienta, es más fácil, más rápido y más seductor no seguir por el camino de TDD.

Continuamos con la pregunta de ¿hay que hacer TDD siempre? En el camino del aprendizaje, nos vamos dando cuenta de que es descabellado hacer TDD en todo. En ese camino se aprende a ser pragmático y a ajustarse a las necesidades del proyecto y del momento en el que estamos trabajando. Pero sobre todo, se aprende en ese camino a diseñar. TDD no es sólo una herramienta de testing, es mucho más, es una herramienta de diseño. En el camino de maestría de TDD se aprende sobre todo a diseñar, y con el tiempo se consigue empezar a acertar en esa primera “arquitectura” que pintamos en un papel. Normalmente los problemas que resolvemos suelen ser parecidos, y vamos mejorando esa arquitectura que dibujamos al principio.

Como última ventaja que le veo a TDD es que cuando no tenemos claro cómo solucionar un problema, TDD ayuda a encontrar una solución, empezando a escribir ese primer test de aquello que queremos programar pero no tenemos claro cómo hacerlo. Conseguimos tener un diseño desacoplado, abierto a la extensión y cerrado a la modificación, etc.… De esta forma cuando averiguamos qué es lo que hay que hacer nos es más sencillo modificar esa arquitectura.

Después de todas las experiencias que vimos, es curioso que siempre los que suelen ir a este tipo de eventos, y tu que estás leyendo esto, son siempre profesionales que buscan formas de hacer mejor su trabajo.

Quiero dejaros algunos nombres y libros que surgieron en la conversación, se que me falta alguno, así que si te acuerdas déjamelo en los comentarios:

• Mark Seemann: http://blog.ploeh.dk/
  
• Armadillo de Pedro J. Molina: http://www.codeproject.com/Articles/12334/Armadillo-Unit-Testing-of-inline-SQL-with-a-little
  

Muchas gracias a Cartuja .NET por reunir a todos los que allí nos juntamos, ha sido una tarde muy agradable y tengo la sensación de que todos nos quedamos con ganas de más.

Estoy deseando ver la visión de cada uno que asistió, bien en los comentarios de este humilde blog o con referencias a los blogs de los que allí nos juntamos. No quiero señalar http://javiersuarezruiz.wordpress.com/, http://www.variablenotfound.com, http://cartujadotnet.es/

Se me olvidó comentar que mañana es el de Global CodeRetreat http://globalday.coderetreat.org/

En Madrid lo tienen preparado: http://madridcoderetreat.wordpress.com/

Si podéis verlo seguro que os gustará.

Nuevas funcionalidades sobre testing en la interfaz Web de TFS

Vamos a ver una nueva funcionalidad que aún no he usado y me ha dejado enamorado.

Se trata de crear casos de test’s a partir de un archivo Excel en TFS con la interfaz web.

Primero, tendremos que crear un plan de tests, en la pestaña “Test” y creamos un nuevo “Test plan” haciendo clic en el “+”:

1. Los Test Plans y Suites son work items

[Mindcamp 2014] How I met testing

En Mayo me invitaron a la Mindcamp 2014, Un evento que se viene celebrando de año en año.

Quería compartir la charla que di sobre cómo conocí el mundo del testing y cómo desde entonces duermo mejor.

Espero que os guste y no dejéis de ver los videos de las demás charlas de la Mindcamp, hay auténticas joyas

El enésimo post sobre el Singleton (UPDATE 1)

La cosa es que el Singleton hace dos cosas:

• Se asegura de que sólo haya una instancia del objeto.

• SomeStuff()

El problema de hacer dos cosas es que viola la S de los principios Solid: Single Responisability Principle. Y esto hace que no sea fácilmente testeable.

Cuando quiero hacer que sea testeable quito el Singleton y lo sustituyo por una factoría, una clase estática y una clase que hace la funcionalidad de SomeStuff.

Aquí tenéis un ejemplo simple:

public static class Singletons
 {
     private static Factoria fact = new Factoria();

<pre><code> public static void HazLoTuyo()
 {
     fact.GetUnicaInstancia().DoStuff();
 }
</code></pre>

}

public class Factoria
 {
     private Clase unicaInstancia;

<pre><code> public Factoria()
 {
     unicaInstancia = new Clase();
 }

 public Clase GetUnicaInstancia()
 {
     return this.unicaInstancia;
 }
</code></pre>

}

public class Clase
 {
     public Clase()
     {
     }

<pre><code> public void DoStuff() { }
</code></pre>

}

De esta manera puedo testear la clase Clase sin preocuparme de que sólo hay una instancia de ella en el sistema.

Es por esto que me asalta la duda, ¿no será el Singleton un antipatron?

¿Cómo lo veis vosotros?

[Update 1]

Gracias a los comentarios voy a ir actualizando el post con algunas conclusiones y dudas que se me plantean.

Resumiendo un poco los comentarios, cuando sólo queremos una instancia de nuestra clase Clase (definida más arriba) suele ser buena idea usar un inyector de dependencias y registrar nuestra clase para que el inyector nos devuelva siempre la misma instancia.

De esta manera “invertimos el control” de la instanciación de nuestra clase, y podemos testearla de manera aislada.

¿Pero que pasa si no queremos meter un inyector de dependencias por el motivo que sea?

Podríamos meter una clase parecida a esta:

 public class ClaseFachada
 {
     private static Clase clase = new Clase();

<pre><code> public static void DoStuff()
 {
     clase.DoStuff();
 }
</code></pre>

}

De esta manera podemos usarla en nuestro código de esta forma:

ClaseFachada.DoStuff();

Como si fuese un Singleton, pero evitando el típico Clase.Instance.DoStuff(). La cosa es que si estamos desarrollando una librería y queremos que nuestra librería se use así.

¿Os parece adecuado? ¿Cómo lo mejoraríais?

Knock, knock … Buenos días developer, venimos a hablarle de TDD

Aviso: Este es un post que te va a vender TDD.

En otras publicaciones han resumido las bonanzas de TDD, como el libro de @carlosble “Diseño ágil con TDD“. Os lo recomiendo desde ya.

Pero he encontrado una presentación de Francesco Carucci, antiguo desarrollador de Crytek que actualmente trabaja en Apple, en la que muestra/vende TDD desde el punto de vista del desarrollo de video juegos.

Me ha parecido muy bien estructurada y cómo vende TDD, así que lo pongo aquí para escribirlo, compartirlo y de manera egoísta, como un ejercicio para que me ayude a no olvidar algunas cosas.

La estructura consiste en poner las diferentes razones y excusas que solemos dar para no escribir tests o por qué no hacer TDD y las respuestas que deberíamos grabarnos como mantras. Así que allá vamos:

No hago Tests por que …

… el tiempo que gasto en escribir test es tiempo que podía estar escribiendo código.

• Al final gastamos más tiempo en debugear y mantener código que escribiéndolo.
• Si escribimos primero los test y el código que los pasa, el código que los pasa es código de producción. La consecuencia es que tardamos menos tiempo en tener código que funciona, esto es: código de producción.
• La modificación del código es más confiable. Cuando modificamos código lo hacemos “más tranquilos” ya que sabemos que vamos a romper pocas cosas, y si se rompen, nos vamos a dar cuenta rápido.
• Se evitan bugs de regresión. Al detectar un bug, escribimos un test que lo reproduzca y ese bug no volverá a aparecer.
• Se detectan antes los bugs, como ya vimos en el post anterior

… los test no lo pueden probar todo

• Un test es mejor que ninguno.
• El código legacy o de terceros no hay que testearlo a menos que tengamos que modificarlo.
• Roma no se construyó en un día, pero se construyó (y conquisto el mundo conocido)

… este código es temporal y lo cambiaré después, no necesito testearlo

• Todo el código se modifica tarde o temprano. Hacer código que sea fácil de cambiar es la razón fundamental de TDD: elimina la sobre-ingeniería (KISS, Keep It Simple, Stupid!)
• Los requisitos cambian: entonces hay que modificar los tests afectados y el código de producción. Pero como está testeado unitariamente, el código está más desacoplado, es más fácil de modificar y los cambios tendrán menos efectos secundarios.

En el mundo del desarrollo de juegos

El desarrollo de juegos es diferente: los test automatizados pueden no funcionar.

• En general el desarrollo de juegos es totalmente diferente …
• … pero escribir código es lo mismo, incluso más simple.
• El código de un juego es más algoritmia y matemáticas, eso es incluso más fácil de testear que un proceso de negocio.
• Un código de sobresaliente es lo mismo tanto en un juego como en una web.
• El código de un juego cambia a menudo: más cambios es un motivo más para tener test que comprueben que no se ha roto nada.

Los juegos son para divertirse, un test no puede comprobar que un juego sea divertido.

• Pero sí puedes capturar bugs, y menos tiempo debugando errores significa más tiempo para implementar la parte divertida.
• Crear un test para un bug te asegura que ese bug no volverá a aparecer (El 30% de las correcciones de bugs crean nuevos bugs debido a efectos colaterales)

Esto es un juego AAA, es muy arriesgado hacer test automatizados sobre él.

• Los juegos AAA son muy complejos, muy tecnológicos y muy divertidos. Para conseguir un juego AAA, se deben usar herramientas adecuadas, y los test automatizados son una de esas herramientas.
• Lo arriesgado es NO hacer test en un juego AAA

¿Cuándo TDD no es apropiado?

• Prototipos. Mientras buscamos/probamos posibles soluciones a un problema.
  • La solución final SÍ debe estar hecha con TDD.
• En el código de wrappers de librerías existentes.
• En la capa GUI, eso no es testing unitario, es testing de integración.
• En código de bajo nivel, el que está muy cerca del hardware

Objetivo: Producir más funcionalidades en menos tiempo.

No perdamos de vista el objetivo, producir lo antes posible código que vaya a producción, esto es código que funciona, libre de bugs y mantenible

¿Y tu porqué no haces Test o TDD?