MVC ASP NET

UNIT TEST CON MVC

TDD, es la abreviatura de Test Driven Development (Desarrollo Orientado a

Pruebas) y es una metodología donde se contempla el ciclo de vida del desarrollo
de software de la siguiente forma:

-Creación de las pruebas unitarias o unit testing

-Implementación del código que está probando la prueba
-Refactoring del código anteriormente implementado

Para que esta metodología funcione, el código tiene que estar lo suficiente
estructurado como para poder crear unit test que prueben pequeñas partes de la
funcionalidad y si todos los elementos de una lógica coinciden.

En software una prueba unitaria no es más que una clase con algún método que
permite probar otro método, para evaluar el resultado se utilizan Asserts
(afirmaciones), del siguiente modo: sabemos que el método Pow de la clase Math
nos dará como resultado "a" elevado a "b", bien para probarlo escribiríamos el
siguiente código:

Las pruebas unitarias son de mucha ayuda, permiten detectar problemas de diseño,
nos ayudan a hacer código más atómico, a tener componentes probados antes de la
integración, pero es necesario detenerse a pensarlas un momento para que sean
correctas.

Vamos a crear un nuevo proyecto llamado ProyectoPruebasUnitarias y lo

marcaremos la opción “Add Unit Test”.

1
 MVC ASP NET

Abrimos un proyecto nuevo de tipo Aplicación Web ASP Net(Net Framework).

Marcar la opción “Crear también un proyecto para pruebas unitarias”.
Lo primero que vemos es que nos ha creado dos proyectos. Uno es el proyecto MVC
con el que realizaremos todas las acciones y el producto final.
El otro proyecto sirve para testear si todos los elementos coinciden con una lógica
de negocio.

2
 MVC ASP NET

En el proyecto Test, podemos ver la carpeta Controllers la clase

HomeControllerTest.

HOMECONTROLLERTEST.CS

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using ProyectoPruebasUnitarias;
using ProyectoPruebasUnitarias.Controllers;

namespace ProyectoPruebasUnitarias.Tests.Controllers
{
[TestClass]
public class HomeControllerTest
{
[TestMethod]
public void Index()
{
// Arrange

3
 MVC ASP NET

HomeController controller = new HomeController();

// Act
ViewResult result = controller.Index() as ViewResult;

// Assert
Assert.IsNotNull(result);
}

[TestMethod]
public void About()
{
// Arrange
HomeController controller = new HomeController();

// Act
ViewResult result = controller.About() as ViewResult;

// Assert
Assert.AreEqual("Your application description page.",
result.ViewBag.Message);
}

[TestMethod]
public void Contact()
{
// Arrange
HomeController controller = new HomeController();

// Act
ViewResult result = controller.Contact() as ViewResult;

// Assert
Assert.IsNotNull(result);
}
}
}

En la clase, comprobamos que está realizando pruebas sobre los métodos

ActionResult de la clase HomeController del proyecto MVC.

Para que una clase sea parte de la prueba unitaria, debe contener la siguiente
decoración:

Los métodos que deseamos evaluar, deben contener la siguiente decoración:

Concretamente, nos interesa la palabra clave Assert.

4
 MVC ASP NET

Mediante Assert, podemos comprobar si los resultados son los esperados, por
ejemplo, si enviamos un modelo a una vista, si el producto final es el adecuado o si
coinciden los elementos de la lógica con un producto final.
Para realizar las pruebas, debemos ir al menú Test  Run  All Test

En la ventana Test Explorer, podremos comprobar que todos los resultados son los
correctos:

Ahora vamos a realizar un ejemplo práctico para comprobar que una vista recibe un
modelo o que estamos enviando un dato adecuado a la vista en ViewBag.

Proyecto MVC.

Sobre la carpeta Models, nos creamos una clase llamada Persona.

PERSONA.CS

public class Persona

{
public int Id { get; set; }
public String Nombre { get; set; }
public String Apellidos { get; set; }
public int Edad { get; set; }
}

5
 MVC ASP NET

Sobre la carpeta Controller nos creamos un controlador llamado

PersonasController.

