miércoles, 4 de julio de 2018

Capítulo 33: Design Patterns - Pluggable Object - TDD By Example

La manera más simple de expresar una variación es hacerlo de manera explícita a través de condicionales:

En el momento que se hace una variación de manera explícita esta se va a comenzar a extender por todo el código añadiendo complejidad al mismo. Por esta razón la segunda vez que se vea un condicional de este tipo es el momento de utilizar «Plugabble Object».

Cuando en su día Erich Gamma y Kent Beck escribieron un editor gráfico dieron con un problema donde aplicar este patrón. Cuando estaban desarrollando la herramienta de selección si estaban sobre una figura y se presionaba el botón del ratón el resto de movimientos del ratón arrastraba la figura hasta soltar el botón. Si no había una figura entonces se estaba seleccionando un grupo de figuras. Arrastrar el ratón provocaba incrementar el rectángulo de selección hasta soltar el botón y en ese momento se seleccionaban todas las figuras que estuvieran en el rectángulo de selección.

El código inicial podría ser algo similar al siguiente.

En este caso se puede apreciar como la variación de si hay una figura seleccionada se extiende por el código. Una posible solución para resolver este problema es crear un «Pluggable Object», un «SelecctionMode» con dos implementaciones «SingleSelection» y «MultipleSelection».


Se tendrá que implementar una interfaz con las dos implementaciones.

Capítulo 33: Design Pattern - Template Method - TDD By Example

Hay ocasiones en las que se implementa un método que definen una serie de operaciones. Si tenemos otro método que implementa las misma serie de operaciones pero con algunas partes variables entonces se puede hacer un refactorización en la que se crea una clase padre con el método con las partes comunes y las subclases implementen las partes variables.

En el ejemplo de xUnit se puede apreciar la secuencia de operaciones de la clase padre «TestCase».

Las clases hijas son las que implementan los distintos métodos.

La pregunta que surge es cuándo se debería escribir una implementación por defecto. En los casos de los métodos «setUp()», «tearDown()» no tienen operaciones por defecto aunque son necesarios para el funcionamiento de la secuencia por lo que habría que implementarlos.

Si la secuencia de operaciones necesita una operación la cual necesita una implementación específica entonces se debería advertir declarando el método abstracto o implementando el método y lanzando una excepción.

lunes, 2 de julio de 2018

Capítulo 33: Design Pattern - Null Object - TDD By Example

Hay ocasiones en las que los programadores tendrán que comprobar si una variable tiene un valor nulo y esta comparación puede repetirse a lo largo de diversas partes del código.

En el siguiente ejemplo se puede apreciar como, cada vez que se hace una búsqueda de una campaña se tiene que hacer una comprobación por si fuera nulo el valor devuelto.


Una posible solución es representar este caso especial con un objeto.


Cada vez que alguien utilice el método «find()» del repositorio, en aquellos casos en los que no se encuentre la campaña, se devolverá el objeto del caso especial.


Con esta estrategia ya no hay que preocuparse de realizar la comprobación ya que esta se realiza en un único sitio y en caso de ser nula devuelve el objeto especial. Con lo que el código original queda más sencillo.

Capítulo 33: Design Pattern - Value Object - TDD By Example

Si dos objetos A y B hacen referencia a un tercero C y A cambia el estado de C entonces B no debería confiar en el estado de C.

Una posible solución es no compartir los objetos en los que se confía si no hacer copias de los mismos. Esto lleva a un mayor uso de espacio y tiempo. Otra solución sería utilizar el patrón Observer de manera que se avise explícitamente de la modificación cuando se produzca un cambio. Esto complica los flujos de control y la lógica.

Otra solución es tratar al objeto como un objeto que no cambia. De esta manera se podrá hacer referencia a él sin miedo a que cambie el estado.

Cuando se implementa el patrón «Value Object» cada operación que se define sobre un objeto devuelve un nuevo objeto sin alterar el objeto original desde el que se hizo la operación.

Cuando se usa un patrón «Value Object» todos los objetos que lo implementan deberían implementar un mecanismo para comprobar la igualdad entre dos de ellos. Cinco euros deberían ser iguales a cinco euros independientemente de si son referencias al mismo objetos o si son objetos distintos con el mismo valor.

Capítulo 33: design Patterns - Command - TDD By Example

Cuando una operación es más complicada que una simple llamada a un método se crea un objeto que albergue la operación y se ejecuta. Se encapsula la funcionalidad en el objeto y se le pasan los parámetros adecuados para su correcto funcionamiento.

Este patrón establece una interfaz común que permite ejecutar las operaciones de forma uniforme así como extender el sistema con nuevas operaciones de una forma sencilla.

Capítulo 33: Design Patterns - TDD By Example

Los patrones de diseño son soluciones que se aplican a problemas comunes. Estos no son un diseño final si no es una descripción de cómo resolver un problema y que se puede aplicar en diversa situaciones. Se pueden considerar como buenas prácticas para resolver estos problemas comunes cuando se está diseñando una aplicación o sistema.

