{ pkgs, module }: # Evaluation tests for the peers options of nix/module.nix. They render the # configuration and the unit without building anything, which is why they run # on any machine: `nix eval` only forces the values below. # # nix eval --impure --json --expr ' # let f = builtins.getFlake (toString ./.); in # import ./nix/tests/module-peers.nix { # pkgs = f.inputs.nixpkgs.legacyPackages.x86_64-linux; # module = f.nixosModules.default; # }' # # Every check throws on failure, so a non-zero exit means the module changed # behaviour; the returned list names the checks that ran. let inherit (pkgs) lib; evalWith = settings: (import (pkgs.path + "/nixos/lib/eval-config.nix") { system = "x86_64-linux"; modules = [ module { system.stateVersion = "24.11"; services.skyg-linux-tracker = settings; } ]; }).config; rendered = settings: (evalWith settings).environment.etc."skyg-linux-tracker.toml".source.value; service = settings: (evalWith settings).systemd.services.skyg-linux-tracker; # Only this module's assertions; a bare evalModules has no root filesystem. failedAssertions = settings: map (a: a.message) (builtins.filter (a: !a.assertion && lib.hasPrefix "services.skyg-linux-tracker" a.message) (evalWith settings).assertions); expect = name: condition: if condition then name else throw "module-peers eval test failed: ${name}"; 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 = { enable = true; peers = { enable = true; settings = { tcp_interval_secs = 2; }; peers = { beta = { url = "https://beta:1984"; tokenFile = token "beta"; }; gamma = { url = "http://gamma:1984"; tokenFile = token "gamma"; allowPlainHttp = true; caFile = "/etc/ssl/private-ca.pem"; }; # Declared but switched off: no entry and no credential may be shipped. off = { url = "https://off:1984"; tokenFile = token "off"; enable = false; }; }; }; }; storePath = pkgs.writeText "peer-token" "placeholder"; plain = rendered { enable = true; }; peersCfg = rendered twoPeers; peersService = service twoPeers; tlsOnly = { enable = true; tls = { enable = true; certFile = "/run/agenix/tls-cert"; keyFile = "/run/agenix/tls-key"; }; }; tlsPeersService = service (twoPeers // { tls = { enable = true; certFile = "/run/agenix/tls-cert"; 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 still reloads and restarts on config changes" ((service { enable = true; }).restartTriggers != [ ] && ((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)) (expect "one [[peers.peer]] per enabled peer, sorted" ((map (p: p.name) peersCfg.peers.peer) == [ "beta" "gamma" ])) (expect "a disabled peer is not rendered" (!(lib.any (p: p.name == "off") peersCfg.peers.peer))) (expect "token_file points into the credential directory" (lib.all (p: p.token_file == "${credentialDir}/peer-${p.name}") peersCfg.peers.peer)) (expect "the token path never appears in the config" (!(lib.hasInfix (token "beta") (builtins.toJSON peersCfg)))) (expect "allow_plain_http and ca_file are passed through" ( (let gamma = lib.findFirst (p: p.name == "gamma") null peersCfg.peers.peer; in gamma.allow_plain_http && (gamma.ca_file == "/etc/ssl/private-ca.pem")) && (let beta = lib.findFirst (p: p.name == "beta") null peersCfg.peers.peer; in (beta.allow_plain_http == false) && !(beta ? ca_file)))) (expect "one LoadCredential per enabled peer" (peersService.serviceConfig.LoadCredential == [ "peer-beta:/run/agenix/peer-beta" "peer-gamma:/run/agenix/peer-gamma" ])) (expect "reload refreshes credentials" (peersService.serviceConfig.RefreshOnReload == "credentials")) # `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 != [ ]))) (expect "TLS credentials are unchanged" ((service tlsOnly).serviceConfig.LoadCredential == [ "cert:/run/agenix/tls-cert" "key:/run/agenix/tls-key" ])) (expect "TLS and peers share the credential list" (tlsPeersService.serviceConfig.LoadCredential == [ "cert:/run/agenix/tls-cert" "key:/run/agenix/tls-key" "peer-beta:/run/agenix/peer-beta" "peer-gamma:/run/agenix/peer-gamma" ])) # The pre-F1 freeform style stays valid; nix/tests/peers.nix uses it. (expect "freeform settings.peers still renders" (((rendered { enable = true; settings.peers = { enabled = true; peer = [{ name = "alpha"; url = "http://alpha:1984"; token_file = "/run/creds/alpha"; allow_plain_http = true; }]; }; }).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 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" (failsWith { enable = true; peers = { enable = true; peers."Beta" = { url = "https://beta:1984"; tokenFile = token "beta"; }; }; } "names must match")) (expect "store paths are rejected as tokenFile" (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; settings.peers.peer = [{ name = "legacy"; url = "https://legacy:1984"; token_file = "/run/creds/legacy"; }]; peers = { enable = true; peers.beta = { url = "https://beta:1984"; tokenFile = token "beta"; }; }; } "not settings.peers.peer")) (expect "a valid peer config passes every assertion" (failedAssertions twoPeers == [ ])) ]