355 lines
21 KiB
C#
355 lines
21 KiB
C#
using GatewayKeepalive.Core;
|
|
|
|
namespace GatewayKeepalive.Tests;
|
|
|
|
internal static class GatewayControllerTests
|
|
{
|
|
public static async Task InitialUnconfiguredDoesNotProbeOrWriteAsync()
|
|
{
|
|
using var harness = new ControllerHarness(Fixtures.Baseline());
|
|
|
|
await harness.Controller.RefreshAsync();
|
|
|
|
Check.False(harness.Controller.Settings.Configured, "A fresh controller should remain unconfigured");
|
|
Check.Equal(NetworkMode.Initializing, harness.Controller.Status.Mode, "Unconfigured refresh should publish the initial state");
|
|
Check.Equal(0, harness.Backend.CaptureCount, "Unconfigured refresh must not capture the adapter");
|
|
Check.Equal(0, harness.Probe.CheckCount, "Unconfigured refresh must not probe");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Unconfigured refresh must not write");
|
|
Check.Equal(0, Directory.GetFiles(harness.Temp.DirectoryPath).Length, "Unconfigured refresh must not create state files");
|
|
}
|
|
|
|
public static async Task ExplicitPausedSavePreservesRealDirectDnsAsync()
|
|
{
|
|
var directDns = new DnsConfiguration(Automatic: false, Servers: ["192.168.6.53"], ProfileServers: []);
|
|
var baseline = Fixtures.Baseline() with { Dns = directDns, EffectiveDns = ["192.168.6.53"] };
|
|
using var harness = new ControllerHarness(baseline);
|
|
var settings = Fixtures.Settings() with
|
|
{
|
|
Policy = new AppSettings().Policy,
|
|
PreserveOriginalDirectDns = true,
|
|
DirectDnsAutomatic = true,
|
|
};
|
|
Check.Equal(ControlPolicy.Paused, settings.Policy, "The product default policy should be paused");
|
|
|
|
await harness.Controller.SaveSettingsAsync(settings);
|
|
|
|
var session = harness.Store.Read<SessionState>("session.json");
|
|
Check.True(session is not null, "Save should persist the adoption session");
|
|
Check.False(string.IsNullOrWhiteSpace(session!.SettingsFingerprint), "Save should persist a settings fingerprint");
|
|
Check.False(session.DirectDns is null, "Save should preserve the real direct DNS configuration");
|
|
Check.False(session.DirectDns!.Automatic, "Static direct DNS must not be replaced by automatic DNS");
|
|
Check.SequenceEqual(["192.168.6.53"], session.DirectDns.Servers, "The adapter's static direct DNS should be retained");
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, session.Baseline), "Baseline should be the real pre-adoption snapshot");
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, session.Expected), "Expected should equal the current direct snapshot");
|
|
Check.Equal(ControlPolicy.Paused, harness.Store.Read<AppSettings>("settings.json")?.Policy, "An explicit first save should remain paused");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "A paused save must not change routes or DNS");
|
|
Check.Equal(0, harness.Probe.CheckCount, "Save must not probe");
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, harness.Backend.Current), "The live configuration must remain untouched");
|
|
}
|
|
|
|
public static async Task ExternalConfigurationChangeIsNotOverwrittenAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
using var harness = new ControllerHarness(baseline);
|
|
var settings = Fixtures.Settings();
|
|
await harness.Controller.SaveSettingsAsync(settings);
|
|
var externalRoute = baseline.Routes[0] with { Gateway = "192.168.6.254", Metric = 7 };
|
|
harness.Backend.Current = baseline with { Routes = [externalRoute] };
|
|
|
|
await harness.Controller.RefreshAsync();
|
|
|
|
Check.Equal(NetworkMode.ExternalConfiguration, harness.Controller.Status.Mode, "A changed route should require explicit adoption");
|
|
Check.Equal(ControlPolicy.Paused, harness.Controller.Status.Policy, "External configuration should pause automatic control");
|
|
Check.Equal(0, harness.Probe.CheckCount, "External configuration must be detected before probing");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "External configuration must never be overwritten automatically");
|
|
Check.Equal("192.168.6.254", harness.Backend.Current.Gateway, "The external route should remain in place");
|
|
Check.Equal(ControlPolicy.Auto, harness.Store.Read<AppSettings>("settings.json")?.Policy, "Refresh must not rewrite the saved policy");
|
|
}
|
|
|
|
public static async Task LegacySessionWithoutFingerprintIsNotWritableAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
using var harness = new ControllerHarness(baseline, Fixtures.Settings());
|
|
harness.Store.Write("session.json", new SessionState(baseline, baseline, DnsConfiguration.Auto));
|
|
|
|
await harness.Controller.RefreshAsync();
|
|
|
|
Check.Equal(NetworkMode.ExternalConfiguration, harness.Controller.Status.Mode, "A session with the default empty fingerprint must not claim the new settings");
|
|
Check.Equal(ControlPolicy.Paused, harness.Controller.Status.Policy, "Legacy session refusal should pause automatic control");
|
|
Check.Equal(0, harness.Probe.CheckCount, "Fingerprint mismatch must be rejected before probing");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Fingerprint mismatch must not write");
|
|
}
|
|
|
|
public static async Task SaveFailureAfterSessionWriteDoesNotBecomeWritableAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
var oldSettings = Fixtures.Settings() with { Policy = ControlPolicy.Paused, ProxyDns = "192.168.6.2" };
|
|
using var harness = new ControllerHarness(baseline, oldSettings);
|
|
var settingsPath = harness.FilePath("settings.json");
|
|
File.Delete(settingsPath);
|
|
Directory.CreateDirectory(settingsPath);
|
|
var uncommitted = oldSettings with { ProxyDns = "192.168.6.3" };
|
|
|
|
await Check.ThrowsAsync<IOException>(
|
|
() => harness.Controller.SaveSettingsAsync(uncommitted),
|
|
"A settings write failure should fail the save");
|
|
|
|
Check.True(harness.Store.Read<SessionState>("session.json") is not null, "The test should fail after session.json was written");
|
|
Check.Equal("192.168.6.2", harness.Controller.Settings.ProxyDns, "Failed save must not publish uncommitted settings in memory");
|
|
|
|
await harness.Controller.RefreshAsync();
|
|
|
|
Check.Equal(NetworkMode.ExternalConfiguration, harness.Controller.Status.Mode, "A partial session/settings write must not become writable");
|
|
Check.Equal(ControlPolicy.Paused, harness.Controller.Status.Policy, "A partial write should pause automatic control");
|
|
Check.Equal(0, harness.Probe.CheckCount, "A partial write must not reach health probing");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "A partial write must not alter routes or DNS");
|
|
Check.Equal("192.168.6.2", harness.Store.Read<AppSettings>("settings.json")?.ProxyDns ?? harness.Controller.Settings.ProxyDns, "No new settings should be committed");
|
|
}
|
|
|
|
public static async Task UnfinishedJournalBlocksAutomaticControlAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
using var harness = new ControllerHarness(baseline);
|
|
await harness.Controller.SaveSettingsAsync(Fixtures.Settings());
|
|
var intended = baseline with
|
|
{
|
|
Routes =
|
|
[
|
|
baseline.Routes[0] with { Metric = 101 },
|
|
new RouteEntry("192.168.6.2", 1, baseline.Routes[0].InterfaceLuid, baseline.Routes[0].InterfaceIndex),
|
|
],
|
|
Dns = new DnsConfiguration(false, ["192.168.6.2"], []),
|
|
};
|
|
var journal = new SwitchJournal(baseline, intended, "ApplyingDns", DateTimeOffset.UtcNow);
|
|
harness.Store.Write(SwitchService.JournalFile, journal);
|
|
|
|
await harness.Controller.RefreshAsync();
|
|
|
|
Check.Equal(NetworkMode.RecoveryRequired, harness.Controller.Status.Mode, "An unfinished journal must require recovery");
|
|
Check.Equal(ControlPolicy.Paused, harness.Controller.Status.Policy, "Automatic control must pause for an unfinished journal");
|
|
Check.Equal(0, harness.Probe.CheckCount, "A journal must block checks before probing");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "A journal must block all automatic writes");
|
|
Check.True(harness.Store.Read<SwitchJournal>(SwitchService.JournalFile) is not null, "Automatic refresh must retain the recovery journal");
|
|
Check.Equal(ControlPolicy.Auto, harness.Store.Read<AppSettings>("settings.json")?.Policy, "The saved Auto policy should remain available for after recovery");
|
|
}
|
|
|
|
public static async Task FixedFailureKeepsFixedPolicyAfterRollbackAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
using var harness = new ControllerHarness(baseline);
|
|
var settings = Fixtures.Settings() with { SuccessThreshold = 1 };
|
|
await harness.Controller.SaveSettingsAsync(settings);
|
|
harness.Probe.VerifyResult = false;
|
|
|
|
await Check.ThrowsAsync<IOException>(
|
|
() => harness.Controller.SetPolicyAsync(ControlPolicy.ForceProxy),
|
|
"Failed fixed-mode egress verification should fail the policy change");
|
|
|
|
Check.Equal(ControlPolicy.ForceProxy, harness.Controller.Settings.Policy, "A successful rollback must retain the fixed policy");
|
|
Check.Equal(ControlPolicy.ForceProxy, harness.Store.Read<AppSettings>("settings.json")?.Policy, "The persisted policy must remain fixed");
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, harness.Backend.Current), "Rollback should restore the direct configuration");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "Successful rollback should clear the journal");
|
|
Check.Equal(4, harness.Backend.Writes.Count, "Fixed switch should write and then fully roll back");
|
|
|
|
harness.Probe.Report = Fixtures.Health(proxyHealthy: true, internetHealthy: true);
|
|
await harness.Controller.RefreshAsync();
|
|
|
|
Check.Equal(ControlPolicy.ForceProxy, harness.Controller.Status.Policy, "Health evaluation must not replace the fixed policy with Auto");
|
|
Check.Equal(ControlPolicy.ForceProxy, harness.Controller.Settings.Policy, "Refresh must keep the fixed policy in memory");
|
|
Check.Equal(NetworkMode.Direct, harness.Controller.Status.Mode, "The rollback should leave the controller in direct mode");
|
|
Check.Equal(4, harness.Backend.Writes.Count, "A fixed policy failure must not trigger an automatic retry");
|
|
Check.Equal(1, harness.Probe.CheckCount, "Refresh should observe health without switching");
|
|
}
|
|
|
|
public static async Task ConcurrentRefreshIsCoalescedAsync()
|
|
{
|
|
using var harness = new ControllerHarness(Fixtures.Baseline());
|
|
await harness.Controller.SaveSettingsAsync(Fixtures.Settings());
|
|
var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
harness.Probe.CheckBehavior = async (_, _, cancellationToken) =>
|
|
{
|
|
entered.TrySetResult();
|
|
await release.Task.WaitAsync(cancellationToken);
|
|
return Fixtures.Health(proxyHealthy: true, internetHealthy: true);
|
|
};
|
|
|
|
var first = harness.Controller.RefreshAsync();
|
|
try
|
|
{
|
|
await entered.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
var second = harness.Controller.RefreshAsync();
|
|
await second.WaitAsync(TimeSpan.FromSeconds(1));
|
|
Check.Equal(1, harness.Probe.CheckCount, "A concurrent refresh should be merged into the running check");
|
|
}
|
|
finally { release.TrySetResult(); }
|
|
await first.WaitAsync(TimeSpan.FromSeconds(5));
|
|
Check.Equal(0, harness.Backend.Writes.Count, "A below-threshold check must not write");
|
|
|
|
await harness.Controller.RefreshAsync();
|
|
Check.Equal(2, harness.Probe.CheckCount, "The merge flag must reset after the running check completes");
|
|
}
|
|
|
|
public static async Task SaveAndRefreshAreSerializedAsync()
|
|
{
|
|
using var harness = new ControllerHarness(Fixtures.Baseline());
|
|
var captureEntered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
var releaseCapture = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
var probeEntered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
var captures = 0;
|
|
harness.Backend.CaptureBehavior = async (_, cancellationToken) =>
|
|
{
|
|
if (Interlocked.Increment(ref captures) == 1)
|
|
{
|
|
captureEntered.TrySetResult();
|
|
await releaseCapture.Task.WaitAsync(cancellationToken);
|
|
}
|
|
return harness.Backend.Current;
|
|
};
|
|
harness.Probe.CheckBehavior = (_, _, _) =>
|
|
{
|
|
probeEntered.TrySetResult();
|
|
return Task.FromResult(Fixtures.Health(proxyHealthy: true, internetHealthy: true));
|
|
};
|
|
var settings = Fixtures.Settings() with { Policy = ControlPolicy.Paused };
|
|
|
|
var save = harness.Controller.SaveSettingsAsync(settings);
|
|
Task? refresh = null;
|
|
var probeStartedWhileSaveHeldGate = false;
|
|
var refreshCompletedWhileSaveHeldGate = false;
|
|
try
|
|
{
|
|
await captureEntered.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
refresh = harness.Controller.RefreshAsync();
|
|
var earlyWinner = await Task.WhenAny(probeEntered.Task, Task.Delay(TimeSpan.FromMilliseconds(150)));
|
|
probeStartedWhileSaveHeldGate = ReferenceEquals(earlyWinner, probeEntered.Task);
|
|
refreshCompletedWhileSaveHeldGate = refresh.IsCompleted;
|
|
}
|
|
finally { releaseCapture.TrySetResult(); }
|
|
await save.WaitAsync(TimeSpan.FromSeconds(5));
|
|
if (refresh is not null) await refresh.WaitAsync(TimeSpan.FromSeconds(5));
|
|
|
|
Check.False(probeStartedWhileSaveHeldGate, "Refresh must wait for the in-progress save");
|
|
Check.False(refreshCompletedWhileSaveHeldGate, "Refresh must not complete while another write operation holds the gate");
|
|
Check.Equal(1, harness.Probe.CheckCount, "Refresh should run once after the save releases the gate");
|
|
Check.Equal(2, harness.Backend.CaptureCount, "Save and the subsequent refresh should capture sequentially");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Neither operation should write in paused mode");
|
|
}
|
|
|
|
public static async Task StopRestoresWhenRequestedAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
using var harness = new ControllerHarness(baseline);
|
|
var settings = Fixtures.Settings();
|
|
await SwitchToProxyAsync(harness, settings);
|
|
await harness.Controller.SaveSettingsAsync(settings with { Policy = ControlPolicy.Paused, RestoreOnExit = true });
|
|
Check.Equal(2, harness.Backend.Writes.Count, "Proxy setup should be the only network change before stop");
|
|
|
|
await harness.Controller.StopAsync();
|
|
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, harness.Backend.Current), "RestoreOnExit should restore the original direct configuration");
|
|
Check.Equal(4, harness.Backend.Writes.Count, "Stop should write baseline routes and DNS once");
|
|
Check.Equal(ControlPolicy.Paused, harness.Controller.Status.Policy, "Stop restore should leave automatic control paused");
|
|
Check.Equal(ControlPolicy.Paused, harness.Store.Read<AppSettings>("settings.json")?.Policy, "Stop restore should persist paused policy");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "Stop restore should clear its journal");
|
|
var session = harness.Store.Read<SessionState>("session.json");
|
|
Check.True(session is not null, "Stop restore should persist the updated session");
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, session!.Expected), "Stopped session should record the restored configuration");
|
|
}
|
|
|
|
public static async Task StopRestoresPersistedSessionBeforeFirstRefreshAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
using var harness = new ControllerHarness(baseline);
|
|
var settings = Fixtures.Settings();
|
|
await SwitchToProxyAsync(harness, settings);
|
|
await harness.Controller.SaveSettingsAsync(settings with { Policy = ControlPolicy.Paused, RestoreOnExit = true });
|
|
Check.Equal("192.168.6.2", harness.Backend.Current.Gateway, "Fixture should persist a proxy session before restart");
|
|
|
|
var restarted = new GatewayController(harness.Backend, harness.Probe, harness.Store, harness.Logs.Add);
|
|
await restarted.StopAsync();
|
|
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, harness.Backend.Current), "RestoreOnExit must restore the persisted baseline even before the first refresh");
|
|
}
|
|
|
|
public static async Task StopLeavesNetworkWhenRestoreIsDisabledAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
using var harness = new ControllerHarness(baseline);
|
|
var settings = Fixtures.Settings();
|
|
await SwitchToProxyAsync(harness, settings);
|
|
await harness.Controller.SaveSettingsAsync(settings with { Policy = ControlPolicy.Paused, RestoreOnExit = false });
|
|
var writesBeforeStop = harness.Backend.Writes.Count;
|
|
|
|
await harness.Controller.StopAsync();
|
|
|
|
Check.Equal(writesBeforeStop, harness.Backend.Writes.Count, "Stop must not restore when RestoreOnExit is false");
|
|
Check.Equal("192.168.6.2", harness.Backend.Current.Gateway, "The proxy configuration should remain active");
|
|
Check.Equal(false, harness.Store.Read<AppSettings>("settings.json")?.RestoreOnExit, "RestoreOnExit should remain disabled");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "A normal stop should leave no journal");
|
|
}
|
|
|
|
public static async Task StopRestoreFailureLeavesControllerAvailableAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
using var harness = new ControllerHarness(baseline);
|
|
var settings = Fixtures.Settings();
|
|
await SwitchToProxyAsync(harness, settings);
|
|
await harness.Controller.SaveSettingsAsync(settings with { Policy = ControlPolicy.Paused, RestoreOnExit = true });
|
|
var failedAutoWrite = 0;
|
|
harness.Backend.DnsWriteBehavior = desired =>
|
|
{
|
|
if (desired.Automatic && Interlocked.Increment(ref failedAutoWrite) == 1)
|
|
throw new IOException("Injected restore DNS failure");
|
|
harness.Backend.ApplyDns(desired);
|
|
return Task.CompletedTask;
|
|
};
|
|
|
|
await Check.ThrowsAsync<IOException>(
|
|
() => harness.Controller.StopAsync(),
|
|
"A failed restore during stop should be reported");
|
|
Check.Equal("192.168.6.2", harness.Backend.Current.Gateway, "Failed stop restore should compensate to the pre-stop proxy state");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "Successful compensation should clear the journal");
|
|
|
|
harness.Backend.DnsWriteBehavior = null;
|
|
var probesBefore = harness.Probe.CheckCount;
|
|
await harness.Controller.RefreshAsync();
|
|
Check.Equal(probesBefore + 1, harness.Probe.CheckCount, "A failed stop restore must leave the controller running");
|
|
Check.Equal(NetworkMode.Proxy, harness.Controller.Status.Mode, "Compensation should leave the controller on the proxy configuration");
|
|
|
|
await harness.Controller.StopAsync();
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, harness.Backend.Current), "A retried stop should restore successfully");
|
|
}
|
|
|
|
private static async Task SwitchToProxyAsync(ControllerHarness harness, AppSettings settings)
|
|
{
|
|
harness.Probe.VerifyResult = true;
|
|
await harness.Controller.SaveSettingsAsync(settings with { Policy = ControlPolicy.Paused });
|
|
await harness.Controller.SetPolicyAsync(ControlPolicy.ForceProxy);
|
|
Check.Equal("192.168.6.2", harness.Backend.Current.Gateway, "Fake switch should reach the proxy gateway");
|
|
Check.Equal(2, harness.Backend.Writes.Count, "Fake proxy setup should write routes and DNS");
|
|
}
|
|
|
|
private sealed class ControllerHarness : IDisposable
|
|
{
|
|
public ControllerHarness(NetworkSnapshot initial, AppSettings? persistedSettings = null)
|
|
{
|
|
Store = new JsonStore(Temp.DirectoryPath);
|
|
if (persistedSettings is not null) Store.Write("settings.json", persistedSettings);
|
|
Backend = new FakeBackend(initial);
|
|
Probe = new FakeProbe();
|
|
Controller = new GatewayController(Backend, Probe, Store, Logs.Add);
|
|
}
|
|
|
|
public TempDirectory Temp { get; } = new();
|
|
public FakeBackend Backend { get; }
|
|
public FakeProbe Probe { get; }
|
|
public JsonStore Store { get; }
|
|
public GatewayController Controller { get; }
|
|
public List<string> Logs { get; } = [];
|
|
public string FilePath(string name) => Path.Combine(Temp.DirectoryPath, name);
|
|
|
|
public void Dispose() => Temp.Dispose();
|
|
}
|
|
}
|