PERSONASCONTROLLER.CS

using ProyectoPruebasUnitarias.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace ProyectoPruebasUnitarias.Controllers
{
public class PersonasController : Controller
{
public List<Persona> GetPersonas()
{
return new List<Persona>{
new Persona
{
Id = 1,
Nombre = "Adrian",
Apellidos = "Garcia",
Edad = 23
},

new Persona
{
Id = 2,
Nombre = "Lucia",
Apellidos = "Ramos",
Edad = 15
},

new Persona
{
Id = 3,
Nombre = "Vitorino",
Apellidos = "Lopez",
Edad = 31
},

new Persona
{
Id = 4,
Nombre = "Luis",
Apellidos = "Gallego",
Edad = 34
},
};
}

// GET: Personas
public ActionResult Index()
{
return View();
}

public ActionResult MostrarPersonas()

{
ViewBag.Titulo = "Lista de Personas";

6
 MVC ASP NET

List<Persona> lista = this.GetPersonas();

return View(lista);
}
}
}

Sobre la carpeta Views, nos habrá creado una vista llamada Personas.
Añadimos una nueva Vista llamada MostrarPersonas y seleccionamos Layout List y
Model Persona.

Proyecto Test

Sobre la carpeta Controllers, creamos una nueva clase Unit Test llamada
PersonasControllerTest.

PERSONASCONTROLLERTEST.CS

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using ProyectoPruebasUnitarias.Controllers;
using System.Web.Mvc;
using System.Collections.Generic;
using ProyectoPruebasUnitarias.Models;

namespace ProyectoPruebasUnitarias.Tests.Controllers

7
 MVC ASP NET

{
[TestClass]
public class PersonasControllerTest
{
[TestMethod]
public void MostrarPersonas()
{
//CREAMOS EL CONTROLADOR
PersonasController controller = new PersonasController();
//CAPTURAMOS LOS RESULTADOS
//DE LA LLAMADA AL ACTIONRESULT
ViewResult result = controller.MostrarPersonas() as ViewResult;
//COMPROBAMOS QUE DEVUELVE LA VISTA
Assert.IsNotNull(result);
}
}
}

Si ejecutamos la prueba de Test, veremos que los resultados son correctos.

Ahora vamos a comprobar si la vista recibe una lista de personas.

Escribimos las siguientes líneas dentro de PersonaControllerTest y del método

MostrarPersonas.

//VAMOS A COMPROBAR QUE EL ACTION

//DEVUELVE UN MODELO
var lista = result.Model;
Assert.IsNotNull(lista);

Y podremos visualizar que todo sigue correcto.

Ahora, sobre el proyecto MVC, vamos a modificar el código del ActionResult

MostrarPersonas y quitamos la devolución de la lista sobre la vista.

public ActionResult MostrarPersonas()

{
ViewBag.Titulo = "Lista de Personas";
List<Persona> lista = this.GetPersonas();
return View();
}

Ejecutamos de nuevo Unit Test.

Y podremos visualizar que no pasamos las pruebas y que nuestra aplicación es

“inestable” en algún momento.

8
 MVC ASP NET

Pongamos que devolvemos una lista con una condición, tampoco pasaríamos la
prueba Test debido a que deseamos que siempre se reciban personas en la vista
MostrarPersonas.

Si modificamos el código del ActionResult MostrarPersonas.

public ActionResult MostrarPersonas()

{
ViewBag.Titulo = "Lista de Personas";
List<Persona> lista = this.GetPersonas();
int num = 0;
if (num == 0)
{
return View();
}
else
{
return View(lista);
}
}

Y ejecutamos Unit Test, veremos que los resultados son los mismos, ya que
comprueba que el objeto Model podría ser NULL en algún momento,
independientemente que se cumpla la condición o no.

También podemos comprobar si el resultado de una operación es igual a lo

esperado, por ejemplo, incluyendo el siguiente Assert dentro del método
MostrarPersonas de MVC.

Assert.AreEqual("Lista de Personas", result.ViewBag.Titulo);

Si coincide, nos mostrará que el resultado es el esperado y pasaremos la prueba.