Pruebas Unitarias y Principio de Inversión de Dependencias en .NET

Clase 15 de 16 • Curso de Principios SOLID en C# y .NET

Contenido del curso

Introducción

Principio de responsabilidad única

Principio de abierto/cerrado

Principio de sustitución de Liskov

Principio de segregación de la interfaz

Principio de inversión de la dependencia

Cierre

16
Principios Solid en C Sharp: Mejora y Aplicación Práctica
02:21 min

Tomar examen

Resumen

¿Cómo manejar las dependencias en pruebas unitarias?

En el desarrollo de software, las pruebas unitarias son fundamentales para asegurar que el código funcione correctamente sin influencias externas. Sin embargo, uno de los retos mayores es manejar las dependencias externas como bases de datos o archivos, que pueden interferir con las pruebas. Aquí abordamos cómo podemos controlar estas dependencias y enfocarnos en probar la lógica esencial de nuestras aplicaciones.

¿Por qué es importante el principio de inversión de la dependencia?

El principio de inversión de la dependencia (DIP, por sus siglas en inglés) es crucial ya que permite desacoplar el código, haciendo las pruebas unitarias más seguras e independientes. Al aplicar este principio en nuestras pruebas, podemos simular (o "mockear") las dependencias, como servicios o repositorios, logrando:

Que las pruebas no dependan de bases de datos o servicios externos.
Control total sobre el comportamiento de las dependencias.
Pruebas más rápidas y confiables, sin estar limitadas por el entorno.

¿Cómo implementar mocks en el Student Controller?

Al trabajar con un controlador como el StudentController, es esencial reducir su dependencia de elementos externos. Veamos cómo podemos lograrlo con ejemplos prácticos de uso de mocks:

Mock de iLogBook: Para simular el comportamiento del iLogBook, encargado de registrar eventos en texto, usaremos librerías como Moq en .NET para hacer un mock de esta dependencia. Esto nos asegura que las pruebas unitarias no dependan del acceso a archivos durante su ejecución.
```
var logbookMock = new Mock<iLogBook>();
```
Mock de iStudentRepository: Similarmente, hacemos un mock del iStudentRepository con el fin de evitar conexiones a bases de datos reales. Definimos qué datos deben retornar ciertas funciones para asegurarnos de que las pruebas son previsibles y consistentes.
```
var studentRepositoryMock = new Mock<iStudentRepository>();
studentRepositoryMock.Setup(repo => repo.GetAll()).Returns(new List<Student>());
```

Mediante estas estrategias, podemos garantizar que pruebas como la de StudentController se ejecuten únicamente con la lógica interna del controlador, sin distracciones de configuraciones externas.

¿Cuál es la forma correcta de ejecutar las pruebas?

Una vez implementados los mocks, el siguiente paso es ejecutar nuestras pruebas unitarias para validar que se comporten tal como esperamos:

Compilación del proyecto de pruebas: Usar donnet build para asegurarnos de que no haya errores en el código de pruebas.
```
dotnet build
```
Ejecución de las pruebas: El comando dotnet test nos permite ejecutar las pruebas unitarias del proyecto, validando que todas pasen correctamente.
```
dotnet test
```

Si las pruebas pasan y no se crean archivos innecesarios o conexiones indeseadas, significa que los mocks funcionan como se espera.

¿Cómo asegurar la creación de código de calidad?

Para mantener la calidad en el desarrollo de nuestras aplicaciones, seguir los principios SOLID, especialmente en APIs, es vital. La capacidad de inyectar dependencias facilita aplicar estos principios y mejorar la flexibilidad y mantenibilidad del código.

Tarea recomendada: Intenta crear una prueba unitaria para el método add del studentRepository. Esto no solo refuerza el aprendizaje de estos principios, sino que te proporciona una base sólida para tu desarrollo futuro.

¡Sigue aprendiendo y practicando! Cada paso que das te acerca más a convertirte en un desarrollador experto en prácticas sólidas y rigurosas.

Aldhair Vera Camacho

student•

Hola, dejo mi solución al problema y añado los diferentes scripts que modifiqué.using Microsoft.AspNetCore.Mvc;namespace DependencyInversion;using Xunit;using DependencyInversion.Controllers;using Moq;using DependencyInversion; namespace Api.Tests;

