De Clases a Records con Suites de Tests
En esta entrada vamos a entrar un poco mas en práctica, y vamos a ver una aplicación su pertinente Suite de Tests, la cual usa Clases, y la vamos a refactorizar convirtiendo sus clases a Records, si no todas pues algunas de ellas.
De este modo vamos a poder ver como refactorizando una aplicación, en la que por ejemplo tengamos cualquier tipo de patrón para los Tests, bien sea el patrón Builder o el patrón Object Mother, nos va a costar mucho menos realizar dicha refactorización, y vamos a encontrarnos con muchas ventajas, evitando el famoso Shotgun Surgery, que ye vimos en otra entrada.
Además vamos a ver como se va a poder cambiar la implementación de inicialización de nuestros objetos sin tocar los Tests, ya que estos van a estar abstraídos de dicha inicialización.
Para este caso vamos a trabajar sobre el ejemplo del patrón Object Mother que tengo en object-mother-example subido, este es un ejemplo sencillo con una sola clase, la cual vamos a pasar a Record, pero no sin anter ver como trabaja con la igualdad de objetos de forma diferente entre Clases y Records
Para la refactorización vamos a usar otro repositorio diferente, el cual también dejo subido en GitHub y lo he llamado refactor-class-to-records-with-object-mother, ahí iré metiendo todos los cambios que vamos a ir haciendo. Básicamente aprovechando que tenemos el patrón object mother montado vamos a pasar la clase User a Record.
Primero vamos a ver como siendo una clase no es posible comparar valores de dos instancias siendo User una clase.
Para ello vamos a dejar la clase User tal cual estaba:
User.cs
public class User
{
public string Name { get; private set; }
public int Age { get; private set; }
public User(string name, int age)
{
Name = name;
Age = age;
}
public static User Create(string name, int age)
{
return new User(name, age);
}
}Lenguaje del código: C# (cs)
Y la clase del Patrón Object Mother igual que estaba también.
UserMother.cs
public class UserMother
{
public static User UserUnderEighteen()
{
return User.Create("Pepito Grillo", 16);
}
public static User UserOverEighteenUnderThirty()
{
return User.Create("Pepito Grillo", 29);
}
public static User UserOverThirtyUnderSixtyFive()
{
return User.Create("Pepito Grillo", 46);
}
public static User UserOverSixtyFive()
{
return User.Create("Pepito Grillo", 67);
}
}Lenguaje del código: C# (cs)
Y vamos a meter un nuevo Test donde vamos a crear dos usuarios que provengan del mismo Object Mother, y vamos a compararlos:
UserShould.cs
[Test]
public void user1_must_be_equals_user2()
{
var user1 = UserMother.UserUnderEighteen();
var user2 = UserMother.UserUnderEighteen();
Assert.AreEqual(user1, user2);
}Lenguaje del código: C# (cs)
El resultado de este Test lógicamente es rojo, porque como ya he comentado al ser una clase no se comparan solo los valores, se comparan también sus referencias, y son distintas.

Después de todo lo que hemos leído, aquí tendríamos dos soluciones, una de ellas que la veremos en una entrada posterior, donde os enseñaré una herramienta para que nos haga la vida mas fácil a la hora de hacer los Tests, y la otra es usar Records, que es lo que vamos a hacer en este caso.
Y sí, muchos de vosotros me diréis que podemos ir haciendo una comparación de igualdad en los Tests para cada una de las propiedades de User, pero en este caso tenemos dos propiedades, pero, ¿y si tenemos 100?
No me voy a enrollar más, y vamos a pasar a refactorizar la Clase User a Record, dejando el mismo Test que os he mostrado arriba:
User.cs
public record User(string Name, int Age);Lenguaje del código: PHP (php)
Lo primero que denotamos es que antes teníamos bastantes mas líneas, sólo para poder declarar la clase User.cs como objeto inmutable, y ahora con tan solo una línea hemos declarado un objeto inmutable.
UserMother.cs
public class UserMother
{
public static User UserUnderEighteen()
{
return new User("Pepito Grillo", 16);
}
public static User UserOverEighteenUnderThirty()
{
return new User("Pepito Grillo", 29);
}
public static User UserOverThirtyUnderSixtyFive()
{
return new User("Pepito Grillo", 46);
}
public static User UserOverSixtyFive()
{
return new User("Pepito Grillo", 67);
}
}Lenguaje del código: C# (cs)
La clase UserMother.cs hemos tenido que modificarla muy poco, ya que ahora en vez de realizar un User.Create() para crear una nueva instancia del objeto, llamamos directamente a new User(), y de este modo como todo lo teníamos centralizado en este Patrón Object Mother no hemos tenido que tocar nada en los Tests, abstrayéndose estos totalmente del cambio de implementación que hemos hecho en User.cs.
Veamos los Tests, como los hemos dejado igual:
Usershould.cs
public class HomeShould
{
private Home home;
[SetUp]
public void Setup()
{
home = new Home();
}
[Test]
public void user1_must_be_equals_user2()
{
var user1 = UserMother.UserUnderEighteen();
var user2 = UserMother.UserUnderEighteen();
Assert.AreEqual(user1, user2);
}
[Test]
public void get_message_under_eighteen_years()
{
//Given
var givenUserUnderEighteen = UserMother.UserUnderEighteen();
//When
var message = home.Access(givenUserUnderEighteen);
//Then
Assert.IsTrue(string.Equals(message, "Aplicación web solo para personas mayores de edad",
StringComparison.OrdinalIgnoreCase));
}
[Test]
public void get_message_over_eighteen_under_thirty_years()
{
//Given
var givenUserOverEighteenUnderThirty = UserMother.UserOverEighteenUnderThirty();
//When
var message = home.Access(givenUserOverEighteenUnderThirty);
//Then
Assert.IsTrue(string.Equals(message, "Consigue un descuento de 20€ en tu primer pedido",
StringComparison.OrdinalIgnoreCase));
}
[Test]
public void get_message_over_thirty_under_sixty_five_years()
{
//Given
var givenUserOverThirtyUnderSixtyFive = UserMother.UserOverThirtyUnderSixtyFive();
//When
var message = home.Access(givenUserOverThirtyUnderSixtyFive);
//Then
Assert.IsTrue(string.Equals(message, "Consigue un descuento de 25€ en tu primer pedido",
StringComparison.OrdinalIgnoreCase));
}
[Test]
public void get_message_over_sixty_five_years()
{
//Given
var givenUserOverSixtyFive = UserMother.UserOverSixtyFive();
//When
var message = home.Access(givenUserOverSixtyFive);
//Then
Assert.IsTrue(string.Equals(message, "Consigue un descuento de 30€ en tu primer pedido",
StringComparison.OrdinalIgnoreCase));
}
}Lenguaje del código: C# (cs)
Los Tests no se han modificado para nada, ya que como he comentado estos se abstraen totalmente de la implementación del objeto User.cs, y lo mejor de todo es que el primer Test de todos ahora nos da verde, ya que la comparación que está realizando es por valor y no por referencia:

Con esta práctica podemos ver de una forma mas clara parte de la teoría que comentaba en las entradas anteriores, ya lo demás lo dejo a vuestra práctica.
Como siempre, espero os haya gustado esta publicación y ¡gracias por leerme!
Os leo en comentarios que os ha parecido la entrada.