Primeros pasos con Moq: un ejemplo básico de TDD con Mocking

Después de “Introducción a los Tests Unitarios, TDD y Mocking” y tras la serie de artículos sobre GRASP hoy me he decidido a mostrar de forma práctica el TDD con Mocking. Quiero hacerlo así, con uno o dos ejemplos sencillos porque estoy preparando unas sesiones de TDD para patrones de diseño, es decir, como enfocar un desarrollo guiado por pruebas cuando se va a atacar cierto patrón de diseño. 

En el ejemplo de hoy voy a partir de aquel ejemplo de la calculadora pero hoy voy a empezar desde cero.  Voy a hacer un diagrama estático de clases primero, para definir una serie de paquetes, interfaces y clases, y un diagrama de secuencia después, para ver cuál va a ser el caso de uso que voy a atacar mediante TDD y Mocking. 

Voy a improvisar unos requisitos: “Queremos desarrollar una calculadora que delegue sus cálculos en una serie de servicios de cálculo. Para comenzar queremos que nuestra calculadora sea capaz de sumar y restar dos números enteros positivos utilizando para tal fin los servicios SumCalculatorService y RestCalculatorService a cuyas interfaces tenemos acceso.”

Bueno, voy a hacer el diagrama estático de clases de todo ésto, a ver qué sale:

¿Se ve claro? Seguro que si pero lo explico, hay dos paquetes, uno el cliente, en azul y otro el servidor, en rojo. El servidor contiene o contendrá los servicios de suma (ISumCalculatorService) y de resta (IRestCalculartorService). Está la clase Calculadora que tiene dependencias (linea punteada con flecha simple hacia la dependencia) con ambos servicios y que implementa (linea punteada con felcha triangular blanca) la interfaz ICalculator. En cuanto al servidor he dicho que contiene o contendrá los servicios y digo contiene o contendrá porque haciendo TDD con Mocking no nos hace falta tener el sistema completo ya que lo que voy a hacer va a ser simular el comportamiento de las dependencias de la clase o de la funcionalidad concreta de la clase que se quiere probar.

A veces siento que soy muy enrevesado expresándome pero es lo que hay, no hay una manera menos enrevesada de explicarlo. El desenrevesador que lo desenrevese buen desenrevesador será. XD!

Antes de empezar a tirar lineas de código de pruebas  voy  a definir un primer ámbito en las pruebas. Las primeras pruebas pueden ser del tipo WhenCreatingTheObject, es decir, cuando se crea el objeto. Aquí  voy  a probar la inyección de dependencias en la clase calculadora y que de verdad implemente ICalculator. 

Y ya va siendo hora de abrir el Visual Studio para crear el proyecto del cliente, al que voy a llamar PrimerosPasosConMoq, y el proyecto que alojará los tests, PromerosPasosConMoqTests. Por cierto, dentro de dos días sale Visual Studio 2012 y creo que me voy a comprar la versión profesional y a estudiarme las mejoras a fondo, cuando lo hice con el 2010 fue duro al principio pero ahora no puedo vivir sin él y me pasó exactamente lo mismo con el Visual Studio 2005. 

Una vez creados los proyectos  voy  con las interfaces, tendré por un lado las de los servicios, que yo las escribo aquí pero que podrían, o deberían mejor dicho, estar en un ensamblado aparte:

public interface ISumCalculatorService
{
    int SumaDosNumeros(int num1, int num2);
}

public interface IRestCalculatorService
{
    int RestaDosNumeros(int num1, int num2);
}

Y ya si en el proyecto “definitivo” la interfaz ICalculator con los métodos que se han definido en el diagrama de clases:

public interface ICalculator
{
    int SumaDosNumeros(int num1, int num2);
    int RestaDosNumeros(int num1, int num2);
}

Ahora  voy  al proyecto de tests y le agrego las siguientes referencias, una al proyecto “definitivo” y otra a la librería de Moq (se supone que cualquier desarrollador con un mínimo de experiencia es capaz de encontrar Moq, descargarlo, descomprimirlo y añadir la referencia a la librería correspondiente a su proyecto de tests), la tercera referencia es a la librería de .Net Microsoft.VisualStudio.QualityTools.UnitTestFramework y la última al proyecto con la clase UnitTestBase que contiene y obliga a utilizar el patrón AAA en nuestros tests.

Bien, pues ya va siendo hora de empezar a pensar en tests. Como decía, lo primero que hay que probar es la construcción del objeto calculadora, la inyección de dependencias, y para ello voy a crear una clase WhenCreatingCalculadora que, para cumplir con la metodología AAA heredará de UnitTestBase. Como recordatorio voy a pegar el código de UnitTestBase pero ya estaba disponible en “Introducción a los Tests Unitarios, TDD y Mocking“:

using Microsoft.VisualStudio.TestTools.UnitTesting;
/* *
 * 
 * Los tests unitarios tienen un comportamiento muy simple:
 * 
 * 1º Arrange()    -> Organizar las precondiciones
 * 2º Act()        -> Actuar, es decir, ejecutar lo que se quiere probar
 * 3º Assert()     -> Verificar que se han cumplido las postcondiciones
 * 
 * Esta visión simplista junto con una buena nomenclatura harán tu TDD mucho más sencillo.
 * 
 * Juan García Carmona
 * 
 * */

namespace ArrangeActAssert
{
    [TestClass]
    public abstract class UnitTestBase
    {
        [TestInitialize]
        public void Init()
        {
            Arrange();
            Act();
        }

        protected virtual void Arrange()
        {
        }

        protected abstract void Act();

        [TestCleanup]
        public void Cleanup()
        {
            System.Windows.Threading.Dispatcher.CurrentDispatcher.InvokeShutdown();
        }
    }
}

Según escribo el código de WhenCreatingCalculadora veo un error, no existe la clase Calculadora, es buena señal pues estamos haciendo TDD y se trata de escribir pruebas y refactorizar el código para que las pruebas compilen y pasen. Voy a crear una clase Calculadora vacía para que compile y, de momento, el código de WhenCreatingCalcualdora tiene el siguiente aspecto:

using ArrangeActAssert;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using PrimerosPasosConMoq.Ejemplo1.Client;
using PrimerosPasosConMoq.Ejemplo1.Server;

namespace PrimerosPasosConMoqTests.Ejemplo1.Client.CalculadoraTests
{
    [TestClass]
    public class WhenCreatingCalculadora : UnitTestBase
    {
        protected Calculadora _objectoToTest;
        protected Mock<IRestCalculatorService> RestCalculatorServiceMock;
        protected Mock<ISumCalculatorService> SumCalculatorServiceMock;

        protected override void Arrange()
        {
            base.Arrange();
            RestCalculatorServiceMock = new Mock();
            SumCalculatorServiceMock = new Mock();
        }

        // Act, como queremos que lance excepciones, lo voy a trasladar a cada método
        protected override void Act(){}

    }
}

En ése código destacan los objetos Mock, son objetos falsos que implementan cada una de las interfaces, IRestCalculatorService e ISumCalculatorService, y son los que voy a utilizar para escribir las pruebas sobre la inyección de dependencias. La primera prueba puede ser que si al primer parámetro le pasamos un objeto nulo el constructor lance una excepción. El código del test quedará así:

