126 lines
6.7 KiB
C#
126 lines
6.7 KiB
C#
using System.Net;
|
|
using System.Text.Json.Nodes;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using MoShiro.Backend.Application;
|
|
using MoShiro.Protocol;
|
|
|
|
namespace MoShiro.Backend.Tests;
|
|
|
|
public sealed class BackendUpdateTests : IAsyncLifetime
|
|
{
|
|
private const string Digest = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
|
|
private readonly BackendFixture _backend = new();
|
|
|
|
public async ValueTask InitializeAsync()
|
|
{
|
|
await _backend.InitializeAsync();
|
|
BackendOptions options = _backend.Services.GetRequiredService<BackendOptions>();
|
|
options.UpdateChannel = "dev";
|
|
options.UpdateMode = "restart";
|
|
}
|
|
|
|
public ValueTask DisposeAsync() => _backend.DisposeAsync();
|
|
|
|
[Theory]
|
|
[InlineData("moshiro-dev", "dev")]
|
|
[InlineData("registry.example/team/moshiro-dev", "dev")]
|
|
[InlineData("moshiro", "release")]
|
|
[InlineData("registry.example/team/moshiro", "release")]
|
|
public void AutoChannel_FollowsTheConfiguredImageRepository(string imageNamespace, string expected)
|
|
{
|
|
Assert.Equal(expected, BackendUpdates.ChannelOf(new BackendOptions { UpdateChannel = "auto", ImageNamespace = imageNamespace }));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("v0.4.1-dev.12-044ce0c", true)]
|
|
[InlineData("dev-725fe17a7de8", true)]
|
|
[InlineData("main-725fe17a7d", true)]
|
|
[InlineData("v0.4.0", false)]
|
|
[InlineData("v0.4.1-rc.1", false)]
|
|
[InlineData(null, false)]
|
|
public void IsDevTag_RecognisesDevelopmentBuilds(string? tag, bool expected)
|
|
{
|
|
Assert.Equal(expected, BackendUpdates.IsDevTag(tag));
|
|
}
|
|
|
|
private async Task<HttpResponseMessage> PublishAsync(long seq, string channel = "dev")
|
|
{
|
|
string manifest = $$"""{"component":"backend","channel":"{{channel}}","image":"registry.example/moshiro-{{channel}}/moshiro-backend","digest":"{{Digest}}","tag":"{{channel}}-{{seq}}","version":"0.1.1","seq":{{seq}}}""";
|
|
return await _backend.Anonymous.PostAsync("/api/release/offer", BackendFixture.Json(new JsonObject { ["manifest"] = manifest, ["signature"] = TestReleaseKey.Sign(manifest) }));
|
|
}
|
|
|
|
private Task<JsonNode> ViewAsync() => _backend.GetJsonAsync(_backend.Admin, "/api/admin/backend/update");
|
|
|
|
[Fact]
|
|
public async Task Webhook_PreservesChannels_AndNeverConfirmsAnUpdateByItself()
|
|
{
|
|
using HttpResponseMessage dev = await PublishAsync(1);
|
|
using HttpResponseMessage release = await PublishAsync(1, "release");
|
|
Assert.Equal(HttpStatusCode.Created, dev.StatusCode);
|
|
Assert.Equal(HttpStatusCode.Created, release.StatusCode);
|
|
JsonNode view = await ViewAsync();
|
|
Assert.Equal("dev", view["channel"]!.GetValue<string>());
|
|
Assert.Equal("dev-1", view["available"]!["tag"]!.GetValue<string>());
|
|
Assert.Equal("available", view["state"]!.GetValue<string>());
|
|
Assert.Equal(0, _backend.Restarts.Count); // 发布只提示，不会自己重启
|
|
ReleaseOffer? stable = await _backend.Services.GetRequiredService<ReleaseService>().GetBackendAsync("release", default);
|
|
Assert.Equal("release-1", stable!.Tag);
|
|
using HttpResponseMessage replay = await PublishAsync(1);
|
|
Assert.Equal(HttpStatusCode.Conflict, replay.StatusCode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Confirm_BacksUpTheDatabase_ThenExits_AndRejectsASupersededSequence()
|
|
{
|
|
using HttpResponseMessage first = await PublishAsync(10);
|
|
Assert.Equal(HttpStatusCode.Created, first.StatusCode);
|
|
using HttpResponseMessage wrong = await _backend.Admin.PostAsync("/api/admin/backend/update", BackendFixture.Json(new JsonObject { ["seq"] = 9 }));
|
|
Assert.Equal(HttpStatusCode.PreconditionFailed, wrong.StatusCode);
|
|
Assert.Equal(0, _backend.Restarts.Count);
|
|
|
|
using HttpResponseMessage accepted = await _backend.Admin.PostAsync("/api/admin/backend/update", BackendFixture.Json(new JsonObject { ["seq"] = 10 }));
|
|
Assert.Equal(HttpStatusCode.NoContent, accepted.StatusCode);
|
|
Assert.Equal(1, _backend.Restarts.Count);
|
|
Assert.Equal("applying", (await ViewAsync())["state"]!.GetValue<string>());
|
|
string backup = Assert.Single(Directory.GetFiles(Path.Combine(_backend.DataDirectory, "backups"), "pre-update-*.db"));
|
|
Assert.True(new FileInfo(backup).Length > 0);
|
|
|
|
using HttpResponseMessage second = await PublishAsync(11);
|
|
Assert.Equal(HttpStatusCode.Created, second.StatusCode);
|
|
using HttpResponseMessage stale = await _backend.Admin.PostAsync("/api/admin/backend/update", BackendFixture.Json(new JsonObject { ["seq"] = 10 }));
|
|
Assert.Equal(HttpStatusCode.PreconditionFailed, stale.StatusCode);
|
|
Assert.Equal(1, _backend.Restarts.Count); // 新清单没有被悄悄当成已确认
|
|
using HttpResponseMessage newConfirmation = await _backend.Admin.PostAsync("/api/admin/backend/update", BackendFixture.Json(new JsonObject { ["seq"] = 11 }));
|
|
Assert.Equal(HttpStatusCode.NoContent, newConfirmation.StatusCode);
|
|
Assert.Equal(2, _backend.Restarts.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Confirm_IsRefusedWithoutRestartMode()
|
|
{
|
|
_backend.Services.GetRequiredService<BackendOptions>().UpdateMode = null;
|
|
using HttpResponseMessage published = await PublishAsync(30);
|
|
Assert.Equal(HttpStatusCode.Created, published.StatusCode);
|
|
Assert.False((await ViewAsync())["enabled"]!.GetValue<bool>());
|
|
using HttpResponseMessage refused = await _backend.Admin.PostAsync("/api/admin/backend/update", BackendFixture.Json(new JsonObject { ["seq"] = 30 }));
|
|
Assert.Equal(HttpStatusCode.PreconditionFailed, refused.StatusCode);
|
|
Assert.Equal(0, _backend.Restarts.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Live_PushesCurrentChannel_AndAnonymousCannotReadOrConfirm()
|
|
{
|
|
using HttpResponseMessage denied = await _backend.Anonymous.GetAsync("/api/admin/backend/update");
|
|
Assert.Equal(HttpStatusCode.Unauthorized, denied.StatusCode);
|
|
using HttpResponseMessage cannotConfirm = await _backend.Anonymous.PostAsync("/api/admin/backend/update", BackendFixture.Json(new JsonObject { ["seq"] = 1 }));
|
|
Assert.Equal(HttpStatusCode.Unauthorized, cannotConfirm.StatusCode);
|
|
await using SseClient live = await SseClient.ConnectAsync(_backend.Admin, "/api/admin/backend/update/live");
|
|
await live.WaitForAsync(e => e.Name == "backend_update");
|
|
using HttpResponseMessage release = await PublishAsync(20);
|
|
Assert.Equal(HttpStatusCode.Created, release.StatusCode);
|
|
SseEvent updated = await live.WaitForAsync(e => e.Name == "backend_update" && e.Data?["available"]?["seq"]?.GetValue<long>() == 20);
|
|
Assert.Equal("dev", updated.Data!["channel"]!.GetValue<string>());
|
|
Assert.Equal(0, _backend.Restarts.Count);
|
|
}
|
|
}
|