public class StudentTest { // [Fact] // public void GetStudent() // { // var studentController = new StudentController(); // var resultGetStudents = studentController.Get(); // Assert.NotNull(resultGetStudents); // Assert.Equal(3, resultGetStudents.Count()); // }

[Fact] public void GetStudent() { var LogbookMock = new Mock<ILogbook>(); var stundentRepositoryMock = new Mock<IStudentRepository>(); stundentRepositoryMock.Setup(p=> p.GetAll()) .Returns(new List<Student>() { new Student(1, "Pepito Pérez", new List<double>() { 3, 4.5 }), new Student(2, "Mariana Lopera", new List<double>() { 4, 5 }), new Student(3, "José Molina", new List<double>() { 2, 3 }) }); var studentController = new StudentController(stundentRepositoryMock.Object, LogbookMock.Object); var resultGetStudents = studentController.Get(); Assert.NotNull(resultGetStudents); Assert.Equal(3, resultGetStudents.Count()); } [Fact] public void AddStudent() { var LogbookMock = new Mock<ILogbook>(); var studentRepositoryMock = new Mock<IStudentRepository>(); studentRepositoryMock.Setup(p=> p.GetAll()) .Returns(new List<Student>() { new Student(1, "Pepito Pérez", new List<double>() { 3, 4.5 }), new Student(2, "Mariana Lopera", new List<double>() { 4, 5 }), new Student(3, "José Molina", new List<double>() { 2, 3 }), new Student(4, "Aldhair Vera", new List<double>() { 5,5 }) }); var studentController = new StudentController(studentRepositoryMock.Object, LogbookMock.Object); studentController.Add(new Student(4, "Aldhair Vera", new List<double>() { 5,5 })); var resultGetStudents = studentController.Get(); Assert.NotNull(resultGetStudents); Assert.Equal(4, resultGetStudents.Count()); }} public class Student{ public int Id { get; set; } public string Fullname { get; set; } public List<double> Grades { get; set; } public Student() { this.Fullname = string.Empty; this.Grades = new List<double>(); } public Student(int id, string fullname, List<double> grades) { this.Id = id; this.Fullname = fullname; this.Grades = grades; } public string ToString() { string content = $"Student: {this.Id} - {this.Fullname} - Grades: "; for (int i = 0; i < this.Grades.Count; i++) { content += $" {this.Grades[i]}{((i >= this.Grades.Count - 1) ? "" : " - ")}"; } return content; }}

namespace DependencyInversion.Controllers; [ApiController, Route("student")]public class StudentController : ControllerBase{ IStudentRepository studentRepository; ILogbook logbook; public StudentController(IStudentRepository student, ILogbook log){ studentRepository = student; logbook = log; } [HttpGet] public IEnumerable<Student> Get() { logbook.Add($"returning student's list"); return studentRepository.GetAll(); } [HttpPost] public void Add([FromBody]Student student) { studentRepository.Add(student); logbook.Add($"The Student {student.Fullname} have been added"); Console.WriteLine($"The Student {student.ToString()} have been added"); foreach(var st in studentRepository.GetAll()){ Console.WriteLine($"{st.ToString()}"); } }}

using Microsoft.AspNetCore.Mvc;

namespace DependencyInversion.Controllers;

[ApiController, Route("student")]
public class StudentController : ControllerBase
{
    IStudentRepository studentRepository;
    ILogbook logbook;

    public StudentController(IStudentRepository student, ILogbook log){
        studentRepository = student;
        logbook = log;
    }

    [HttpGet]
    public IEnumerable<Student> Get()
    {
        logbook.Add($"returning student's list");
        return studentRepository.GetAll();
    }

    [HttpPost]
    public void Add([FromBody]Student student)
    {
        studentRepository.Add(student);
        logbook.Add($"The Student {student.Fullname} have been added");
        Console.WriteLine($"The Student {student.ToString()} have been added");

        foreach(var st in studentRepository.GetAll()){
            Console.WriteLine($"{st.ToString()}");
        }
    }
}

``````js
namespace DependencyInversion;

public class Student
{
    public int Id { get; set; }
    public string Fullname { get; set; }
    public List<double> Grades { get; set; }

    public Student()
    {
        this.Fullname = string.Empty;
        this.Grades = new List<double>();
    }

    public Student(int id, string fullname, List<double> grades)
    {
        this.Id = id;
        this.Fullname = fullname;
        this.Grades = grades;
    }

