cesnimda
255 lines
14 KiB
C#
255 lines
14 KiB
C#
using System.Text.Json;
|
|
using JobTrackerApi.Controllers;
|
|
using JobTrackerApi.Data;
|
|
using JobTrackerApi.Models;
|
|
using JobTrackerApi.Services;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Xunit;
|
|
|
|
namespace JobTrackerApi.Tests;
|
|
|
|
public sealed class OperationsControllerTests
|
|
{
|
|
[Fact]
|
|
public async Task Operation_api_lists_mutates_and_hides_other_owner_records()
|
|
{
|
|
await using var fixture = await Fixture.CreateAsync();
|
|
Guid ownId;
|
|
Guid otherId;
|
|
await using (var db = fixture.Context("user-1"))
|
|
ownId = (await fixture.Operations(db).CreateAsync(Request("own"), default)).Operation.Id;
|
|
await using (var db = fixture.Context("user-2"))
|
|
otherId = (await fixture.Operations(db).CreateAsync(Request("other"), default)).Operation.Id;
|
|
|
|
await using var ownerDb = fixture.Context("user-1");
|
|
var controller = fixture.OperationsController(ownerDb);
|
|
var listed = Assert.IsType<OkObjectResult>((await controller.List(cancellationToken: default)).Result);
|
|
var item = Assert.Single(Assert.IsAssignableFrom<IReadOnlyList<OperationDto>>(listed.Value));
|
|
Assert.Equal(ownId, item.Id);
|
|
Assert.IsType<NotFoundResult>((await controller.Get(otherId, default)).Result);
|
|
|
|
var cancelled = Assert.IsType<OkObjectResult>((await controller.Cancel(ownId, default)).Result);
|
|
Assert.Equal(ownId, Assert.IsType<OperationDto>(cancelled.Value).Id);
|
|
Assert.Equal(OperationStatuses.Cancelled, Assert.IsType<OperationDto>(cancelled.Value).Status);
|
|
Assert.IsType<ConflictObjectResult>((await controller.Cancel(ownId, default)).Result);
|
|
var retried = Assert.IsType<OkObjectResult>((await controller.Retry(ownId, default)).Result);
|
|
Assert.Equal(ownId, Assert.IsType<OperationDto>(retried.Value).Id);
|
|
Assert.Equal(OperationStatuses.Queued, Assert.IsType<OperationDto>(retried.Value).Status);
|
|
Assert.IsType<ConflictObjectResult>((await controller.Retry(ownId, default)).Result);
|
|
|
|
await using var persistedDb = fixture.Context("user-1");
|
|
var persisted = Assert.Single(await persistedDb.UserOperations.AsNoTracking().ToListAsync());
|
|
Assert.Equal(ownId, persisted.Id);
|
|
Assert.Equal(OperationStatuses.Queued, persisted.Status);
|
|
Assert.Null(persisted.StartedAtUtc);
|
|
Assert.Null(persisted.CompletedAtUtc);
|
|
Assert.Null(persisted.CancellationRequestedAtUtc);
|
|
|
|
var serialized = JsonSerializer.Serialize(item);
|
|
Assert.DoesNotContain("IdempotencyKey", serialized, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("LeaseToken", serialized, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("FailureMessage", serialized, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("ResultReference", serialized, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("Provider", serialized, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("Model", serialized, StringComparison.Ordinal);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Notification_api_is_owner_scoped_and_read_dismiss_are_idempotent()
|
|
{
|
|
await using var fixture = await Fixture.CreateAsync();
|
|
Guid notificationId;
|
|
await using (var db = fixture.Context("user-1"))
|
|
{
|
|
var operations = fixture.Operations(db);
|
|
var operation = await operations.CreateAsync(Request("notification"), default);
|
|
Assert.True(await operations.RequestCancellationAsync(operation.Operation.Id, default));
|
|
notificationId = (await db.UserNotifications.AsNoTracking().SingleAsync()).Id;
|
|
}
|
|
|
|
await using (var otherDb = fixture.Context("user-2"))
|
|
{
|
|
var other = fixture.NotificationsController(otherDb);
|
|
Assert.Empty(Assert.IsAssignableFrom<IReadOnlyList<NotificationDto>>(
|
|
Assert.IsType<OkObjectResult>((await other.List(cancellationToken: default)).Result).Value));
|
|
Assert.IsType<NotFoundResult>(await other.MarkRead(notificationId, default));
|
|
Assert.IsType<NotFoundResult>(await other.Dismiss(notificationId, default));
|
|
}
|
|
|
|
await using var ownerDb = fixture.Context("user-1");
|
|
var controller = fixture.NotificationsController(ownerDb);
|
|
var operationBefore = JsonSerializer.Serialize(await ownerDb.UserOperations.AsNoTracking().SingleAsync());
|
|
Assert.Single(Assert.IsAssignableFrom<IReadOnlyList<NotificationDto>>(
|
|
Assert.IsType<OkObjectResult>((await controller.List(cancellationToken: default)).Result).Value));
|
|
Assert.IsType<NoContentResult>(await controller.MarkRead(notificationId, default));
|
|
var read = await ownerDb.UserNotifications.AsNoTracking().SingleAsync();
|
|
Assert.Equal(notificationId, read.Id);
|
|
Assert.NotNull(read.ReadAtUtc);
|
|
Assert.IsType<NoContentResult>(await controller.MarkRead(notificationId, default));
|
|
Assert.Equal(read.ReadAtUtc, (await ownerDb.UserNotifications.AsNoTracking().SingleAsync()).ReadAtUtc);
|
|
Assert.IsType<NoContentResult>(await controller.Dismiss(notificationId, default));
|
|
var dismissed = await ownerDb.UserNotifications.AsNoTracking().SingleAsync();
|
|
Assert.NotNull(dismissed.DismissedAtUtc);
|
|
Assert.IsType<NoContentResult>(await controller.Dismiss(notificationId, default));
|
|
Assert.Empty(Assert.IsAssignableFrom<IReadOnlyList<NotificationDto>>(
|
|
Assert.IsType<OkObjectResult>((await controller.List(cancellationToken: default)).Result).Value));
|
|
await using var persistedDb = fixture.Context("user-1");
|
|
var persisted = await persistedDb.UserNotifications.AsNoTracking().SingleAsync();
|
|
Assert.Equal(notificationId, persisted.Id);
|
|
Assert.Equal(read.CreatedAtUtc, persisted.CreatedAtUtc);
|
|
Assert.Equal(read.ReadAtUtc, persisted.ReadAtUtc);
|
|
Assert.Equal(dismissed.DismissedAtUtc, persisted.DismissedAtUtc);
|
|
Assert.Equal(operationBefore, JsonSerializer.Serialize(await persistedDb.UserOperations.AsNoTracking().SingleAsync()));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Operation_and_notification_endpoints_validate_bounds_and_require_local_auth()
|
|
{
|
|
await using var fixture = await Fixture.CreateAsync();
|
|
await using var db = fixture.Context("user-1");
|
|
Assert.IsType<BadRequestObjectResult>((await fixture.OperationsController(db).List(0, default)).Result);
|
|
Assert.IsType<BadRequestObjectResult>((await fixture.NotificationsController(db).List(101, default)).Result);
|
|
|
|
foreach (var type in new[] { typeof(OperationsController), typeof(NotificationsController) })
|
|
{
|
|
var authorize = Assert.Single(type.GetCustomAttributes(typeof(AuthorizeAttribute), inherit: true).Cast<AuthorizeAttribute>());
|
|
Assert.Equal("local", authorize.AuthenticationSchemes);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Operation_and_notification_DTOs_preserve_all_UTC_instants_after_SQLite_roundtrips()
|
|
{
|
|
await using var fixture = await Fixture.CreateAsync();
|
|
var created = new DateTime(2026, 10, 16, 8, 9, 10, DateTimeKind.Utc).AddTicks(1234567);
|
|
var started = created.AddMinutes(1).AddTicks(2);
|
|
var completed = created.AddMinutes(2).AddTicks(3);
|
|
var deadline = created.AddMinutes(30).AddTicks(4);
|
|
var cancellationRequested = created.AddSeconds(90).AddTicks(5);
|
|
var noticeCreated = completed.AddTicks(6);
|
|
var noticeRead = noticeCreated.AddMinutes(1).AddTicks(7);
|
|
Guid operationId;
|
|
var notificationId = Guid.NewGuid();
|
|
await using (var seedDb = fixture.Context("user-1"))
|
|
{
|
|
var operation = (await fixture.Operations(seedDb).CreateAsync(Request("utc-transport"), default)).Operation;
|
|
operationId = operation.Id;
|
|
operation.Status = OperationStatuses.Failed;
|
|
operation.CreatedAtUtc = created;
|
|
operation.StartedAtUtc = started;
|
|
operation.CompletedAtUtc = completed;
|
|
operation.DeadlineAtUtc = deadline;
|
|
operation.CancellationRequestedAtUtc = cancellationRequested;
|
|
seedDb.UserNotifications.Add(new UserNotification
|
|
{
|
|
Id = notificationId, OwnerUserId = "user-1", OperationId = operationId,
|
|
Kind = "operation_failed", Title = "Recorded operation", Message = "Stored UTC contract",
|
|
CreatedAtUtc = noticeCreated, ReadAtUtc = noticeRead,
|
|
});
|
|
await seedDb.SaveChangesAsync();
|
|
}
|
|
|
|
await using var readDb = fixture.Context("user-1");
|
|
var storedOperation = await readDb.UserOperations.AsNoTracking().SingleAsync();
|
|
var storedNotification = await readDb.UserNotifications.AsNoTracking().SingleAsync();
|
|
Assert.All(new[] { storedOperation.CreatedAtUtc, storedOperation.StartedAtUtc!.Value,
|
|
storedOperation.CompletedAtUtc!.Value, storedOperation.DeadlineAtUtc!.Value,
|
|
storedOperation.CancellationRequestedAtUtc!.Value, storedNotification.CreatedAtUtc,
|
|
storedNotification.ReadAtUtc!.Value }, value => Assert.Equal(DateTimeKind.Unspecified, value.Kind));
|
|
var operationBefore = JsonSerializer.Serialize(storedOperation);
|
|
var notificationBefore = JsonSerializer.Serialize(storedNotification);
|
|
|
|
var operationController = fixture.OperationsController(readDb);
|
|
var retrieved = Assert.IsType<OperationDto>(Assert.IsType<OkObjectResult>(
|
|
(await operationController.Get(operationId, default)).Result).Value);
|
|
var listed = Assert.Single(Assert.IsAssignableFrom<IReadOnlyList<OperationDto>>(
|
|
Assert.IsType<OkObjectResult>((await operationController.List(cancellationToken: default)).Result).Value));
|
|
var notification = Assert.Single(Assert.IsAssignableFrom<IReadOnlyList<NotificationDto>>(
|
|
Assert.IsType<OkObjectResult>((await fixture.NotificationsController(readDb).List(cancellationToken: default)).Result).Value));
|
|
Assert.Equal(operationId, retrieved.Id);
|
|
Assert.Equal(retrieved, listed);
|
|
Assert.Equal(notificationId, notification.Id);
|
|
Assert.Equal(operationId, notification.OperationId);
|
|
|
|
// Web JSON serialization of controller DTOs; this fixture does not host HTTP.
|
|
var options = new JsonSerializerOptions(JsonSerializerDefaults.Web);
|
|
foreach (var operation in new[] { retrieved, listed })
|
|
{
|
|
var json = JsonSerializer.SerializeToElement(operation, options);
|
|
Assert.Equal(new[] { "id", "taskType", "status", "subjectType", "createdAtUtc", "startedAtUtc", "completedAtUtc",
|
|
"deadlineAtUtc", "cancellationRequestedAtUtc", "progressStage", "progressPercent", "failureCategory", "canCancel", "canRetry" }.Order(),
|
|
json.EnumerateObject().Select(property => property.Name).Order());
|
|
AssertUtcJson(json, "createdAtUtc", created);
|
|
AssertUtcJson(json, "startedAtUtc", started);
|
|
AssertUtcJson(json, "completedAtUtc", completed);
|
|
AssertUtcJson(json, "deadlineAtUtc", deadline);
|
|
AssertUtcJson(json, "cancellationRequestedAtUtc", cancellationRequested);
|
|
}
|
|
var noticeJson = JsonSerializer.SerializeToElement(notification, options);
|
|
Assert.Equal(new[] { "id", "operationId", "kind", "title", "message", "linkPath", "createdAtUtc", "readAtUtc" }.Order(),
|
|
noticeJson.EnumerateObject().Select(property => property.Name).Order());
|
|
AssertUtcJson(noticeJson, "createdAtUtc", noticeCreated);
|
|
AssertUtcJson(noticeJson, "readAtUtc", noticeRead);
|
|
|
|
await using var verifyDb = fixture.Context("user-1");
|
|
Assert.Equal(operationBefore, JsonSerializer.Serialize(await verifyDb.UserOperations.AsNoTracking().SingleAsync()));
|
|
Assert.Equal(notificationBefore, JsonSerializer.Serialize(await verifyDb.UserNotifications.AsNoTracking().SingleAsync()));
|
|
}
|
|
|
|
private static void AssertUtcJson(JsonElement json, string property, DateTime expected)
|
|
{
|
|
Assert.EndsWith("Z", json.GetProperty(property).GetString());
|
|
var instant = json.GetProperty(property).GetDateTimeOffset();
|
|
Assert.Equal(TimeSpan.Zero, instant.Offset);
|
|
Assert.Equal(expected.Ticks, instant.UtcDateTime.Ticks);
|
|
}
|
|
|
|
private static CreateUserOperation Request(string key) => new("synthetic-test", key, "authorized", "local-only", "job", "42");
|
|
|
|
private sealed class CurrentUser(string? userId) : ICurrentUserService
|
|
{
|
|
public string? UserId { get; } = userId;
|
|
}
|
|
|
|
private sealed class Fixture : IAsyncDisposable
|
|
{
|
|
private readonly string _root;
|
|
private readonly string _connectionString;
|
|
|
|
private Fixture(string root)
|
|
{
|
|
_root = root;
|
|
_connectionString = $"Data Source={Path.Combine(root, "api.db")};Default Timeout=5;Pooling=False";
|
|
}
|
|
|
|
public static async Task<Fixture> CreateAsync()
|
|
{
|
|
var root = Path.Combine(Path.GetTempPath(), $"jobtracker-operation-api-{Guid.NewGuid():N}");
|
|
Directory.CreateDirectory(root);
|
|
var fixture = new Fixture(root);
|
|
await using var db = fixture.Context(null);
|
|
await db.Database.EnsureCreatedAsync();
|
|
return fixture;
|
|
}
|
|
|
|
public JobTrackerContext Context(string? owner)
|
|
{
|
|
var options = new DbContextOptionsBuilder<JobTrackerContext>().UseSqlite(_connectionString).Options;
|
|
return new JobTrackerContext(options, new CurrentUser(owner));
|
|
}
|
|
|
|
public UserOperationStore Operations(JobTrackerContext db) => new(db, TimeProvider.System);
|
|
public UserNotificationStore Notifications(JobTrackerContext db) => new(db, TimeProvider.System);
|
|
public OperationsController OperationsController(JobTrackerContext db) => new(Operations(db));
|
|
public NotificationsController NotificationsController(JobTrackerContext db) => new(Notifications(db));
|
|
|
|
public ValueTask DisposeAsync()
|
|
{
|
|
if (Directory.Exists(_root)) Directory.Delete(_root, true);
|
|
return ValueTask.CompletedTask;
|
|
}
|
|
}
|
|
}
|