eu07/StarterNG
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/StarterNG.git synced 2026-10-16 23:49:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

Drop the update check - Steam updates the starter

Browse Source 
The daily GitHub check, the top-bar button, the stable/staging channel and
"check now" go, with their settings and texts.
This commit is contained in:
maj00r
2026-10-04 18:46:38 +02:00
parent 6cedf8b6f6
commit 52ad490fb7
18 changed files with 0 additions and 775 deletions
Download Patch File Download Diff File Expand all files Collapse all files

291
StarterNG.Tests/UpdateCheckTests.cs
View File

@@ -1,291 +0,0 @@
using System.Net;
using System.Net.Http;
using StarterNG.Application;
using StarterNG.Application.Abstractions;
using StarterNG.Domain.Settings;
using StarterNG.Infrastructure.Adapters;
using StarterNG.Tests.Fakes;
namespace StarterNG.Tests;
public class UpdateCheckTests
{
private const string Page = "https://github.com/MaSzyna-EU07/StarterNG/releases/tag/v1.4.107";
private const string StagingPage = "https://github.com/MaSzyna-EU07/StarterNG/releases/tag/staging";
private const string RecordPath = "/home/user/.config/starter/updatecheck.txt";
private const string RunningCommit = "9d981cb0932c372074eaba25d5c917acbacc25d8";
private const string OtherCommit = "f7219cf7055670ad0f39fc18e0640358b8fff8f7";
private static readonly Version Current = new(1, 4, 100, 0);
[Theory]
[InlineData("v1.4.107")]
[InlineData("v1.5.0")]
[InlineData("1.4.101")]
public async Task A_higher_release_is_an_update(string tag)
{
var check = new Rig(new StubFeed(Stable(tag))).Check;
Assert.Equal(UpdateCheckOutcome.UpdateAvailable, await check.CheckNowAsync(UpdateChannel.Stable));
Assert.Equal(UpdateCheck.ParseTag(tag)!.ToString(), check.Available!.Label);
Assert.Equal(Page, check.Available.PageUrl);
}
[Theory]
[InlineData("v1.4.100")]
[InlineData("v1.4.99")]
[InlineData("v1.3.500")]
[InlineData("staging")]
[InlineData("v1.5.0-rc1")]
public async Task The_same_an_older_or_an_unversioned_release_is_not(string tag)
{
var check = new Rig(new StubFeed(Stable(tag))).Check;
Assert.Equal(UpdateCheckOutcome.UpToDate, await check.CheckNowAsync(UpdateChannel.Stable));
Assert.Null(check.Available);
}
[Fact]
public async Task No_answer_is_reported_as_such_and_not_remembered()
{
var rig = new Rig(new StubFeed(lookup: ReleaseLookup.NoAnswer));
Assert.Equal(UpdateCheckOutcome.NoAnswer, await rig.Check.CheckNowAsync(UpdateChannel.Stable));
Assert.False(rig.Files.FileExists(RecordPath));
}
[Fact]
public async Task The_daily_check_asks_once_a_day_and_keeps_showing_the_answer()
{
var feed = new StubFeed(Stable("v1.4.107"));
var rig = new Rig(feed);
await rig.Check.CheckDailyAsync();
// A second start the same day: no request, the update still shown.
var again = rig.Restart();
await again.CheckDailyAsync();
Assert.Equal(1, feed.Calls);
Assert.Equal("1.4.107", again.Available!.Label);
}
[Fact]
public async Task The_next_day_it_asks_again()
{
var feed = new StubFeed(Stable("v1.4.107"));
var rig = new Rig(feed);
await rig.Check.CheckDailyAsync();
rig.Clock.Now = rig.Clock.Now.AddDays(1);
await rig.Restart().CheckDailyAsync();
Assert.Equal(2, feed.Calls);
}
[Fact]
public async Task A_remembered_release_already_installed_is_not_offered()
{
var rig = new Rig(new StubFeed(Stable("v1.4.107")));
await rig.Check.CheckDailyAsync();
var upgraded = rig.Restart(current: new Version(1, 4, 107, 0));
await upgraded.CheckDailyAsync();
Assert.Null(upgraded.Available);
}
[Fact]
public async Task Switching_the_channel_asks_again_the_same_day()
{
var feed = new StubFeed(Stable("v1.4.107"));
var rig = new Rig(feed);
await rig.Check.CheckDailyAsync();
rig.Settings.UpdateChannel = UpdateChannel.Staging;
await rig.Restart().CheckDailyAsync();
Assert.Equal(2, feed.Calls);
Assert.Equal(UpdateChannel.Staging, feed.LastChannel);
}
[Fact]
public async Task Switched_off_the_daily_check_does_not_ask_but_the_button_does()
{
var feed = new StubFeed(Stable("v9.0.0"));
var rig = new Rig(feed);
rig.Settings.CheckForUpdates = false;
await rig.Check.CheckDailyAsync();
Assert.Equal(0, feed.Calls);
Assert.Equal(UpdateCheckOutcome.UpdateAvailable, await rig.Check.CheckNowAsync(UpdateChannel.Stable));
}
[Fact]
public async Task A_staging_build_from_another_commit_is_offered()
{
var check = new Rig(new StubFeed(Staging(OtherCommit))).Check;
Assert.Equal(UpdateCheckOutcome.UpdateAvailable, await check.CheckNowAsync(UpdateChannel.Staging));
Assert.Equal("staging f7219cf", check.Available!.Label);
Assert.Equal(StagingPage, check.Available.PageUrl);
}
[Fact]
public async Task The_staging_build_already_running_is_not()
{
var check = new Rig(new StubFeed(Staging(RunningCommit))).Check;
Assert.Equal(UpdateCheckOutcome.UpToDate, await check.CheckNowAsync(UpdateChannel.Staging));
}
[Fact]
public async Task Finding_an_update_tells_the_top_bar()
{
var check = new Rig(new StubFeed(Stable("v1.4.107"))).Check;
int changes = 0;
check.Changed += () => changes++;
await check.CheckNowAsync(UpdateChannel.Stable);
await check.CheckNowAsync(UpdateChannel.Stable);
Assert.Equal(1, changes);
}
[Fact]
public void The_commit_is_read_from_the_informational_version()
{
Assert.Equal(RunningCommit, UpdateCheck.CommitOf("1.4.113+" + RunningCommit));
Assert.Null(UpdateCheck.CommitOf("1.4.113"));
Assert.Null(UpdateCheck.CommitOf(null));
}
[Fact]
public void The_four_part_assembly_version_matches_a_three_part_tag()
{
Assert.Equal(new Version(1, 4, 0), UpdateCheck.ParseTag("v1.4"));
Assert.Equal(new Version(1, 4, 107), UpdateCheck.ParseTag("V1.4.107"));
}
[Fact]
public async Task The_feed_reads_a_stable_release()
{
var feed = Feed(HttpStatusCode.OK,
$$"""{"tag_name":"v1.4.107","html_url":"{{Page}}","target_commitish":"{{OtherCommit}}","prerelease":false}""");
var lookup = await feed.LatestAsync(UpdateChannel.Stable);
Assert.True(lookup.Answered);
Assert.Equal(new ReleaseInfo("v1.4.107", Page, OtherCommit), lookup.Release);
}
[Fact]
public async Task The_stable_feed_skips_a_pre_release_and_the_staging_feed_takes_it()
{
string json = $$"""{"tag_name":"staging","html_url":"{{StagingPage}}","target_commitish":"{{OtherCommit}}","prerelease":true}""";
Assert.Null((await Feed(HttpStatusCode.OK, json).LatestAsync(UpdateChannel.Stable)).Release);
Assert.Equal(OtherCommit, (await Feed(HttpStatusCode.OK, json).LatestAsync(UpdateChannel.Staging)).Release!.Commit);
}
[Fact]
public async Task The_staging_feed_asks_for_the_staging_tag()
{
string? asked = null;
var feed = new GitHubReleaseFeed(new TestInstallation().Log, Current, new StubHandler(request =>
{
asked = request.RequestUri!.AbsolutePath;
return Respond(HttpStatusCode.NotFound, "{}");
}));
await feed.LatestAsync(UpdateChannel.Staging);
Assert.EndsWith("/releases/tags/staging", asked);
}
[Fact]
public async Task Nothing_released_yet_is_an_answer()
{
var lookup = await Feed(HttpStatusCode.NotFound, """{"message":"Not Found"}""").LatestAsync(UpdateChannel.Stable);
Assert.True(lookup.Answered);
Assert.Null(lookup.Release);
}
[Fact]
public async Task No_network_is_no_answer_and_nothing_in_the_log()
{
var log = new TestInstallation().Log;
var feed = new GitHubReleaseFeed(log, Current, new StubHandler(_ => throw new HttpRequestException("offline")));
Assert.False((await feed.LatestAsync(UpdateChannel.Stable)).Answered);
Assert.Equal("", log.Text);
}
[Fact]
public async Task A_broken_answer_is_logged()
{
var log = new TestInstallation().Log;
var feed = new GitHubReleaseFeed(log, Current, new StubHandler(_ => Respond(HttpStatusCode.OK, "<html>")));
Assert.False((await feed.LatestAsync(UpdateChannel.Stable)).Answered);
Assert.Contains("update check", log.Text);
}
private static ReleaseLookup Stable(string tag) => ReleaseLookup.Found(new ReleaseInfo(tag, Page));
private static ReleaseLookup Staging(string commit) =>
ReleaseLookup.Found(new ReleaseInfo("staging", StagingPage, commit));
private static GitHubReleaseFeed Feed(HttpStatusCode status, string body) =>
new(new TestInstallation().Log, Current, new StubHandler(_ => Respond(status, body)));
private static HttpResponseMessage Respond(HttpStatusCode status, string body) =>
new(status) { Content = new StringContent(body) };
/// <summary>One installation's worth of update checking, restartable on the same disk.</summary>
private sealed class Rig
{
private readonly IReleaseFeed _feed;
private readonly TestInstallation _installation;
public Rig(IReleaseFeed feed)
{
_feed = feed;
_installation = new TestInstallation(Files, new DateTime(2026, 10, 4, 9, 0, 0));
Check = Restart();
}
public InMemoryFileSystem Files { get; } = new();
public SimulatorSettings Settings { get; } = new();
public FixedClock Clock => _installation.Clock;
public UpdateCheck Check { get; }
public UpdateCheck Restart(Version? current = null) =>
new(Settings, _feed, current ?? Current, RunningCommit, Files, Clock, _installation.Log, RecordPath);
}
private sealed class StubFeed(ReleaseLookup lookup) : IReleaseFeed
{
public int Calls { get; private set; }
public UpdateChannel? LastChannel { get; private set; }
public Task<ReleaseLookup> LatestAsync(UpdateChannel channel, CancellationToken cancellationToken = default)
{
Calls++;
LastChannel = channel;
return Task.FromResult(lookup);
}
}
private sealed class StubHandler(Func<HttpRequestMessage, HttpResponseMessage> respond) : HttpMessageHandler
{
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken) =>
Task.FromResult(respond(request));
}
}