    public string ToString()
    {
        string content = $"Student: {this.Id} - {this.Fullname} - Grades: ";

        for (int i = 0; i < this.Grades.Count; i++)
        {
            content += $" {this.Grades[i]}{((i >= this.Grades.Count - 1) ? "" : " - ")}";
        }

        return content;
    }
}

``````js
using Xunit;
using DependencyInversion.Controllers;
using Moq;
using DependencyInversion;

namespace Api.Tests;


public class StudentTest 
{
    // [Fact]
    // public void GetStudent()
    // {
    //     var studentController = new StudentController();

    //     var resultGetStudents = studentController.Get();

    //     Assert.NotNull(resultGetStudents);
    //     Assert.Equal(3, resultGetStudents.Count());
    // }


    [Fact]
    public void GetStudent()
    {
        var LogbookMock = new Mock<ILogbook>();
        var stundentRepositoryMock = new Mock<IStudentRepository>();
        stundentRepositoryMock.Setup(p=> p.GetAll())
                                        .Returns(new List<Student>()
                                        {
                                            new Student(1, "Pepito Pérez", new List<double>() { 3, 4.5 }),
                                            new Student(2, "Mariana Lopera", new List<double>() { 4, 5 }),
                                            new Student(3, "José Molina", new List<double>() { 2, 3 })
                                        });

        var studentController = new StudentController(stundentRepositoryMock.Object, LogbookMock.Object);

        var resultGetStudents = studentController.Get();

        Assert.NotNull(resultGetStudents);
        Assert.Equal(3, resultGetStudents.Count());
    }

    [Fact]
    public void AddStudent()
    {
        var LogbookMock = new Mock<ILogbook>();
        var studentRepositoryMock = new Mock<IStudentRepository>();
        studentRepositoryMock.Setup(p=> p.GetAll())
                                        .Returns(new List<Student>()
                                        {
                                            new Student(1, "Pepito Pérez", new List<double>() { 3, 4.5 }),
                                            new Student(2, "Mariana Lopera", new List<double>() { 4, 5 }),
                                            new Student(3, "José Molina", new List<double>() { 2, 3 }),
                                            new Student(4, "Aldhair Vera", new List<double>() { 5,5 })
                                        });

        var studentController = new StudentController(studentRepositoryMock.Object, LogbookMock.Object);

        studentController.Add(new Student(4, "Aldhair Vera", new List<double>() { 5,5 }));
        var resultGetStudents = studentController.Get();

        Assert.NotNull(resultGetStudents);
        Assert.Equal(4, resultGetStudents.Count());
    }
}

Miguel Santiago Gómez Suárez

Carlos Andres Bohorquez Duran

Carlos Isael Ramírez González

Carlos Gomez

Carlos Fernando Galeano Espinosa

Joel Angel David Barrantes Palacios

Juan Navas

Hermann Klaus Seer Diaz

JULIAN ANDRES ALZATE HURTADO

Marcel Solera

José David Gómez Brenes

Thomas Isaid Castro Navarro

César Augusto Poveda Floréz

Stanley Melgar

Jason Galvis Camargo

Joseling Jomara González Contreras

Joseph Ruiz

Jose Noriega

ROMMEL DUAREZ SAENZ

Sebastian Londoño

Sebastian Jaramillo

Franklin Alexander Reyes Andres

Pruebas Unitarias y Principio de Inversión de Dependencias en .NET

Introducción

Principios SOLID en C# y .NET: Teoría y Práctica

Requisitos y Herramientas para Curso de Principios SOLID en C#

Prácticas de Código Limpio y Principios SOLID

Principios SOLID en Programación Orientada a Objetos

Principio de responsabilidad única

Principio de Responsabilidad Única en Programación Orientada a Objetos

Aplicación del Principio de Responsabilidad Única en C#

Principio de abierto/cerrado

Principio Abierto-Cerrado en C# para Extender Código sin Modificarlo

Aplicación del Principio de Abierto/Cerrado en Programación

Principio de sustitución de Liskov

Principio de Sustitución de Liskov en Programación SOLID

Aplicación del Principio de Sustitución de Liskov en Código SOLID

Principio de segregación de la interfaz

Principio de Segregación de Interfaces en Programación C#

Segregación de Interfaces en Programación SOLID

Principio de inversión de la dependencia

Principio de Inversión de Dependencia en Programación SOLID

Aplicación del Principio de Inversión de Dependencias en C#

Pruebas Unitarias y Principio de Inversión de Dependencias en .NET

Cierre

Principios Solid en C Sharp: Mejora y Aplicación Práctica