345 lines
21 KiB
C#
345 lines
21 KiB
C#
using GatewayKeepalive.Core;
|
|
|
|
namespace GatewayKeepalive.Tests;
|
|
|
|
internal static class SwitchServiceTests
|
|
{
|
|
public static async Task DnsFailureAfterRouteWriteRollsBackAsync()
|
|
{
|
|
var before = Fixtures.Baseline();
|
|
using var harness = new SwitchHarness(before);
|
|
harness.Backend.DnsWriteBehavior = desired =>
|
|
{
|
|
if (desired.Servers.Contains("192.168.6.2", StringComparer.Ordinal))
|
|
throw new IOException("Injected DNS write failure");
|
|
harness.Backend.ApplyDns(desired);
|
|
return Task.CompletedTask;
|
|
};
|
|
|
|
var failure = await Check.ThrowsAsync<IOException>(
|
|
() => harness.Service.SwitchAsync(Fixtures.Settings(), before, proxy: true, directDns: null, CancellationToken.None),
|
|
"A DNS failure must surface as a failed switch");
|
|
|
|
Check.Contains("已恢复", failure.Message, "Rollback success should be reported");
|
|
Check.SequenceEqual(
|
|
[new BackendWrite("route", "192.168.6.2"), new BackendWrite("dns", "192.168.6.2"), new BackendWrite("route", "192.168.6.1")],
|
|
harness.Backend.Writes,
|
|
"The service must restore the changed route and leave the unchanged DNS alone");
|
|
Check.True(NetworkComparison.SameConfiguration(before, harness.Backend.Current), "The fake adapter should be back to its exact pre-switch configuration");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "A verified rollback must remove the journal");
|
|
Check.True(harness.Logs.Any(line => line.Contains("切换失败，开始恢复", StringComparison.Ordinal)), "The failure path should be logged");
|
|
Check.True(harness.Logs.Any(line => line.Contains("切换前配置已恢复并读回验证", StringComparison.Ordinal)), "Verified rollback should be logged");
|
|
Check.Equal(0, harness.Probe.VerifyCount, "Egress verification must not run after DNS failure");
|
|
}
|
|
|
|
public static async Task EgressFailureRollsBackAsync()
|
|
{
|
|
var before = Fixtures.Baseline();
|
|
using var harness = new SwitchHarness(before);
|
|
harness.Probe.VerifyResult = false;
|
|
|
|
var failure = await Check.ThrowsAsync<IOException>(
|
|
() => harness.Service.SwitchAsync(Fixtures.Settings(), before, proxy: true, directDns: null, CancellationToken.None),
|
|
"Failed egress verification must fail the switch");
|
|
|
|
Check.Contains("出口验证", failure.Message, "Egress failure should be identified");
|
|
Check.Equal(1, harness.Probe.VerifyCount, "The probe should run once after route and DNS readback");
|
|
Check.Equal(false, harness.Probe.VerifyToken.IsCancellationRequested, "The switch budget should still be live during verification");
|
|
Check.Equal("192.168.6.2", harness.Probe.VerifiedSnapshot?.Gateway, "Verification should use the applied proxy configuration");
|
|
Check.SequenceEqual(
|
|
[new BackendWrite("route", "192.168.6.2"), new BackendWrite("dns", "192.168.6.2"), new BackendWrite("route", "192.168.6.1"), new BackendWrite("dns", "auto")],
|
|
harness.Backend.Writes,
|
|
"A failed egress check must restore routes and DNS");
|
|
Check.True(NetworkComparison.SameConfiguration(before, harness.Backend.Current), "The adapter must be restored exactly");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "Successful rollback must delete the journal");
|
|
}
|
|
|
|
public static async Task RollbackFailureRetainsJournalAsync()
|
|
{
|
|
var before = Fixtures.Baseline();
|
|
using var harness = new SwitchHarness(before);
|
|
harness.Backend.DnsWriteBehavior = desired =>
|
|
{
|
|
if (desired.Servers.Contains("192.168.6.2", StringComparer.Ordinal))
|
|
throw new IOException("Injected initial DNS failure");
|
|
harness.Backend.ApplyDns(desired);
|
|
return Task.CompletedTask;
|
|
};
|
|
var routeWrites = 0;
|
|
harness.Backend.RouteWriteBehavior = desired =>
|
|
{
|
|
routeWrites++;
|
|
if (routeWrites == 2) throw new IOException("Injected rollback route failure");
|
|
harness.Backend.ApplyRoutes(desired);
|
|
return Task.CompletedTask;
|
|
};
|
|
|
|
var failure = await Check.ThrowsAsync<RecoveryRequiredException>(
|
|
() => harness.Service.SwitchAsync(Fixtures.Settings(), before, proxy: true, directDns: null, CancellationToken.None),
|
|
"Failed rollback must require recovery");
|
|
|
|
Check.Contains("恢复未完成", failure.Message, "RecoveryRequired should explain the incomplete rollback");
|
|
Check.True(failure.InnerException is AggregateException, "Both the switch and rollback failures should be retained");
|
|
var journal = harness.Store.Read<SwitchJournal>(SwitchService.JournalFile);
|
|
Check.True(journal is not null, "Failed rollback must retain the journal");
|
|
Check.Equal("RollingBack", journal!.Stage, "Journal should remain in the interrupted rollback stage");
|
|
Check.True(NetworkComparison.SameConfiguration(before, journal.Before), "Journal must retain the true pre-switch baseline");
|
|
Check.Equal(2, routeWrites, "Route write should occur once forward and once for rollback");
|
|
}
|
|
|
|
public static async Task ExternalModificationIsNotOverwrittenAsync()
|
|
{
|
|
var before = Fixtures.Baseline();
|
|
using (var harness = new SwitchHarness(before))
|
|
{
|
|
var changed = before with
|
|
{
|
|
Routes = [before.Routes[0] with { Metric = 77 }],
|
|
};
|
|
harness.Backend.Current = changed;
|
|
await Check.ThrowsAsync<InvalidOperationException>(
|
|
() => harness.Service.SwitchAsync(Fixtures.Settings(), before, proxy: true, directDns: null, CancellationToken.None),
|
|
"A mismatch against the saved expected snapshot must be rejected");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "The service must not write when the expected snapshot is stale");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "No journal should be created when preflight fails");
|
|
Check.Equal(77u, harness.Backend.Current.PreferredRoute?.Metric, "The external route change must remain untouched");
|
|
}
|
|
|
|
using (var harness = new SwitchHarness(before))
|
|
{
|
|
var foreign = new RouteEntry("10.20.30.40", 9, 0x5555, 55);
|
|
harness.Backend.DnsWriteBehavior = _ =>
|
|
{
|
|
harness.Backend.Current = harness.Backend.Current with
|
|
{
|
|
Routes = harness.Backend.Current.Routes.Append(foreign).ToArray(),
|
|
};
|
|
throw new IOException("Injected DNS failure after external route change");
|
|
};
|
|
|
|
await Check.ThrowsAsync<RecoveryRequiredException>(
|
|
() => harness.Service.SwitchAsync(Fixtures.Settings(), before, proxy: true, directDns: null, CancellationToken.None),
|
|
"A foreign row during recovery must stop rollback");
|
|
Check.True(harness.Backend.Current.Routes.Any(route => route == foreign), "Recovery must leave the external route in place");
|
|
Check.SequenceEqual([new BackendWrite("route", "192.168.6.2"), new BackendWrite("dns", "192.168.6.2")], harness.Backend.Writes, "Rollback must not write over the foreign configuration");
|
|
var journal = harness.Store.Read<SwitchJournal>(SwitchService.JournalFile);
|
|
Check.True(journal is not null, "RecoveryRequired must preserve the journal");
|
|
Check.Equal("ApplyingDns", journal!.Stage, "Journal should retain the failed apply stage");
|
|
}
|
|
}
|
|
|
|
public static async Task CrossNetworkRollbackIsRejectedAsync()
|
|
{
|
|
var before = Fixtures.Baseline();
|
|
using var harness = new SwitchHarness(before);
|
|
var intended = harness.Service.Plan(Fixtures.Settings(), before, proxy: true, directDns: null);
|
|
var journal = new SwitchJournal(before, intended, "ApplyingDns", DateTimeOffset.UtcNow);
|
|
harness.Backend.Current = before with
|
|
{
|
|
Adapter = before.Adapter with { NetworkFingerprint = "network-b" },
|
|
};
|
|
|
|
var failure = await Check.ThrowsAsync<RecoveryRequiredException>(
|
|
() => harness.Service.RollbackAsync(journal, CancellationToken.None),
|
|
"Rollback must reject a different network identity");
|
|
Check.Contains("不属于本次切换", failure.Message, "Cross-network rejection should explain ownership failure");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Cross-network recovery must not write routes or DNS");
|
|
Check.Equal("network-b", harness.Backend.Current.Adapter.NetworkFingerprint, "The other network must remain untouched");
|
|
|
|
var blank = before with { Adapter = before.Adapter with { NetworkFingerprint = " " } };
|
|
harness.Backend.Current = blank;
|
|
await Check.ThrowsAsync<RecoveryRequiredException>(
|
|
() => harness.Service.RollbackAsync(journal, CancellationToken.None),
|
|
"Rollback must reject an unknown network identity");
|
|
}
|
|
|
|
public static async Task ProfileDnsIsRejectedAsync()
|
|
{
|
|
var baseline = Fixtures.Baseline();
|
|
var profiled = baseline with
|
|
{
|
|
Dns = new DnsConfiguration(Automatic: false, Servers: ["192.168.6.1"], ProfileServers: ["192.168.6.99"]),
|
|
};
|
|
using var harness = new SwitchHarness(profiled);
|
|
|
|
var failure = await Check.ThrowsAsync<InvalidOperationException>(
|
|
() => harness.Service.SwitchAsync(Fixtures.Settings(), profiled, proxy: true, directDns: null, CancellationToken.None),
|
|
"Profile DNS must prevent takeover");
|
|
Check.Contains("配置文件 DNS", failure.Message, "Rejection should identify profile DNS");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Profile DNS must be rejected before any write");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "Profile DNS rejection must not leave a journal");
|
|
}
|
|
|
|
public static Task GatewayMustBeOnAdapterSubnetAsync()
|
|
{
|
|
var before = Fixtures.Baseline();
|
|
using var harness = new SwitchHarness(before);
|
|
var settings = Fixtures.Settings();
|
|
|
|
var remoteProxy = Check.Throws<InvalidOperationException>(
|
|
() => harness.Service.Plan(settings with { ProxyGateway = "192.168.7.2" }, before, proxy: true, directDns: null),
|
|
"A proxy gateway outside the adapter subnet must be rejected");
|
|
Check.Contains("子网", remoteProxy.Message, "Subnet rejection should be specific");
|
|
|
|
Check.Throws<InvalidOperationException>(
|
|
() => harness.Service.Plan(settings with { DirectGateway = "192.168.7.1" }, before, proxy: false, directDns: null),
|
|
"A direct gateway outside the adapter subnet must be rejected");
|
|
Check.Throws<InvalidOperationException>(
|
|
() => harness.Service.Plan(settings with { ProxyGateway = "192.168.6.10" }, before, proxy: true, directDns: null),
|
|
"A gateway equal to the local address must be rejected");
|
|
|
|
var narrow = before with
|
|
{
|
|
Adapter = before.Adapter with { Addresses = [new Ipv4Address("192.168.6.130", 25)] },
|
|
Routes = [before.Routes[0] with { Gateway = "192.168.6.129" }],
|
|
};
|
|
Check.Throws<InvalidOperationException>(
|
|
() => harness.Service.Plan(settings with { DirectGateway = "192.168.6.129", ProxyGateway = "192.168.6.2" }, narrow, proxy: true, directDns: null),
|
|
"Subnet validation must honor a non-/24 prefix");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Plan must remain read-only on validation failure");
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public static async Task BaselineRestoreFailureCompensatesAsync()
|
|
{
|
|
var original = Fixtures.Baseline();
|
|
using var harness = new SwitchHarness(original);
|
|
var current = harness.Service.Plan(Fixtures.Settings(), original, proxy: true, directDns: null);
|
|
harness.Backend.Current = current;
|
|
var dnsWrites = 0;
|
|
harness.Backend.DnsWriteBehavior = desired =>
|
|
{
|
|
dnsWrites++;
|
|
if (dnsWrites == 1) throw new IOException("Injected baseline DNS failure");
|
|
harness.Backend.ApplyDns(desired);
|
|
return Task.CompletedTask;
|
|
};
|
|
|
|
var failure = await Check.ThrowsAsync<IOException>(
|
|
() => harness.Service.RestoreBaselineAsync(current, original, CancellationToken.None),
|
|
"A failed baseline restore must report the compensation result");
|
|
Check.Contains("已退回", failure.Message, "Successful compensation should be explicit");
|
|
Check.SequenceEqual(
|
|
[new BackendWrite("route", "192.168.6.1"), new BackendWrite("dns", "auto"), new BackendWrite("route", "192.168.6.2")],
|
|
harness.Backend.Writes,
|
|
"Baseline failure must restore the changed route and leave unchanged proxy DNS alone");
|
|
Check.True(NetworkComparison.SameConfiguration(current, harness.Backend.Current), "Compensation must restore the exact pre-restore configuration");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "Verified compensation must remove the restore journal");
|
|
Check.True(harness.Logs.Any(line => line.Contains("切换前配置已恢复并读回验证", StringComparison.Ordinal)), "Verified baseline compensation should be logged");
|
|
|
|
var foreign = current with
|
|
{
|
|
Routes = current.Routes.Append(new RouteEntry("10.9.8.7", 3, 0x9999, 99)).ToArray(),
|
|
};
|
|
harness.Backend.Current = foreign;
|
|
var writesBefore = harness.Backend.Writes.Count;
|
|
await Check.ThrowsAsync<RecoveryRequiredException>(
|
|
() => harness.Service.RestoreBaselineAsync(current, original, CancellationToken.None),
|
|
"Baseline restore must reject an externally modified live configuration");
|
|
Check.Equal(writesBefore, harness.Backend.Writes.Count, "Rejected baseline restore must not overwrite the external configuration");
|
|
Check.True(harness.Backend.Current.Routes.Any(route => route.Gateway == "10.9.8.7"), "External baseline modification should remain");
|
|
|
|
var otherNetwork = original with { Adapter = original.Adapter with { NetworkFingerprint = "network-b" } };
|
|
await Check.ThrowsAsync<RecoveryRequiredException>(
|
|
() => harness.Service.RestoreBaselineAsync(current, otherNetwork, CancellationToken.None),
|
|
"A baseline from another network must be rejected");
|
|
}
|
|
|
|
public static Task PlanPreservesPreferredMetricAsync()
|
|
{
|
|
var route = Fixtures.Baseline().Routes[0] with { Metric = 0 };
|
|
var preferred = Fixtures.Baseline() with { Routes = [route] };
|
|
using var harness = new SwitchHarness(preferred);
|
|
var settings = Fixtures.Settings();
|
|
|
|
var directPlan = harness.Service.Plan(settings, preferred, proxy: false, directDns: null);
|
|
Check.Equal(0u, directPlan.PreferredRoute?.Metric, "An already preferred gateway must retain its DHCP metric of zero");
|
|
Check.True(NetworkComparison.SameConfiguration(preferred, directPlan), "A no-op direct plan must preserve route and DNS configuration");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Plan must remain read-only");
|
|
|
|
var proxyPlan = harness.Service.Plan(settings, preferred, proxy: true, directDns: null);
|
|
Check.Equal("192.168.6.2", proxyPlan.Gateway, "A non-preferred target should become preferred");
|
|
Check.Equal(1u, proxyPlan.PreferredRoute?.Metric, "The new proxy route should use the preferred metric");
|
|
Check.Equal(101u, proxyPlan.Routes.Single(x => x.Gateway == "192.168.6.1").Metric, "The previous route should be demoted relative to the new preferred route");
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public static async Task SwitchSameConfigurationSkipsWritesAsync()
|
|
{
|
|
var route = Fixtures.Baseline().Routes[0] with { Metric = 0 };
|
|
var before = Fixtures.Baseline() with { Routes = [route] };
|
|
using var harness = new SwitchHarness(before);
|
|
|
|
var actual = await harness.Service.SwitchAsync(
|
|
Fixtures.Settings(), before, proxy: false, directDns: null, CancellationToken.None);
|
|
|
|
Check.True(NetworkComparison.SameConfiguration(before, actual), "Switch should return the unchanged verified configuration");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "An already matching route and DNS must not be rewritten");
|
|
Check.Equal(1, harness.Probe.VerifyCount, "No-op switching should still verify the actual egress");
|
|
Check.Equal(2, harness.Backend.CaptureCount, "Switch should capture once for preflight and once for readback");
|
|
Check.Equal("Verified", harness.Store.Read<SwitchJournal>(SwitchService.JournalFile)?.Stage, "A verified no-op should leave the completed journal for the controller");
|
|
}
|
|
|
|
public static async Task SwitchWritesOnlyChangedDnsAsync()
|
|
{
|
|
var route = Fixtures.Baseline().Routes[0] with { Metric = 0 };
|
|
var before = Fixtures.Baseline() with { Routes = [route] };
|
|
var directDns = new DnsConfiguration(Automatic: false, Servers: ["192.168.6.53"], ProfileServers: []);
|
|
using var harness = new SwitchHarness(before);
|
|
|
|
var actual = await harness.Service.SwitchAsync(
|
|
Fixtures.Settings(), before, proxy: false, directDns, CancellationToken.None);
|
|
|
|
Check.SequenceEqual([new BackendWrite("dns", "192.168.6.53")], harness.Backend.Writes, "Only the changed DNS component should be written");
|
|
Check.True(NetworkComparison.SameDns(directDns, actual.Dns), "Readback should expose the requested direct DNS");
|
|
Check.Equal(1, harness.Probe.VerifyCount, "The changed configuration should be verified");
|
|
}
|
|
|
|
public static async Task SwitchWritesOnlyChangedRoutesAsync()
|
|
{
|
|
var settings = Fixtures.Settings();
|
|
using var harness = new SwitchHarness(Fixtures.Baseline());
|
|
var proxy = harness.Service.Plan(settings, Fixtures.Baseline(), proxy: true, directDns: null);
|
|
var before = proxy with { Dns = DnsConfiguration.Auto, EffectiveDns = ["192.168.6.1"] };
|
|
harness.Backend.Current = before;
|
|
|
|
var actual = await harness.Service.SwitchAsync(
|
|
settings, before, proxy: false, directDns: null, CancellationToken.None);
|
|
|
|
Check.SequenceEqual([new BackendWrite("route", "192.168.6.1")], harness.Backend.Writes, "Only the changed route component should be written");
|
|
Check.True(NetworkComparison.SameDns(DnsConfiguration.Auto, actual.Dns), "Unchanged direct DNS must not be rewritten");
|
|
Check.Equal("192.168.6.1", actual.Gateway, "Readback should expose the direct gateway");
|
|
Check.Equal(1, harness.Probe.VerifyCount, "The changed route should be verified");
|
|
}
|
|
|
|
public static async Task RollbackSameConfigurationSkipsWritesAsync()
|
|
{
|
|
var route = Fixtures.Baseline().Routes[0] with { Metric = 0 };
|
|
var before = Fixtures.Baseline() with { Routes = [route] };
|
|
using var harness = new SwitchHarness(before);
|
|
var intended = harness.Service.Plan(Fixtures.Settings(), before, proxy: true, directDns: null);
|
|
var journal = new SwitchJournal(before, intended, "ApplyingDns", DateTimeOffset.UtcNow);
|
|
|
|
var actual = await harness.Service.RollbackAsync(journal, CancellationToken.None);
|
|
|
|
Check.True(NetworkComparison.SameConfiguration(before, actual), "Rollback of an unchanged state should return the baseline");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Rollback must skip both writes when routes and DNS already match");
|
|
Check.Equal(2, harness.Backend.CaptureCount, "Rollback should capture before deciding and after verification");
|
|
Check.Equal<SwitchJournal?>(null, harness.Store.Read<SwitchJournal>(SwitchService.JournalFile), "Verified no-op rollback should clear its journal");
|
|
}
|
|
|
|
public static async Task BaselineRestoreSameConfigurationSkipsWritesAsync()
|
|
{
|
|
var route = Fixtures.Baseline().Routes[0] with { Metric = 0 };
|
|
var baseline = Fixtures.Baseline() with { Routes = [route] };
|
|
using var harness = new SwitchHarness(baseline);
|
|
|
|
var actual = await harness.Service.RestoreBaselineAsync(baseline, baseline, CancellationToken.None);
|
|
|
|
Check.True(NetworkComparison.SameConfiguration(baseline, actual), "Restoring an unchanged baseline should return the verified snapshot");
|
|
Check.Equal(0, harness.Backend.Writes.Count, "Baseline restore must skip both writes when nothing changed");
|
|
Check.Equal(2, harness.Backend.CaptureCount, "Baseline restore should capture for preflight and readback");
|
|
Check.Equal("Verified", harness.Store.Read<SwitchJournal>(SwitchService.JournalFile)?.Stage, "No-op restore should leave the completed journal for the controller");
|
|
}
|
|
}
|