using System.Collections.Concurrent; using System.Net; using System.Text.Json; using Forge.Data; using Forge.Features.Webhooks; using Forge.Tests.Support; using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.DependencyInjection; namespace Forge.Tests; public class WebhookTests(ForgeHost host) : IClassFixture { private sealed record Received(string Event, string Delivery, string Signature, byte[] Body); /// A local HTTP endpoint standing in for a CI server. Answers with whatever status the test queues. private sealed class Receiver : IAsyncDisposable { private readonly WebApplication _app; public ConcurrentQueue Requests { get; } = new(); public ConcurrentQueue Statuses { get; } = new(); public string Url { get; } private Receiver(WebApplication app) { _app = app; Url = app.Urls.First().TrimEnd('/') + "/hook"; } public static async Task StartAsync() { var builder = WebApplication.CreateBuilder(["--urls=http://127.0.0.1:0", "--Logging:LogLevel:Default=Warning"]); var app = builder.Build(); Receiver? self = null; app.MapPost("/hook", async (HttpContext context) => { using var body = new MemoryStream(); await context.Request.Body.CopyToAsync(body); self!.Requests.Enqueue(new Received( context.Request.Headers["X-Forge-Event"].ToString(), context.Request.Headers["X-Forge-Delivery"].ToString(), context.Request.Headers["X-Forge-Signature"].ToString(), body.ToArray())); return Results.StatusCode(self.Statuses.TryDequeue(out var status) ? status : 200); }); await app.StartAsync(); self = new Receiver(app); return self; } public async Task NextAsync(int count = 1) { var deadline = DateTime.UtcNow.AddSeconds(30); while (Requests.Count < count) { Assert.True(DateTime.UtcNow < deadline, $"Expected {count} webhook request(s), got {Requests.Count}."); await Task.Delay(50); } return Requests.ElementAt(count - 1); } public async ValueTask DisposeAsync() { await _app.StopAsync(); await _app.DisposeAsync(); } } private Task> DeliveriesAsync(long webhookId) => host.WithScopeAsync(sp => sp.GetRequiredService().WebhookDeliveries .Where(d => d.WebhookId == webhookId).OrderBy(d => d.Id).ToListAsync()); private async Task> WaitForDeliveriesAsync(long webhookId, Func, bool> done) { var deadline = DateTime.UtcNow.AddSeconds(30); while (true) { var rows = await DeliveriesAsync(webhookId); if (done(rows)) { return rows; } Assert.True(DateTime.UtcNow < deadline, $"Deliveries did not reach the expected state; have {rows.Count}."); await Task.Delay(50); } } [Fact] public async Task Push_sends_a_signed_payload_and_failures_are_retried() { WebhookWorker.RetryDelays = [TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100)]; await using var receiver = await Receiver.StartAsync(); var user = await host.CreateUserAsync(); var repo = await host.CreateRepoAsync(user, "hooked", Visibility.Public); var token = await host.CreateTokenAsync(user, canWrite: true); using var client = await host.CreateSignedInClientAsync(); // Add the webhook through the UI. var added = await ForgeHost.PostFormAsync(client, "/jessie/hooked/settings/webhooks", "add-webhook", new() { ["Url"] = receiver.Url, ["Secret"] = "s3cret", }); Assert.Equal(HttpStatusCode.Redirect, added.StatusCode); var hook = await host.WithScopeAsync(sp => sp.GetRequiredService().Webhooks.SingleAsync(w => w.RepoId == repo.Id)); var detailUrl = $"/jessie/hooked/settings/webhooks/{hook.Id}"; // Test ping. var pinged = await ForgeHost.PostFormAsync(client, detailUrl, "hook-action", new() { ["Action"] = "ping" }); Assert.Contains("The ping was delivered", await ForgeHost.TextAsync(pinged)); var ping = await receiver.NextAsync(1); Assert.Equal("ping", ping.Event); Assert.Equal(WebhookSender.Sign("s3cret", ping.Body), ping.Signature); // A push: the first attempt fails with 500, the retry succeeds. receiver.Statuses.Enqueue(500); var work = host.NewDir("work"); var sha = await host.Git.CreateWorkRepoAsync(work); await host.Git.MustAsync(work, "push", host.GitUrl("jessie", "hooked", token), "main"); var retried = await receiver.NextAsync(3); Assert.Equal("push", retried.Event); Assert.Equal(WebhookSender.Sign("s3cret", retried.Body), retried.Signature); Assert.StartsWith("sha256=", retried.Signature); using var payload = JsonDocument.Parse(retried.Body); var root = payload.RootElement; Assert.Equal("refs/heads/main", root.GetProperty("ref").GetString()); Assert.Equal(Git.GitParsers.ZeroSha, root.GetProperty("before").GetString()); Assert.Equal(sha, root.GetProperty("after").GetString()); Assert.Equal("jessie/hooked", root.GetProperty("repository").GetProperty("full_name").GetString()); Assert.Equal("http://forge.test/jessie/hooked.git", root.GetProperty("repository").GetProperty("clone_url").GetString()); Assert.StartsWith("http://forge.test/jessie/hooked/", root.GetProperty("compare").GetString()); var commit = Assert.Single(root.GetProperty("commits").EnumerateArray()); Assert.Equal(sha, commit.GetProperty("id").GetString()); Assert.Equal("First commit", commit.GetProperty("message").GetString()); // Every attempt is a row: ping, failed push, successful retry. var rows = await WaitForDeliveriesAsync(hook.Id, r => r.Count(d => d.PushEventId != null && d.StatusCode != null) == 2); var pushRows = rows.Where(d => d.PushEventId != null).ToList(); Assert.Equal([(1, 500), (2, 200)], pushRows.Select(d => (d.Attempt, d.StatusCode!.Value))); Assert.Equal(retried.Delivery, pushRows[1].Id.ToString()); Assert.Null(rows[0].PushEventId); Assert.Equal(200, rows[0].StatusCode); // The history page lists them, and Redeliver sends the event again. var history = await client.GetStringAsync(detailUrl); Assert.Contains("refs/heads/main", history); var redelivered = await ForgeHost.PostFormAsync(client, detailUrl, "redeliver", new() { ["DeliveryId"] = pushRows[0].Id.ToString() }); Assert.Contains("Delivered again", await ForgeHost.TextAsync(redelivered)); var again = await receiver.NextAsync(4); Assert.Equal(retried.Body, again.Body); Assert.Equal(3, (await DeliveriesAsync(hook.Id)).Last().Attempt); // A disabled webhook receives nothing. await ForgeHost.PostFormAsync(client, detailUrl, "hook-action", new() { ["Action"] = "toggle" }); await File.WriteAllTextAsync(Path.Combine(work, "more.txt"), "more\n"); await host.Git.MustAsync(work, "add", "-A"); await host.Git.MustAsync(work, "commit", "-m", "More"); await host.Git.MustAsync(work, "push", host.GitUrl("jessie", "hooked", token), "main"); await Task.Delay(500); Assert.Equal(4, receiver.Requests.Count); // Deleting the repository removes its webhooks and deliveries with it. await host.WithScopeAsync(async sp => { var service = sp.GetRequiredService(); await service.DeleteAsync((await service.FindAsync("jessie", "hooked"))!); return 0; }); Assert.Empty(await DeliveriesAsync(hook.Id)); } [Fact] public async Task Unreachable_receiver_is_recorded_as_a_failed_delivery() { var user = await host.CreateUserAsync(); var repo = await host.CreateRepoAsync(user, "unreachable", Visibility.Public); var hook = await host.WithScopeAsync(async sp => { var db = sp.GetRequiredService(); // Port 9 (discard) on localhost: nothing listens there. var row = new Webhook { RepoId = repo.Id, Url = "http://127.0.0.1:9/hook", Secret = "x", CreatedAt = DateTime.UtcNow }; db.Webhooks.Add(row); await db.SaveChangesAsync(); return row; }); var ok = await host.Services.GetRequiredService().DeliverAsync(hook.Id, null, 1); Assert.False(ok); var delivery = Assert.Single(await DeliveriesAsync(hook.Id)); Assert.Null(delivery.StatusCode); Assert.False(string.IsNullOrEmpty(delivery.Error)); } }