Se van a presentar los siguientes patrones de diseño:

  • Command: representa la invocación de un operación como un objeto no simplemente como un mensaje.
  • Value Object: evita problemas creando objetos que nunca cambian una vez que se han creado.
  • Null Object: representa el caso base de una operación por un objeto.
  • Template Method: representa secuencias invariables de operaciones con un método abstracto el cual se define a través de la herencia.
  • Pluggable Object: evita subclases invocando dinamicamente diferentes métodos para diferentes instancias.
  • Factory Method: crea un objeto llamando a un método en vez de a un constructor.
  • Composite: representa la composición del comportamiento de una lista de objetos con un objeto.
  • Collecting Parameters: 
  • Imposter: introduce variaciones introduciendo a nueva implementación de un protocolo existente.

Patrón Escritura de prueba Refactor
Command X
Value Object X
Null Object X
Template Method X
Plugabble Object X
Pluggable Selector X
Factory Method X X
Composite X X
Collecting Parameter X X
Imposter X X

domingo, 1 de julio de 2018

Capítulo 32: xUnit Patterns - TDD By Example

La manera de comprobar si un código funciona correctamente es escribir un expresión binaria que juzgue si el código funciona.

En el caso de las pruebas automatizados significa que hay que tener todas esas expresiones almacenadas en forma de pruebas de manera que se lance un instrucción o se pulse un botón de manera que se ejecuten y comprueben todas esas expresiones. Esto sugiere:

  • Que las expresiones tienen que ser binarias. Funciona o no funciona.
  • El estado de las expresiones las comprueba el entorno llamando a alguna variantes de un método «assert()».

Las afirmaciones tienen que ser lo más precisas posibles. Si un el área de un rectángulo tiene que ser 50, di que este debería ser 50 y (assertTrue($rectangle->area() == 50)) y no algo maś genérico como (assertTrue($rectangle->area() != 0)).

Es recomendable revisar si la librería xUnit tiene una afirmación especial para comparar valores así una entrada para un mensaje de error en el que podamos indicar qué está sucediendo. Por ejemplo,



Las pruebas no deberían en ningún caso depender de la implementación por lo que si esta cambia, las pruebas, deberían seguir ejecutándose normalmente.

Fixture

Cuando tenemos varias pruebas que utilizan un objeto común podemos sobreescribir el método «setUp()» de la prueba e inicializar el objeto común.

Un ejemplo realmente simple podría ser inicializar un objeto común a varias pruebas.


En este caso podríamos deshacernos de la duplicación:


La relación entre las subclases de «TestCase» y las instancias de aquellas subclase es una de las partes más complicadas de xUnit. Cada nuevo tipo de «fixture» debería ser una nueva subclase de «TestCase». Cada nuevo «fixture» se crea en una instancia de esa subclase, se usa y se descarta.

En el ejemplo, si queremos escribir  una prueba para un rectangulo que no esté vacío entonces habrá que escribir una nueva clase, «NormalRectangleTest». En general, si hay un «fixture» ligeramente diferente entonces hay que crear una nueva clase de «TestCase».

External Fixture

La manera de liberar recursos externos en el «fixture» es sobreescribir el método «tearDown()» y liberar estos recursos.

El objetivo de las pruebas es comprobar si el código funciona pero las pruebas tienen que ejecutarse de manera independiente por lo que el estado debe ser siempre el mismo antes y después de ejecutarse una prueba.

Por ejemplo, si se abre un archivo al final de la ejecución de la prueba debería cerrarse.


Si «MyFile» se usa en varios pruebas entonces se podría hacer parte del «fixture».


Primero, si se utiliza en varias pruebas se puede apreciar que hay una duplicación de la cláusula «finally» que indica que se está perdiendo algo en el diseño. Segundo hay que cerrar el archivo mediante el método «close()» lo que se puede olvidar con cierta facilidad. Por último hay varios componentes en la prueba inicial, que son la parte «try», la parte «finally» y el propio cierre.

xUnit garantiza ejecutar el método «tearDown()» después de ejecutar el método de prueba e independientemente de lo que pase en este método. Así que se puede transformar el código anterior en el siguiente.


Test Method

Los método de prueba, por convección, se representan con un método que comienza con la palabra «test».

En el caso de utilizar «fixtures» todas las pruebas que comparten una misma «fixture» serán método de la misma clase. Las pruebas que tengan un «fixture» distinto tendrán una clase distinta.

Los métodos de prueba deberían tener un nombre descriptivo que comunique la intención de lo que se está probando.

Los método de prueba deberían ser fáciles de leer y deberían tener pocas líneas. Si un método de prueba se vuelve complejo de entender es posible que se necesite hacer varios métodos de prueba más sencillos.

Exception Test

Hay ocasiones en la que queremos probar si una excepción se lanza durante una ejecución. La prueba fallará sólo si la excepción no se lanza.


Alltest

Aunque actualmente la mayoría de IDE son capaces de ejecutar todos las pruebas.

Si se añade un prueba a un paquete y se añade un método de pruebas la siguiente vez que se ejecuten todos las pruebas también se debería ejecutar esta nueva prueba. En el caso de que el IDE no xUnit no soporte esta característica cada paquete debería declarar una clase «AllTest» que implemente un método estático «suite()» que devuelva una «TestSuite».

Se puede añadir este «AllTest» al método «main()» así la clase puede ejecutarse desde el IDE o la línea de comandos.