[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ItShouldThrowAnArgumentNullExceptionWhenSumCalculatorServiceIsNull()
{
    _objectoToTest = new Calculadora(null, RestCalculatorServiceMock.Object);
}

Pero claro, éste código da errores de compilación porque Calculadora, que es una clase vacía, no tiene ningún constructor que acepte dos argumentos. ¿Por qué no lo tiene? Porque aún no lo he escrito. De nuevo hay que refactorizar para adaptar el código a los tests, voy a hacer que Calculadora herede de ICalculator y a ponerle un constructor que acepte dos argumentos.

public class Calculadora : ICalculator
{
    public Calculadora (ISumCalculatorService sumService, IRestCalculatorService restService)
    {
    }

    public int SumaDosNumeros(int num1, int num2)
    {
        throw new NotImplementedException();
    }

    public int RestaDosNumeros(int num1, int num2)
    {
        throw new NotImplementedException();
    }
}

public Calculadora (ISumCalculatorService sumService, IRestCalculatorService restService)
{
    if (sumService == null)
        throw new ArgumentNullException("sumService");
}

[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void ItShouldThrowAnArgumentNullExceptionWhenRestCalculatorServiceIsNull()
{
    _objectoToTest = new Calculadora(SumCalculatorServiceMock.Object,null);
}

public Calculadora (ISumCalculatorService sumService, IRestCalculatorService restService)
{
    if (sumService == null)
        throw new ArgumentNullException("sumService");
    if (restService == null)
        throw new ArgumentNullException("restService");
}

[TestMethod]
public void ItShouldImplementICalculator()
{
    _objectoToTest = new Calculadora(SumCalculatorServiceMock.Object, RestCalculatorServiceMock.Object);
    Assert.IsNotNull(_objectoToTest as ICalculator);
}

[TestMethod]
public void ItShouldReturnACalculatorThatImplementICalculatorWhenParamsAreOk()
{
    _objectoToTest = new Calculadora(SumCalculatorServiceMock.Object, RestCalculatorServiceMock.Object);
    // Es una calculadora, se ha creado correctamente
    Assert.IsNotNull(_objectoToTest);
    // y además implementa ICalculator
    Assert.IsNotNull(_objectoToTest as ICalculator);
}

using System;
using ArrangeActAssert;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using PrimerosPasosConMoq.Ejemplo1.Client;
using PrimerosPasosConMoq.Ejemplo1.Server;

namespace PrimerosPasosConMoqTests.Ejemplo1.Client.CalculadoraTests
{
    [TestClass]
    public class WhenCreatingCalculadora : UnitTestBase
    {
        protected Calculadora _objectoToTest;
        protected Moc<IRestCalculatorService> RestCalculatorServiceMock;
        protected Mock<ISumCalculatorService> SumCalculatorServiceMock;

        protected override void Arrange()
        {
            base.Arrange();
            RestCalculatorServiceMock = new Mock<IRestCalculatorService>();
            SumCalculatorServiceMock = new Mock<ISumCalculatorService>();
        }


        // Act, como queremos que lance excepciones, lo voy a trasladar a cada método
        protected override void Act() { }

        [TestMethod]
        public void ItShouldReturnACalculatorThatImplementICalculatorWhenParamsAreOk()
        {
            _objectoToTest = new Calculadora(SumCalculatorServiceMock.Object, RestCalculatorServiceMock.Object);
            // Es una calculadora, se ha creado correctamente
            Assert.IsNotNull(_objectoToTest);
            // y además implementa ICalculator
            Assert.IsNotNull(_objectoToTest as ICalculator);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void ItShouldThrowAnArgumentNullExceptionWhenSumCalculatorServiceIsNull()
        {
            _objectoToTest = new Calculadora(null, RestCalculatorServiceMock.Object);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void ItShouldThrowAnArgumentNullExceptionWhenRestCalculatorServiceIsNull()
        {
            _objectoToTest = new Calculadora(SumCalculatorServiceMock.Object, null);
        }

    }
}

[TestClass]
public abstract class WhenUsingTheCalculator : UnitTestBase
{
    protected Calculadora _objectToTest;
    protected Mock RestCalculatorServiceMock;
    protected Mock SumCalculatorServiceMock;

    protected override void Arrange()
    {
        base.Arrange();
        RestCalculatorServiceMock = new Mock();
        SumCalculatorServiceMock = new Mock();
        // Esto ya lo hemos probado y sabemos que funciona:
        _objectToTest = new Calculadora(SumCalculatorServiceMock.Object, RestCalculatorServiceMock.Object);
    }
}

[TestClass]
public abstract class WhenAddingTwoNumbers : WhenUsingTheCalculator
{
    protected abstract int X { get; }
    protected abstract int Y { get; }
    protected int result;

    protected override void Arrange()
    {
        base.Arrange();
        // Cuando al servicio 'falso' le pase dos números
        // Que devuelva la suma de ambos
        SumCalculatorServiceMock.Setup(x => x.SumaDosNumeros(X, Y)).Returns(X + Y);
    }

    protected override void Act()
    {
        result = _objectToTest.SumaDosNumeros(X, Y);
    }
}

[TestClass]
public class WhenAddingTwoPositiveNumbers : WhenAddingTwoNumbers
{
    protected override int X { get { return 13; } }
    protected override int Y { get { return 45; } }

    [TestMethod]
    public void ItShouldReturnTheCorrectResult()
    {
        Assert.AreEqual(58, result);
    }
}

public class Calculadora : ICalculator
{
    private readonly ISumCalculatorService _sumService;
    
    public Calculadora (ISumCalculatorService sumService, IRestCalculatorService restService)
    {
        if (sumService == null)
            throw new ArgumentNullException("sumService");
        if (restService == null)
            throw new ArgumentNullException("restService");

        _sumService = sumService;
    }

    public int SumaDosNumeros(int num1, int num2)
    {
        return _sumService.SumaDosNumeros(num1, num2);
    }

    public int RestaDosNumeros(int num1, int num2)
    {
        throw new NotImplementedException();
    }
}

[TestClass]
public abstract class WhensubtractingTwoNumbers : WhenUsingTheCalculator
{
    protected abstract int X { get; }
    protected abstract int Y { get; }
    protected int result;

    protected override void Arrange()
    {
        base.Arrange();
        // Cuando al servicio 'falso' le pase dos números
        // Que devuelva la resta de ambos
        RestCalculatorServiceMock.Setup(x => x.RestaDosNumeros(X, Y)).Returns(X - Y);
    }

    protected override void Act()
    {
        result = _objectToTest.RestaDosNumeros(X, Y);
    }
}

[TestClass]
public class WhenSubtractingTwoPositiveNumbers : WhensubtractingTwoNumbers
{
    protected override int X { get { return 13; } }
    protected override int Y { get { return 45; } }

    [TestMethod]
    public void ItShouldReturnTheCorrectResult()
    {
        Assert.AreEqual(-32, result);
    }
}

public class Calculadora : ICalculator
{
    private readonly ISumCalculatorService _sumService;
    private readonly IRestCalculatorService _subsService;
    
    public Calculadora (ISumCalculatorService sumService, IRestCalculatorService restService)
    {
        if (sumService == null)
            throw new ArgumentNullException("sumService");
        if (restService == null)
            throw new ArgumentNullException("restService");

        _sumService = sumService;
        _subsService = restService;
    }

    public int SumaDosNumeros(int num1, int num2)
    {
        return _sumService.SumaDosNumeros(num1, num2);
    }

    public int RestaDosNumeros(int num1, int num2)
    {
        return _subsService.RestaDosNumeros(num1, num2);
    }
}