# Configuración del proyecto
## Contexto
Esta guía se basa en la documentación de Microsoft sobre [Pruebas de integración en ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/test/integration-tests). La muestra original utiliza una base de datos SQLite en memoria como almacenamiento de respaldo para las pruebas de integración. Reemplazarás SQLite por una instancia real de Microsoft SQL Server que se ejecuta en un contenedor Docker utilizando Testcontainers.
Puedes encontrar la muestra de código original en el repositorio [dotnet/AspNetCore.Docs.Samples](https://github.com/dotnet/AspNetCore.Docs.Samples/tree/main/test/integration-tests/IntegrationTestsSample).
## Clona el repositorio
Clona el repositorio de la guía de Testcontainers y accede al directorio del proyecto:
```console
$ git clone https://github.com/testcontainers/tc-guide-testing-aspnet-core.git
$ cd tc-guide-testing-aspnet-core
```
## Estructura del proyecto
La solución contiene dos proyectos:
```text
RazorPagesProject.sln
├── src/RazorPagesProject/ # Aplicación ASP.NET Core Razor Pages
└── tests/RazorPagesProject.Tests/ # Pruebas de integración de xUnit
```
### Proyecto de aplicación
El proyecto de aplicación (`src/RazorPagesProject/RazorPagesProject.csproj`) es una aplicación web Razor Pages que utiliza Entity Framework Core con SQLite como su proveedor de base de datos predeterminado:
```xml
net9.0
enable
all
runtime; build; native; contentfiles; analyzers; buildtransitive
```
El `ApplicationDbContext` almacena entidades `Message` y proporciona métodos para consultarlas y gestionarlas:
```csharp
public class ApplicationDbContext : IdentityDbContext
{
public ApplicationDbContext(DbContextOptions options)
: base(options)
{
}
public virtual DbSet Messages { get; set; }
public async virtual Task> GetMessagesAsync()
{
return await Messages
.OrderBy(message => message.Text)
.AsNoTracking()
.ToListAsync();
}
public async virtual Task AddMessageAsync(Message message)
{
await Messages.AddAsync(message);
await SaveChangesAsync();
}
public async virtual Task DeleteAllMessagesAsync()
{
foreach (Message message in Messages)
{
Messages.Remove(message);
}
await SaveChangesAsync();
}
public async virtual Task DeleteMessageAsync(int id)
{
var message = await Messages.FindAsync(id);
if (message != null)
{
Messages.Remove(message);
await SaveChangesAsync();
}
}
public void Initialize()
{
Messages.AddRange(GetSeedingMessages());
SaveChanges();
}
public static List GetSeedingMessages()
{
return new List()
{
new Message(){ Text = "You're standing on my scarf." },
new Message(){ Text = "Would you like a jelly baby?" },
new Message(){ Text = "To the rational mind, nothing is inexplicable; only unexplained." }
};
}
}
```
### Proyecto de pruebas
El proyecto de pruebas (`tests/RazorPagesProject.Tests/RazorPagesProject.Tests.csproj`) incluye xUnit, la infraestructura de pruebas de ASP.NET Core y el módulo MSSQL de Testcontainers:
```xml
net9.0
enable
all
runtime; build; native; contentfiles; analyzers; buildtransitive
all
runtime; build; native; contentfiles; analyzers; buildtransitive
Always
```
Las dependencias clave son:
- `Microsoft.AspNetCore.Mvc.Testing`: proporciona `WebApplicationFactory` para arrancar la aplicación en las pruebas
- `Microsoft.EntityFrameworkCore.SqlServer`: el proveedor de base de datos SQL Server para Entity Framework Core
- `Testcontainers.MsSql`: el módulo de Testcontainers para Microsoft SQL Server
### Fábrica de pruebas existente basada en SQLite
El proyecto original incluye una `CustomWebApplicationFactory` que reemplaza la base de datos de la aplicación con una instancia SQLite en memoria:
```csharp
public class CustomWebApplicationFactory
: WebApplicationFactory where TProgram : class
{
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(services =>
{
var dbContextDescriptor = services.SingleOrDefault(
d => d.ServiceType ==
typeof(DbContextOptions));
services.Remove(dbContextDescriptor);
var dbConnectionDescriptor = services.SingleOrDefault(
d => d.ServiceType ==
typeof(DbConnection));
services.Remove(dbConnectionDescriptor);
// Crea una SqliteConnection abierta para que EF no la cierre automáticamente.
services.AddSingleton(container =>
{
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
return connection;
});
services.AddDbContext((container, options) =>
{
var connection = container.GetRequiredService();
options.UseSqlite(connection);
});
});
builder.UseEnvironment("Development");
}
}
```
Aunque este enfoque funciona, SQLite tiene diferencias de comportamiento con respecto a la base de datos que usarías en producción. En la siguiente sección, la reemplazarás con una instancia de Microsoft SQL Server gestionada por Testcontainers.