yavsc/src/test/Yavsc.Api.Tests/PodcastScheduleTests.cs
Paul Schneider b157dce4e4
Add OBS podcast ingestion and account withdrawal privacy controls
Support scoped RTMPS publishing through MediaMTX, authenticated replay, resource accounting and PostIt activation/revocation. Close withdrawn accounts, erase managed files and purge eligible payment residues after one year. Include migrations, documentation and regression tests.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-08 07:43:15 +00:00

174 lines
9 KiB
C#

using System.Net;
using System.Net.Http.Json;
using System.Text.Json;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Yavsc.Abstract.Streaming;
using Yavsc.Api.Services;
using Yavsc.Api.Test.Fixtures;
using Yavsc.Models;
namespace Yavsc.Api.Test;
[Collection("Yavsc Api")]
public sealed class PodcastScheduleTests(ApiWebServerFixture fixture) : IClassFixture<ApiWebServerFixture>
{
private static CancellationToken Ct => TestContext.Current.CancellationToken;
private HttpClient Client(string? user)
{
var client = new HttpClient(new HttpClientHandler
{
ServerCertificateCustomValidationCallback = (_, _, _, _) => true
}) { BaseAddress = new Uri(fixture.BaseAddress) };
if (user != null) client.DefaultRequestHeaders.Authorization = new("Bearer", Yavsc.Tests.Shared.TestTokenIssuer.Issue(user, "api"));
return client;
}
private async Task<string> OwnerAsync()
{
var id = "schedule-" + Guid.NewGuid().ToString("N");
using var scope = fixture.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
db.Users.Add(new ApplicationUser { Id = id, UserName = id, Email = id + "@example.test" });
await db.SaveChangesAsync(Ct);
return id;
}
private static PreparePodcastRequest Request(string? announcement = null) => new()
{
Title = "Concert prepare", ScheduledStartAt = DateTimeOffset.UtcNow.AddDays(7),
PlannedDurationMinutes = 90, PublicAnnouncement = announcement
};
private async Task<PodcastResponse> PrepareAsync(HttpClient client, PreparePodcastRequest request)
{
using var response = await client.PostAsJsonAsync("/api/v1/podcasts/planned", request, Ct);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.NotNull(response.Headers.Location);
return (await response.Content.ReadFromJsonAsync<PodcastResponse>(Ct))!;
}
[Fact]
public async Task Plans_are_persisted_in_LiveFlow_private_editable_and_cancelable()
{
var ownerId = await OwnerAsync();
using var owner = Client(ownerId);
using var other = Client("other");
using var anonymous = Client(null);
var request = Request();
var plan = await PrepareAsync(owner, request);
var path = $"/api/v1/podcasts/{plan.Id}";
Assert.Equal(PodcastState.Planned, plan.State);
Assert.NotNull(plan.FlowId);
Assert.Equal(request.ScheduledStartAt, plan.ScheduledStartAt);
Assert.Equal(90, plan.PlannedDurationMinutes);
using var obsStatus = await owner.GetAsync(path + "/obs", Ct);
Assert.Equal(HttpStatusCode.OK, obsStatus.StatusCode);
Assert.True(obsStatus.Headers.CacheControl?.NoStore);
var status = await obsStatus.Content.ReadFromJsonAsync<PodcastObsStatus>(Ct);
Assert.False(status!.Enabled);
using var obsDenied = await other.GetAsync(path + "/obs", Ct);
Assert.Equal(HttpStatusCode.Forbidden, obsDenied.StatusCode);
using var obsAnonymous = await anonymous.GetAsync(path + "/obs", Ct);
Assert.Equal(HttpStatusCode.Unauthorized, obsAnonymous.StatusCode);
using (var scope = fixture.Services.CreateScope())
{
var flow = await scope.ServiceProvider.GetRequiredService<ApplicationDbContext>().LiveFlow
.AsNoTracking().SingleAsync(f => f.Id == plan.FlowId, Ct);
Assert.Equal(plan.Id, flow.PodcastId);
var reloaded = await scope.ServiceProvider.GetRequiredService<IPodcastScheduleService>().GetAsync(plan.Id, ownerId, Ct);
Assert.Equal(plan, reloaded.Podcast);
}
var list = await other.GetFromJsonAsync<List<PodcastResponse>>("/api/v1/podcasts", Ct);
Assert.DoesNotContain(list!, p => p.Id == plan.Id);
using var missing = await other.GetAsync(path, Ct);
Assert.Equal(HttpStatusCode.NotFound, missing.StatusCode);
using var denied = await other.PutAsJsonAsync(path + "/planned", Request("changed"), Ct);
Assert.Equal(HttpStatusCode.Forbidden, denied.StatusCode);
using var startDenied = await other.PostAsync(path + "/start", null, Ct);
Assert.Equal(HttpStatusCode.Forbidden, startDenied.StatusCode);
using var updated = await owner.PutAsJsonAsync(path + "/planned", request with { Title = "Nouveau titre" }, Ct);
Assert.Equal(HttpStatusCode.OK, updated.StatusCode);
Assert.Equal("Nouveau titre", (await owner.GetFromJsonAsync<PodcastManifestResponse>(path, Ct))?.Podcast.Title);
using var streamDenied = await anonymous.GetAsync(path + "/index.m3u8", Ct);
Assert.Equal(HttpStatusCode.Unauthorized, streamDenied.StatusCode);
using var cancelled = await owner.DeleteAsync(path, Ct);
Assert.Equal(HttpStatusCode.NoContent, cancelled.StatusCode);
using var cancelledGet = await owner.GetAsync(path, Ct);
Assert.Equal(HttpStatusCode.NotFound, cancelledGet.StatusCode);
}
[Fact]
public async Task Public_announcements_have_only_presentation_data_and_can_be_unpublished()
{
using var owner = Client(await OwnerAsync());
using var anonymous = Client(null);
var privatePlan = await PrepareAsync(owner, Request());
var publicPlan = await PrepareAsync(owner, Request("Venez au concert"));
using var response = await anonymous.GetAsync("/api/v1/podcasts/announcements", Ct);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var items = await response.Content.ReadFromJsonAsync<List<PodcastAnnouncementResponse>>(Ct);
Assert.Contains(items!, p => p.Id == publicPlan.Id && p.Announcement == "Venez au concert");
Assert.DoesNotContain(items!, p => p.Id == privatePlan.Id);
using var json = JsonDocument.Parse(await response.Content.ReadAsStringAsync(Ct));
Assert.All(json.RootElement.EnumerateArray(), item =>
Assert.Equal(new[] { "announcement", "id", "ownerName", "plannedDurationMinutes", "scheduledStartAt", "title" },
item.EnumerateObject().Select(p => p.Name).Order().ToArray()));
using var update = await owner.PutAsJsonAsync($"/api/v1/podcasts/{publicPlan.Id}/planned", Request(), Ct);
Assert.Equal(HttpStatusCode.OK, update.StatusCode);
Assert.DoesNotContain((await anonymous.GetFromJsonAsync<List<PodcastAnnouncementResponse>>("/api/v1/podcasts/announcements", Ct))!,
p => p.Id == publicPlan.Id);
using (await owner.DeleteAsync($"/api/v1/podcasts/{privatePlan.Id}", Ct)) { }
using (await owner.DeleteAsync($"/api/v1/podcasts/{publicPlan.Id}", Ct)) { }
}
[Fact]
public async Task Manual_start_retains_id_and_schedule_is_idempotent_and_prevents_later_edits()
{
using var owner = Client(await OwnerAsync());
var plan = await PrepareAsync(owner, Request("Annonce"));
var path = $"/api/v1/podcasts/{plan.Id}";
try
{
var responses = await Task.WhenAll(owner.PostAsync(path + "/start", null, Ct), owner.PostAsync(path + "/start", null, Ct));
foreach (var response in responses)
{
using (response)
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var live = await response.Content.ReadFromJsonAsync<PodcastResponse>(Ct);
Assert.Equal(plan.Id, live?.Id);
Assert.Equal(PodcastState.Live, live?.State);
Assert.Equal(plan.FlowId, live?.FlowId);
Assert.Equal(plan.ScheduledStartAt, live?.ScheduledStartAt);
}
}
using var edit = await owner.PutAsJsonAsync(path + "/planned", Request(), Ct);
Assert.Equal(HttpStatusCode.Conflict, edit.StatusCode);
using var completed = await owner.PostAsync(path + "/complete", null, Ct);
Assert.Equal(plan.FlowId, (await completed.Content.ReadFromJsonAsync<PodcastResponse>(Ct))?.FlowId);
using var restart = await owner.PostAsync(path + "/start", null, Ct);
Assert.Equal(HttpStatusCode.Conflict, restart.StatusCode);
}
finally
{
using (await owner.PostAsync(path + "/complete", null, Ct)) { }
using (await owner.DeleteAsync(path, Ct)) { }
}
}
[Theory]
[InlineData(0, "Concert")]
[InlineData(-1, "Concert")]
[InlineData(60, " ")]
public async Task Invalid_plans_are_rejected_without_creating_a_flow(int minutes, string title)
{
var id = await OwnerAsync();
using var owner = Client(id);
using var response = await owner.PostAsJsonAsync("/api/v1/podcasts/planned",
Request() with { PlannedDurationMinutes = minutes, Title = title }, Ct);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
using var scope = fixture.Services.CreateScope();
Assert.False(await scope.ServiceProvider.GetRequiredService<ApplicationDbContext>().LiveFlow.AnyAsync(f => f.OwnerId == id, Ct));
}
}