dmolinari
0e363d1cfc
Agrega helper CreateClientWithOverrides en TestWebAppFactory que envuelve WithWebHostBuilder+ConfigureTestServices para inyectar stubs por test sin tocar la fábrica compartida. Usa el patrón para agregar 2 tests e2e: Deactivate_WhenProductQueryReturnsInUse_Returns409WithErrorCode (PRD-001/PRD-002) y CreateRubro_WhenParentHasAvisos_Returns409WithErrorCode (CAT-002). Remueve el comentario TODO PRD-002. 287 Api tests verdes.
249 lines
11 KiB
C#
249 lines
11 KiB
C#
using System.Net;
|
|
using System.Net.Http.Headers;
|
|
using System.Net.Http.Json;
|
|
using System.Text.Json;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.Mvc.Filters;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.DependencyInjection.Extensions;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using SIGCM2.Api.Filters;
|
|
using SIGCM2.Application.Abstractions.Persistence;
|
|
using SIGCM2.Domain.Exceptions;
|
|
using SIGCM2.TestSupport;
|
|
|
|
namespace SIGCM2.Api.Tests.Rubros;
|
|
|
|
/// <summary>
|
|
/// CAT-002 — Regla de Oro Rama vs Hoja.
|
|
///
|
|
/// Unit tests: ExceptionFilter mapping for new 409 cases (no DB needed).
|
|
/// Integration: GET /arbol returns tieneAvisos field per node (stub = false).
|
|
/// Integration: POST child under leaf with avisos → 409 (via per-test DI override, issue #36).
|
|
/// </summary>
|
|
[Collection("ApiIntegration")]
|
|
public sealed class RubrosReglaDeOroTests : IAsyncLifetime
|
|
{
|
|
private const string AdminEndpoint = "/api/v1/admin/rubros";
|
|
private const string ReadEndpoint = "/api/v1/rubros";
|
|
private const string AdminUsername = "admin";
|
|
private const string AdminPassword = "@Diego550@";
|
|
|
|
private readonly TestWebAppFactory _factory;
|
|
private readonly HttpClient _client;
|
|
|
|
public RubrosReglaDeOroTests(TestWebAppFactory factory)
|
|
{
|
|
_factory = factory;
|
|
_client = factory.CreateClient();
|
|
}
|
|
|
|
public Task InitializeAsync() => Task.CompletedTask;
|
|
public Task DisposeAsync() => Task.CompletedTask;
|
|
|
|
// ── Helpers ───────────────────────────────────────────────────────────────
|
|
|
|
private async Task<string> GetAdminTokenAsync()
|
|
{
|
|
var response = await _client.PostAsJsonAsync("/api/v1/auth/login", new
|
|
{
|
|
username = AdminUsername,
|
|
password = AdminPassword
|
|
});
|
|
response.EnsureSuccessStatusCode();
|
|
var json = await response.Content.ReadFromJsonAsync<JsonElement>();
|
|
return json.GetProperty("accessToken").GetString()!;
|
|
}
|
|
|
|
private HttpRequestMessage BuildRequest(HttpMethod method, string url, object? body = null, string? bearerToken = null)
|
|
{
|
|
var request = new HttpRequestMessage(method, url);
|
|
if (bearerToken is not null)
|
|
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", bearerToken);
|
|
if (body is not null)
|
|
request.Content = JsonContent.Create(body);
|
|
return request;
|
|
}
|
|
|
|
private static async Task DeleteRubroIfExistsAsync(int id)
|
|
{
|
|
await using var conn = new Microsoft.Data.SqlClient.SqlConnection(TestConnectionStrings.ApiTestDb);
|
|
await conn.OpenAsync();
|
|
await Dapper.SqlMapper.ExecuteAsync(conn, "ALTER TABLE dbo.Rubro SET (SYSTEM_VERSIONING = OFF)");
|
|
await Dapper.SqlMapper.ExecuteAsync(conn, "DELETE FROM dbo.Rubro_History WHERE Id = @Id", new { Id = id });
|
|
await Dapper.SqlMapper.ExecuteAsync(conn, """
|
|
WITH ToDelete AS (
|
|
SELECT Id FROM dbo.Rubro WHERE Id = @Id
|
|
UNION ALL
|
|
SELECT r.Id FROM dbo.Rubro r INNER JOIN ToDelete t ON r.ParentId = t.Id
|
|
)
|
|
DELETE r FROM dbo.Rubro r INNER JOIN ToDelete td ON r.Id = td.Id
|
|
""", new { Id = id });
|
|
await Dapper.SqlMapper.ExecuteAsync(conn,
|
|
"ALTER TABLE dbo.Rubro SET (SYSTEM_VERSIONING = ON (HISTORY_TABLE = dbo.Rubro_History, HISTORY_RETENTION_PERIOD = 10 YEARS))");
|
|
}
|
|
|
|
// ── ExceptionFilter unit tests (no DB, no HTTP) ───────────────────────────
|
|
|
|
private static ExceptionContext MakeExceptionContext(Exception exception)
|
|
{
|
|
var httpContext = new DefaultHttpContext();
|
|
var routeData = new Microsoft.AspNetCore.Routing.RouteData();
|
|
var actionDescriptor = new Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor();
|
|
var modelState = new Microsoft.AspNetCore.Mvc.ModelBinding.ModelStateDictionary();
|
|
var actionContext = new ActionContext(httpContext, routeData, actionDescriptor, modelState);
|
|
return new ExceptionContext(actionContext, new List<IFilterMetadata>())
|
|
{
|
|
Exception = exception
|
|
};
|
|
}
|
|
|
|
[Fact]
|
|
public void ExceptionFilter_MapsRubroPadreEsHojaConAvisos_To409()
|
|
{
|
|
var filter = new ExceptionFilter(NullLogger<ExceptionFilter>.Instance);
|
|
var ctx = MakeExceptionContext(new RubroPadreEsHojaConAvisosException(parentId: 1, cantidadAvisos: 3));
|
|
|
|
filter.OnException(ctx);
|
|
|
|
var result = Assert.IsType<ObjectResult>(ctx.Result);
|
|
Assert.Equal(StatusCodes.Status409Conflict, result.StatusCode);
|
|
var json = System.Text.Json.JsonSerializer.Serialize(result.Value);
|
|
Assert.Contains("rubro_padre_es_hoja_con_avisos", json);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExceptionFilter_MapsRubroEsRamaConHijosActivos_To409()
|
|
{
|
|
var filter = new ExceptionFilter(NullLogger<ExceptionFilter>.Instance);
|
|
var ctx = MakeExceptionContext(new RubroEsRamaConHijosActivosException(rubroId: 7, cantidadHijos: 2));
|
|
|
|
filter.OnException(ctx);
|
|
|
|
var result = Assert.IsType<ObjectResult>(ctx.Result);
|
|
Assert.Equal(StatusCodes.Status409Conflict, result.StatusCode);
|
|
var json = System.Text.Json.JsonSerializer.Serialize(result.Value);
|
|
Assert.Contains("rubro_es_rama_con_hijos_activos", json);
|
|
}
|
|
|
|
// ── Integration: GET /arbol includes tieneAvisos field (stub = false) ─────
|
|
|
|
[Fact]
|
|
public async Task GetTree_ResponseIncludesTieneAvisosField_FalseWithStub()
|
|
{
|
|
var token = await GetAdminTokenAsync();
|
|
|
|
// Create a root rubro to ensure tree is non-empty
|
|
using var createReq = BuildRequest(HttpMethod.Post, AdminEndpoint, new
|
|
{
|
|
nombre = "TieneAvisosCheck_CAT002",
|
|
parentId = (int?)null,
|
|
}, token);
|
|
var createResp = await _client.SendAsync(createReq);
|
|
Assert.Equal(HttpStatusCode.Created, createResp.StatusCode);
|
|
var created = await createResp.Content.ReadFromJsonAsync<JsonElement>();
|
|
var rootId = created.GetProperty("id").GetInt32();
|
|
|
|
try
|
|
{
|
|
using var req = BuildRequest(HttpMethod.Get, $"{ReadEndpoint}/tree", bearerToken: token);
|
|
var resp = await _client.SendAsync(req);
|
|
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
|
|
|
|
var json = await resp.Content.ReadFromJsonAsync<JsonElement>();
|
|
var ourNode = json.EnumerateArray()
|
|
.FirstOrDefault(n => n.GetProperty("id").GetInt32() == rootId);
|
|
|
|
Assert.True(ourNode.ValueKind != JsonValueKind.Undefined, "Our rubro must appear in tree");
|
|
Assert.True(ourNode.TryGetProperty("tieneAvisos", out var tieneAvisos),
|
|
"tieneAvisos must be present in every tree node (CAT-002 additive field)");
|
|
Assert.False(tieneAvisos.GetBoolean(),
|
|
"Stub (NullAvisoQueryRepository) must always return false");
|
|
}
|
|
finally
|
|
{
|
|
await DeleteRubroIfExistsAsync(rootId);
|
|
}
|
|
}
|
|
|
|
// ── Integration: POST child under leaf with avisos → 409 (DI override) ─────
|
|
|
|
/// <summary>
|
|
/// Verifies the 409 guard path end-to-end via a per-test DI override: injects a stub
|
|
/// <see cref="IAvisoQueryRepository"/> that reports the parent Rubro has 1 aviso,
|
|
/// so no real Aviso row needs to exist in the database.
|
|
///
|
|
/// Uses <see cref="TestWebAppFactory.CreateClientWithOverrides"/> — the pattern enabled
|
|
/// by fixing issue #36 (RSA singleton / per-test DI override).
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task CreateRubro_WhenParentHasAvisos_Returns409WithErrorCode()
|
|
{
|
|
// Arrange: get token from shared client (same DB)
|
|
var token = await GetAdminTokenAsync();
|
|
|
|
// Create a real parent Rubro to have a valid parentId
|
|
using var createParentReq = BuildRequest(HttpMethod.Post, AdminEndpoint, new
|
|
{
|
|
nombre = $"Parent_Hoja_CAT002_{Guid.NewGuid():N}"[..30],
|
|
parentId = (int?)null,
|
|
}, token);
|
|
var parentResp = await _client.SendAsync(createParentReq);
|
|
Assert.Equal(HttpStatusCode.Created, parentResp.StatusCode);
|
|
var parentJson = await parentResp.Content.ReadFromJsonAsync<JsonElement>();
|
|
var parentId = parentJson.GetProperty("id").GetInt32();
|
|
|
|
try
|
|
{
|
|
// Child client with stub that reports parentId has 1 aviso
|
|
using var client = _factory.CreateClientWithOverrides(services =>
|
|
{
|
|
services.RemoveAll<IAvisoQueryRepository>();
|
|
services.AddScoped<IAvisoQueryRepository>(_ =>
|
|
new AlwaysHasAvisosQueryRepository());
|
|
});
|
|
|
|
// Act: attempt to create a child under the "leaf with avisos" parent
|
|
var childReq = new System.Net.Http.HttpRequestMessage(HttpMethod.Post, AdminEndpoint);
|
|
childReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
|
|
childReq.Content = System.Net.Http.Json.JsonContent.Create(new
|
|
{
|
|
nombre = $"Child_CAT002_{Guid.NewGuid():N}"[..30],
|
|
parentId,
|
|
});
|
|
var resp = await client.SendAsync(childReq);
|
|
|
|
// Assert
|
|
Assert.Equal(HttpStatusCode.Conflict, resp.StatusCode);
|
|
var body = await resp.Content.ReadFromJsonAsync<JsonElement>();
|
|
Assert.Equal("rubro_padre_es_hoja_con_avisos", body.GetProperty("error").GetString());
|
|
}
|
|
finally
|
|
{
|
|
await DeleteRubroIfExistsAsync(parentId);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stub: always reports that a Rubro has 1 aviso (single query) and a non-empty batch dictionary.
|
|
/// Used by <see cref="RubrosReglaDeOroTests.CreateRubro_WhenParentHasAvisos_Returns409WithErrorCode"/>
|
|
/// via <see cref="TestWebAppFactory.CreateClientWithOverrides"/> to verify the 409 guard
|
|
/// without seeding real Aviso rows in the database (issue #36 DI override pattern).
|
|
/// </summary>
|
|
file sealed class AlwaysHasAvisosQueryRepository : IAvisoQueryRepository
|
|
{
|
|
public Task<int> CountAvisosEnRubroAsync(int rubroId, CancellationToken ct = default)
|
|
=> Task.FromResult(1);
|
|
|
|
public Task<IReadOnlyDictionary<int, int>> CountAvisosBatchAsync(
|
|
IReadOnlyCollection<int> rubroIds,
|
|
CancellationToken ct = default)
|
|
{
|
|
IReadOnlyDictionary<int, int> result = rubroIds.ToDictionary(id => id, _ => 1);
|
|
return Task.FromResult(result);
|
|
}
|
|
}
|
|
|