From d056f9df3a63564ab140fdc9777663baebc05139 Mon Sep 17 00:00:00 2001 From: ari Date: Mon, 19 Oct 2026 23:18:27 -0400 Subject: [PATCH] F: F1 eval cases for the restart/reload split and the new assertions --- nix/tests/module-peers.nix | 109 +++++++++++++++++++++++++++++++++++-- 1 file changed, 103 insertions(+), 6 deletions(-) diff --git a/nix/tests/module-peers.nix b/nix/tests/module-peers.nix index 5a3a4d4..8a468b3 100644 --- a/nix/tests/module-peers.nix +++ b/nix/tests/module-peers.nix @@ -43,6 +43,11 @@ let failsWith = settings: needle: lib.any (m: lib.hasInfix needle m) (failedAssertions settings); + # The restart trigger carries the part of the config SIGHUP cannot apply, as + # JSON. Reading it back as data keeps the cases independent of key order. + restartSettings = settings: + builtins.fromJSON (builtins.head (service settings).restartTriggers); + credentialDir = "/run/credentials/skyg-linux-tracker.service"; token = name: "/run/agenix/peer-${name}"; twoPeers = { @@ -90,14 +95,28 @@ let keyFile = "/run/agenix/tls-key"; }; }); + + # Variants used by the reload/restart cases: one change inside the part + # SIGHUP applies, one that only a restart can apply. + withPeerUrl = url: twoPeers // { + peers = twoPeers.peers // { + peers = twoPeers.peers.peers // { + beta = twoPeers.peers.peers.beta // { url = url; }; + }; + }; + }; + withPeerSettings = extra: twoPeers // { + peers = twoPeers.peers // { settings = twoPeers.peers.settings // extra; }; + }; + withPort = port: twoPeers // { port = port; }; in [ (expect "a peer-less config gains no [peers] section" (!(plain ? peers))) (expect "a peer-less unit has no peer credentials" (!((service { enable = true; }).serviceConfig ? LoadCredential))) - (expect "a peer-less unit restarts on config changes" + (expect "a peer-less unit still reloads and restarts on config changes" ((service { enable = true; }).restartTriggers != [ ] - && ((service { enable = true; }).reloadTriggers == [ ]))) + && ((service { enable = true; }).reloadTriggers != [ ]))) (expect "peers.enable turns the feature on" (peersCfg.peers.enabled == true)) (expect "settings are merged into [peers]" (peersCfg.peers.tcp_interval_secs == 2)) @@ -122,11 +141,37 @@ in ])) (expect "reload refreshes credentials" (peersService.serviceConfig.RefreshOnReload == "credentials")) - (expect "peer changes reload instead of restart" - (peersService.reloadTriggers != [ ] && (peersService.restartTriggers == [ ]))) + + # `switch-to-configuration` reloads a unit only when the reload triggers are + # the sole difference in the unit file, and restarts it otherwise. So a peer + # edit or an interval change must leave the restart trigger untouched, and + # anything SIGHUP cannot apply must move it. + (expect "the restart trigger carries only the keys SIGHUP cannot apply" + ((restartSettings twoPeers).peers == { enabled = true; } + && !((restartSettings twoPeers).peers ? peer) + && !((restartSettings twoPeers).peers ? tcp_interval_secs))) + (expect "a peer url change reloads instead of restarting" + ((rendered (withPeerUrl "https://beta2:1984")) != peersCfg + && (restartSettings (withPeerUrl "https://beta2:1984")) == (restartSettings twoPeers) + && (service (withPeerUrl "https://beta2:1984")).reloadTriggers != peersService.reloadTriggers)) + (expect "an interval change reloads instead of restarting" + ((restartSettings (withPeerSettings { api_interval_secs = 9; })) == (restartSettings twoPeers) + && (service (withPeerSettings { api_interval_secs = 9; })).reloadTriggers != peersService.reloadTriggers)) + (expect "a port change restarts even with peers on" + ((restartSettings (withPort 2084)) != (restartSettings twoPeers) + && (rendered (withPort 2084)) != peersCfg)) + (expect "a port change restarts with peers off" + ((restartSettings ({ enable = true; port = 2084; })) != (restartSettings { enable = true; }))) + (expect "a concurrency limit change restarts" + ((restartSettings (withPeerSettings { max_concurrent_total = 32; })).peers.max_concurrent_total == 32 + && (restartSettings (withPeerSettings { max_concurrent_total = 32; })) != (restartSettings twoPeers))) + (expect "a deny_cidrs change restarts" + ((restartSettings (withPeerSettings { deny_cidrs = [ "10.0.0.0/8" ]; })) != (restartSettings twoPeers))) + (expect "an auth setting change restarts" + ((restartSettings (twoPeers // { settings.auth.enabled = false; })) != (restartSettings twoPeers))) (expect "TLS alone keeps the restart trigger" - ((service tlsOnly).restartTriggers != [ ] && ((service tlsOnly).reloadTriggers == [ ]))) + ((service tlsOnly).restartTriggers != [ ] && ((service tlsOnly).reloadTriggers != [ ]))) (expect "TLS credentials are unchanged" ((service tlsOnly).serviceConfig.LoadCredential == [ "cert:/run/agenix/tls-cert" @@ -151,7 +196,15 @@ in }).peers.peer) == [{ name = "alpha"; url = "http://alpha:1984"; token_file = "/run/creds/alpha"; allow_plain_http = true; }])) (expect "enable without peers is rejected" - (failsWith { enable = true; peers.enable = true; } "requires at least one peer")) + (failsWith { enable = true; peers.enable = true; } "requires at least one enabled peer")) + (expect "enabled peers are what counts" + (failsWith { + enable = true; + peers = { + enable = true; + peers.off = { url = "https://off:1984"; tokenFile = token "off"; enable = false; }; + }; + } "requires at least one enabled peer")) (expect "peers without enable are rejected" (failsWith { enable = true; peers.peers.beta = { url = "https://beta:1984"; tokenFile = token "beta"; }; } "requires peers.enable = true")) (expect "invalid names are rejected" @@ -160,8 +213,52 @@ in (failsWith { enable = true; peers = { enable = true; peers.beta = { url = "https://beta:1984"; tokenFile = "${storePath}"; }; }; } "outside the Nix store")) (expect "relative tokenFile is rejected" (failsWith { enable = true; peers = { enable = true; peers.beta = { url = "https://beta:1984"; tokenFile = "peer-beta"; }; }; } "absolute path")) + (expect "a colon in tokenFile is rejected" + (failsWith { enable = true; peers = { enable = true; peers.beta = { url = "https://beta:1984"; tokenFile = "/run/agenix/peer:beta"; }; }; } "must not contain")) + (expect "a space in tokenFile is rejected" + (failsWith { enable = true; peers = { enable = true; peers.beta = { url = "https://beta:1984"; tokenFile = "/run/agenix/peer beta"; }; }; } "must not contain")) + (expect "more than 64 peers are rejected" ( + let + many = lib.genAttrs (map (i: "p${toString i}") (lib.range 1 65)) (_: { + url = "https://peer:1984"; + tokenFile = "/run/agenix/many"; + }); + in + failsWith { enable = true; peers = { enable = true; peers = many; }; } "at most 64 peers")) + (expect "64 peers are accepted" ( + let + many = lib.genAttrs (map (i: "p${toString i}") (lib.range 1 64)) (_: { + url = "https://peer:1984"; + tokenFile = "/run/agenix/many"; + }); + in + failedAssertions { enable = true; peers = { enable = true; peers = many; }; } == [ ])) (expect "relative caFile is rejected" (failsWith { enable = true; peers = { enable = true; peers.beta = { url = "https://beta:1984"; tokenFile = token "beta"; caFile = "ca.pem"; }; }; } "caFile must be an absolute path")) + (expect "peers.settings.enabled cannot override peers.enable" + (failsWith { + enable = true; + peers = { + enable = true; + settings.enabled = false; + peers.beta = { url = "https://beta:1984"; tokenFile = token "beta"; }; + }; + } "conflict with peers.enable")) + (expect "settings.peers.enabled cannot override peers.enable" + (failsWith { + enable = true; + settings.peers.enabled = false; + peers = { enable = true; peers.beta = { url = "https://beta:1984"; tokenFile = token "beta"; }; }; + } "conflict with peers.enable")) + (expect "peers.settings.peer is rejected next to first-class peers" + (failsWith { + enable = true; + peers = { + enable = true; + settings.peer = [{ name = "legacy"; url = "https://legacy:1984"; token_file = "/run/creds/legacy"; }]; + peers.beta = { url = "https://beta:1984"; tokenFile = token "beta"; }; + }; + } "not settings.peers.peer")) (expect "mixing first-class and freeform peers is rejected" (failsWith { enable = true;