diff options
Diffstat (limited to 'tests/scenarios.nix')
| -rw-r--r-- | tests/scenarios.nix | 2156 |
1 files changed, 6 insertions, 2150 deletions
diff --git a/tests/scenarios.nix b/tests/scenarios.nix index 2fc1bd7..ad4617d 100644 --- a/tests/scenarios.nix +++ b/tests/scenarios.nix @@ -1,717 +1,13 @@ -# Test scenarios for populate: every combination of each source type's -# options, deployed to the local machine, to a remote target as root, and to -# a remote target using sudo, plus scenarios for features spanning sources. -# -# A scenario prepares the target directory, then runs its phases. Each phase -# runs populate, or writeDeploy with a stand-in for nixos-rebuild, expecting -# it to succeed or to fail with a message, and checks the result on the -# target. Phases expecting evaluation to fail get checked here and don't run. -{ - # nixpkgs' lib. - lib, - # krops' lib. - krops, - # Function from populate's arguments to the command running populate. - populate, - # krops' writeDeploy. - writeDeploy, - # Where the deploying machine serves /fixtures/www via HTTP. - url, - # URL of the Git repository /fixtures/git/gitsrc.git. - gitUrl, - # Host name of the remote target. - remoteHost, - # Absolute path of age on the deploying machine. - agePath, - # HEAD of /fixtures/gitsrc, and its parent. - gitHead, - gitFirst, - # Version of rsync on the deploying machine. - rsyncVersion, -}: - -let - inherit (lib) - attrNames concatMap concatStringsSep foldl' isBool mapAttrsToList - optional optionalAttrs optionals optionalString; - - prelude = ". ${./lib.sh}\n"; - - cartesian = attrs: foldl' - (acc: name: concatMap - (combination: map - (value: combination // { ${name} = value; }) - attrs.${name}) - acc) - [{}] - (attrNames attrs); - - flagsName = flags: concatStringsSep "-" (mapAttrsToList - (name: value: name + (if isBool value then (if value then "1" else "0") else value)) - flags); - - targets = { - local = path: krops.mkTarget "" // { host = "localhost"; inherit path; }; - remote = path: { - user = "root"; host = remoteHost; port = null; inherit path; - sudo = false; extraOptions = []; - }; - sudo = path: { - user = "deploy"; host = remoteHost; port = null; inherit path; - sudo = true; extraOptions = []; - }; - }; - - alt = { alt.file = "/fixtures/alt"; }; - - # A path on a target of kind targetKind, as populate names it in what it - # prints. - targetName = targetKind: path: { - local = ""; - remote = "${remoteHost}:"; - sudo = "deploy@${remoteHost}:"; - }.${targetKind} + path; - - # How a source draws inputs from other sources: not at all, by rewriting - # the lock file of its flake, or by a generated flake. - inputModes = [ "none" "rewrite" "generated" ]; - - # The options of a source drawing inputs in mode. - drawInputs = mode: inputs: optionalAttrs (mode != "none") ({ - inherit inputs; - } // optionalAttrs (mode == "generated") { - rewriteLock = false; - }); - - # The flake of source x that has its inputs drawn in mode. - flakeOf = mode: - if mode == "generated" then ''"$T"/.populate/flakes/x'' else ''"$T"/x''; - - # Builds a scenario from a name, a target kind, and phases with sources. - # Isolated scenarios start with no target directories and a collected store - # on both machines, so no other scenario's store paths or roots stand in for - # missing ones. An exhaustive scenario covers a combination that no code - # path tells apart from the ones the other scenarios cover, so it only runs - # in the exhaustive tests. - scenario = { - name, targetKind, node ? null, isolate ? false, exhaustive ? false, - prepare ? "", prepareDeployer ? null, phases, - }: let - path = "/var/krops/${name}"; - target = targets.${targetKind} path; - vars = "T=${path}\n"; - # A phase expecting evaluation to fail has a control: sources that - # differ only in what makes evaluation fail, or a function returning them - # for the phase's sources, and that must evaluate. So the phase doesn't - # pass for failing for an unrelated reason, e.g. a misspelt option. - # targetPath deploys to another path than the scenario's target - # directory, and controlTargetPath is the control for a path that makes - # evaluation fail. env sets environment variables for populate, as - # arguments of env. interrupt ends populate after that many seconds, - # which it's expected not to finish before. output lists what a - # succeeding populate is expected to print. - phase = { - sources, backup ? false, prune ? false, deploy ? null, - targetPath ? path, env ? "", interrupt ? null, output ? [], - expect ? "success", control ? null, controlTargetPath ? null, - check ? "", mutate ? null, checkDeployer ? null, mutateDeployer ? null, - }: let - command = sources: targetPath: let - args = { - source = krops.evalSource [ sources ]; - inherit backup prune; - target = target // { path = targetPath; }; - force = true; - }; - in - if deploy == null then populate args - else writeDeploy "deploy" (args // { useNixOutputMonitor = false; } // deploy); - evaluates = sources: targetPath: - (builtins.tryEval - (builtins.seq (toString (command sources targetPath)) true)).success; - script = text: if text == null then null else prelude + vars + text; - in - if expect == "eval-error" then - if control == null && controlTargetPath == null then - throw "scenario ${name}: expecting evaluation to fail needs a control" - else if evaluates sources targetPath then - throw "scenario ${name}: populate evaluates, but is expected to fail" - else if !( - if controlTargetPath != null then evaluates sources controlTargetPath - else evaluates - (if lib.isFunction control then control sources else control) - targetPath - ) then - throw "scenario ${name}: the control doesn't evaluate either" - else - null - else { - populate = toString (command sources targetPath); - inherit env interrupt output; - expect = if expect == "success" then null else expect.fail; - # No phase gets around checking the canaries. - check = script (check + "\ncanary_check\n"); - mutate = script mutate; - checkDeployer = script checkDeployer; - mutateDeployer = script mutateDeployer; - }; - in { - inherit name isolate exhaustive; - node = - if node != null then node - else if targetKind == "local" then "deployer" - else "target"; - prepare = prelude + vars + '' - rm -fR "$T" - '' + prepare; - prepareDeployer = - if prepareDeployer == null then null else prelude + vars + prepareDeployer; - # For all machines: before the scenario, and after it for the ones its - # checks don't run on. - canarySetup = prelude + "canary_setup\n"; - canaryCheck = prelude + "canary_check\n"; - phases = lib.filter (x: x != null) (map phase phases); - }; - - # Same sources twice, so the second phase checks redeploying. - twice = phase: [ phase phase ]; - - targetKinds = [ "local" "remote" "sudo" ]; - - # Scenarios for all combinations of options and target kinds. f gets the - # options and the scenario's name, target kind, and target directory, and - # returns the scenario's arguments, or null for invalid combinations. - matrix = type: options: f: - concatMap - (targetKind: lib.filter (x: x != null) (map - (flags: let - name = "${type}-${targetKind}" + - optionalString (flags != {}) "-${flagsName flags}"; - args = f flags { inherit name targetKind; path = "/var/krops/${name}"; }; - in - if args == null then null - else scenario ({ inherit name targetKind; } // args)) - (cartesian options))) - targetKinds; - - # Checks that the source at $T/x is a link to a store path, or to the - # subdirectory sub therein, or a writable directory if materialized, and - # evaluates the attribute attr of the flake there, or of its generated - # flake, after collecting garbage. - checkFlake = { - attr, expected, subdir ? false, generated ? false, materialized ? false, - }: (if materialized then '' - test -d "$T"/x && ! test -L "$T"/x || fail "x isn't a directory" - test -w "$T"/x/flake.nix || fail "flake.nix isn't writable" - '' else '' - link=$(readlink "$T"/x) - ${if subdir then '' - expect_eq subdirectory "$(basename "$link")" sub - link=$(dirname "$link") - '' else ""} - expect_eq "store directory" "$(dirname "$link")" /nix/store - '') + '' - test ! -e "$T"/.populate/flake-uploads || fail "upload directory remains" - gc - expect_eq ${attr} "$(nix_eval ${ - if generated then ''"$T"/.populate/flakes/x'' else ''"$T"/x'' - }#${attr})" ${lib.escapeShellArg expected} - ''; - - copyingWithSudo = flags: ctx: - ctx.targetKind == "sudo" && !(flags.fetchOnTarget or false); - - # The sources with fetchOnTarget set for all flake and flake-input sources, - # the control for copying flakes to targets using sudo. - withFetchOnTarget = lib.mapAttrs (_: lib.mapAttrs (type: options: - if lib.elem type [ "flake" "flake-input" ] - then options // { fetchOnTarget = true; } - else options)); +# Test scenarios for krops, besides populate's, which run through +# pkgs.populate here: writeDeploy's arguments to nixos-rebuild, which a +# stand-in records. The arguments are those of populate's builder.nix, +# and targets, which give the target of each kind for a path. +{ targets, ... }@args: -in - -# The remote target must not count as local wherever this gets evaluated. -assert !(krops.isLocalTarget (targets.remote "/")); +with import ../pkgs/populate/tests/builder.nix (removeAttrs args [ "targets" ]); { - derivation = matrix "derivation" {} (_: _: { - phases = twice { - sources.x.derivation = '' - derivation { - name = "krops-test"; - system = builtins.currentSystem; - builder = "/bin/sh"; - args = [ "-c" "echo built > $out" ]; - } - ''; - check = '' - gc - expect_eq x "$(cat "$T"/x)" built - ''; - }; - }); - - file = let - f = flags: _: { - # Drawing inputs happens after rsync, so it doesn't depend on rsync's - # options. - exhaustive = flags.inputs != "none" && - (flags.checksum || flags.deleteExcluded || flags.filters); - prepare = '' - mkdir -p "$T"/x - echo old > "$T"/x/skip-ex - echo old > "$T"/x/skip-f - echo stale > "$T"/x/stale - echo BBBB > "$T"/x/same - touch -d @1000000000 "$T"/x/same - ''; - phases = twice { - sources = { - x.file = { - path = "/fixtures/filesrc"; - useChecksum = flags.checksum; - inherit (flags) deleteExcluded; - exclude = optional (flags.exclude or false) "skip-ex"; - filters = optional flags.filters { type = "exclude"; pattern = "skip-f"; }; - } // drawInputs flags.inputs { dep.follows = "alt"; }; - } // optionalAttrs (flags.inputs != "none") alt; - check = let - excluded = file: set: '' - ${if !set then '' - expect_eq ${file} "$(cat "$T"/x/${file})" src - '' else if flags.deleteExcluded then '' - test ! -e "$T"/x/${file} || fail "${file} not deleted" - '' else '' - expect_eq ${file} "$(cat "$T"/x/${file})" old - ''} - ''; - in '' - expect_eq keep "$(cat "$T"/x/keep)" keep - ${excluded "skip-ex" (flags.exclude or false)} - ${excluded "skip-f" flags.filters} - ${if flags.deleteExcluded then '' - test ! -e "$T"/x/stale || fail "stale not deleted" - '' else '' - expect_eq stale "$(cat "$T"/x/stale)" stale - ''} - expect_eq same "$(cat "$T"/x/same)" ${if flags.checksum then "AAAA" else "BBBB"} - '' + optionalString (flags.inputs != "none") '' - # Inputs not drawn from sources aren't delivered, so this needs the - # network and can't collect garbage before. - expect_eq msg "$(nix_eval_online ${flakeOf flags.inputs}#msg)" top:alt,sub - ''; - }; - }; - in - matrix "file" { - checksum = [ false true ]; - deleteExcluded = [ false true ]; - filters = [ false true ]; - inputs = inputModes; - } f - ++ [ - # The deprecated exclude option, once, because it warns. - (scenario (let - args = f { - checksum = false; - deleteExcluded = true; - exclude = true; - filters = false; - inputs = "none"; - } null; - in args // { - name = "file-local-exclude"; - targetKind = "local"; - phases = [ (builtins.head args.phases) ]; - })) - ] - # A source whose .rsync-filter rsync 3.5.0 and later can't read, because - # it's reached through a symlink that neither root nor the user deploying - # owns. (Running as root, the scenarios can't use the other common - # cause, a directory on the way that the user may enter but not read.) - ++ concatMap (targetKind: map (insecureLinks: let - affected = lib.versionAtLeast rsyncVersion "3.5.0"; - excluded = !affected || insecureLinks == true; - in scenario { - name = "file-${targetKind}-insecureLinks" + - (if insecureLinks == null then "Null" else if insecureLinks then "True" else "False"); - inherit targetKind; - prepare = '' - mkdir -p "$T"/x - echo old > "$T"/x/garbage - ''; - phases = twice ({ - sources.x.file = { path = "/fixtures/filtered-link"; inherit insecureLinks; }; - } // (if affected && insecureLinks == null then { - expect.fail = "can't read /fixtures/filtered-link/.rsync-filter, so it would sync /fixtures/filtered-link/ without it."; - } else { - output = optional affected ( - if insecureLinks - then "can't read /fixtures/filtered-link/.rsync-filter; it reads it with --insecure-links anyway, because insecureLinks is true." - else "can't read /fixtures/filtered-link/.rsync-filter, so it syncs /fixtures/filtered-link/ without it, because insecureLinks is false." - ); - check = '' - expect_eq keep "$(cat "$T"/x/keep)" keep - ${if excluded then '' - test ! -e "$T"/x/garbage || fail "garbage not excluded" - '' else '' - expect_eq garbage "$(cat "$T"/x/garbage)" garbage - ''} - ''; - })); - }) [ null true false ]) targetKinds - ++ concatMap (targetKind: let - affected = lib.versionAtLeast rsyncVersion "3.5.0"; - unreadable = name: { path, file, dir ? "x", env ? "" }: scenario { - name = "file-${targetKind}-insecureLinks${name}"; - inherit targetKind; - prepare = '' - mkdir -p "$T"/${dir} - echo old > "$T"/${dir}/garbage - ''; - phases = twice ({ - sources.x.file = { inherit path; }; - inherit env; - } // (if affected then { - expect.fail = "can't read ${file}, so it would sync ${path}/ without it."; - } else { - check = '' - expect_eq keep "$(cat "$T"/${dir}/keep)" keep - test ! -e "$T"/${dir}/garbage || fail "garbage not excluded" - ''; - })); - }; - in [ - # The filter file is in the directory above what gets synced, where it - # applies as well. - (unreadable "Parent" { - path = "/fixtures/filtered-parent-link/sub"; - file = "/fixtures/filtered-parent-link/.rsync-filter"; - }) - # The filter file is in a directory whose name rsync prints escaped - # in the C locale. - (unreadable "Name" { - path = "/fixtures/filtered-name-link"; - file = "/fixtures/filtered-name-link/bär/.rsync-filter"; - dir = "x/bär"; - env = "LC_ALL=C"; - }) - ]) targetKinds; - - flake = matrix "flake" { - kind = [ "git" "path" "subdir" "remote" ]; - fetchOnTarget = [ false true ]; - inputs = inputModes; - materialize = [ false true ]; - } (flags: ctx: let - flake = { - git = "/fixtures/top"; - path = "path:/fixtures/top"; - subdir = "git+file:/fixtures/mono?dir=sub"; - remote = "${url}/remote.tar.gz"; - }.${flags.kind}; - msg = { - git = "top:${if flags.inputs != "none" then "alt" else "dep+inner"},sub"; - path = msg.git; - remote = "remote:${if flags.inputs != "none" then "alt" else "dep+inner"}"; - }; - in - # The flake in a subdirectory has no inputs to draw from sources. - if flags.kind == "subdir" && flags.inputs != "none" then null else { - isolate = true; - # Materializing copies what got delivered, whichever way, so it depends - # on how inputs get drawn and on subdirectories, not on how the flake got - # there. - exhaustive = flags.materialize && !lib.elem flags.kind [ "git" "subdir" ]; - phases = twice ({ - sources = { - x.flake = { - url = flake; - inherit (flags) fetchOnTarget materialize; - } // drawInputs flags.inputs { dep.follows = "alt"; }; - } // optionalAttrs (flags.inputs != "none") alt; - } // (if copyingWithSudo flags ctx then { - expect = "eval-error"; - control = withFetchOnTarget; - } else { - check = if flags.kind == "subdir" then checkFlake { - attr = "who"; expected = "sub"; subdir = true; - materialized = flags.materialize; - } else checkFlake { - attr = "msg"; expected = msg.${flags.kind}; - generated = flags.inputs == "generated"; - materialized = flags.materialize; - }; - })); - }); - - flake-input = concatMap - (name: matrix "flake-input-${lib.replaceStrings ["/"] ["."] name}" ({ - fetchOnTarget = [ false true ]; - materialize = [ false true ]; - } // optionalAttrs (name == "dep") { - inputs = inputModes; - }) (flags: ctx: let - inputs = flags.inputs or "none"; - in { - isolate = true; - # Materializing copies what got delivered, whichever input it is. - exhaustive = flags.materialize && name != "dep"; - phases = twice ({ - sources = { - x.flake-input = { - url = "/fixtures/top"; - inherit name; - inherit (flags) fetchOnTarget materialize; - } // drawInputs inputs { inner.follows = "alt"; }; - } // optionalAttrs (inputs != "none") alt; - } // (if copyingWithSudo flags ctx then { - expect = "eval-error"; - control = withFetchOnTarget; - } else { - check = { - dep = checkFlake { - attr = "greeting"; - expected = if inputs != "none" then "dep+alt" else "dep+inner"; - generated = inputs == "generated"; - materialized = flags.materialize; - }; - "dep/inner" = checkFlake { - attr = "who"; expected = "inner"; materialized = flags.materialize; - }; - sub = checkFlake { - attr = "who"; expected = "sub"; subdir = true; - materialized = flags.materialize; - }; - }.${name}; - })); - })) - [ "dep" "dep/inner" "sub" ]; - - git = matrix "git" { - shallow = [ false true ]; - fetchAlways = [ false true ]; - cleanExclude = [ false true ]; - inputs = inputModes; - } (flags: _: let - check = '' - expect_eq HEAD "$(git -C "$T"/x rev-parse HEAD)" ${gitHead} - expect_eq commits "$(git -C "$T"/x rev-list --count HEAD)" ${ - if flags.shallow then "1" else "2" - } - test -e "$T"/x/two || fail "two missing" - '' + optionalString (flags.inputs == "generated") '' - grep -q '"git+file:' "$T"/.populate/flakes/x/flake.nix || - fail "the Git work tree isn't referred to as git+file:" - '' + optionalString (flags.inputs != "none") '' - gc - expect_eq msg "$(nix_eval ${flakeOf flags.inputs}#msg)" git:alt - ''; - sources = ref: { - x.git = { - url = gitUrl; - inherit ref; - inherit (flags) shallow fetchAlways; - clean.exclude = optional flags.cleanExclude "keepme"; - } // drawInputs flags.inputs { dep.follows = "alt"; }; - } // optionalAttrs (flags.inputs != "none") alt; - in { - # Drawing inputs happens after Git, so it doesn't depend on Git's - # options. - exhaustive = flags.inputs != "none" && - (flags.shallow || flags.fetchAlways || flags.cleanExclude); - phases = [ - # The older commit first, so deploying HEAD changes the work tree, and - # fetches if fetchAlways is set or the clone is shallow. - { - sources = sources gitFirst; - check = '' - expect_eq HEAD "$(git -C "$T"/x rev-parse HEAD)" ${gitFirst} - expect_eq commits "$(git -C "$T"/x rev-list --count HEAD)" 1 - test ! -e "$T"/x/two || fail "two present" - ''; - } - { - sources = sources gitHead; - inherit check; - mutate = '' - echo junk > "$T"/x/junk - echo keepme > "$T"/x/keepme - ''; - } - { - sources = sources gitHead; - check = check + '' - test ! -e "$T"/x/junk || fail "junk not cleaned" - ${if flags.cleanExclude then '' - test -e "$T"/x/keepme || fail "keepme cleaned" - '' else '' - test ! -e "$T"/x/keepme || fail "keepme not cleaned" - ''} - ''; - } - ]; - }) - ++ map (targetKind: scenario (let - # The commit the first phase adds on top of gitHead, deterministic like - # the ones fixtures.sh creates. - gitThird = "c2e0f9d727337617a548284552909abe0f196d05"; - in { - # A full clone fetches a commit that appears on the server afterwards, - # also without fetchAlways. - name = "git-${targetKind}-fetch"; - inherit targetKind; - prepareDeployer = '' - git -C /fixtures/git/gitsrc.git update-ref -d refs/heads/extra - ''; - phases = [ - { - sources.x.git = { url = gitUrl; ref = gitHead; }; - check = '' - expect_eq HEAD "$(git -C "$T"/x rev-parse HEAD)" ${gitHead} - ''; - mutateDeployer = '' - export GIT_AUTHOR_NAME=krops GIT_AUTHOR_EMAIL=spam@krebsco.de - export GIT_COMMITTER_NAME=krops GIT_COMMITTER_EMAIL=spam@krebsco.de - export GIT_AUTHOR_DATE='1000000000 +0000' GIT_COMMITTER_DATE='1000000000 +0000' - export GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_NOSYSTEM=1 - cd /fixtures/gitsrc - git checkout -q -B extra ${gitHead} - echo three > three - git add -A - git commit -q -m three - git push -q -f /fixtures/git/gitsrc.git extra - git checkout -q master - expect_eq "third commit" "$(git rev-parse extra)" ${gitThird} - ''; - } - { - sources.x.git = { url = gitUrl; ref = gitThird; }; - check = '' - expect_eq HEAD "$(git -C "$T"/x rev-parse HEAD)" ${gitThird} - test -e "$T"/x/three || fail "three missing" - ''; - } - ]; - })) targetKinds - # Branches and tags follow the server: a branch that moves between two - # deploys, and a tag, with full and shallow clones. - ++ concatMap (targetKind: map (shallow: scenario { - name = "git-${targetKind}-shallow${if shallow then "1" else "0"}-refs"; - inherit targetKind; - prepareDeployer = '' - git -C /fixtures/git/gitsrc.git update-ref refs/heads/moving ${gitFirst} - git -C /fixtures/git/gitsrc.git update-ref refs/tags/first ${gitFirst} - ''; - phases = [ - { - sources.x.git = { url = gitUrl; ref = "moving"; inherit shallow; }; - check = '' - expect_eq HEAD "$(git -C "$T"/x rev-parse HEAD)" ${gitFirst} - ''; - mutateDeployer = '' - git -C /fixtures/git/gitsrc.git update-ref refs/heads/moving ${gitHead} - ''; - } - { - sources.x.git = { url = gitUrl; ref = "moving"; inherit shallow; }; - check = '' - expect_eq HEAD "$(git -C "$T"/x rev-parse HEAD)" ${gitHead} - ''; - } - { - sources.x.git = { url = gitUrl; ref = "first"; inherit shallow; }; - check = '' - expect_eq HEAD "$(git -C "$T"/x rev-parse HEAD)" ${gitFirst} - ''; - } - ]; - }) [ false true ]) targetKinds - - # A git source stops drawing inputs: its lock file, which Nix created and - # staged, goes, so the work tree is as the commit has it. - ++ map (targetKind: scenario { - name = "git-${targetKind}-dropInputs"; - inherit targetKind; - phases = [ - { - sources = alt // { - x.git = { url = gitUrl; ref = gitHead; inputs.dep.follows = "alt"; }; - }; - check = '' - expect_eq msg "$(nix_eval_online git+file:"$T"/x#msg)" git:alt - ''; - } - { - sources = alt // { x.git = { url = gitUrl; ref = gitHead; }; }; - check = '' - expect_eq status "$(git -C "$T"/x status --porcelain)" "" - ''; - } - ]; - }) targetKinds; - - pass = matrix "pass" { - store = [ "pass" "pass-git" ]; - } (flags: _: { - phases = twice { - sources.x.pass = { dir = "/fixtures/${flags.store}"; name = "x"; }; - check = '' - expect_eq a "$(cat "$T"/x/a)" secret-a - ''; - }; - }); - - passage = matrix "passage" { - age = [ "default" "path" ]; - dir = [ "store" "subdir" ]; - } (flags: _: { - phases = twice { - sources.x.passage = { - dir = "/fixtures/passage/store" + optionalString (flags.dir == "subdir") "/x"; - identities_file = "/fixtures/passage/identities"; - } // optionalAttrs (flags.age == "path") { - age = agePath; - }; - check = '' - expect_eq a "$(cat "$T"/x/${optionalString (flags.dir == "store") "x/"}a)" secret-a - ''; - }; - }); - - pipe = matrix "pipe" {} (_: _: { - phases = twice { - sources.x.pipe = "/fixtures/pipe"; - check = '' - expect_eq x "$(cat "$T"/x)" piped - ''; - }; - }); - - symlink = matrix "symlink" { - absolute = [ false true ]; - inputs = [ false true ]; - } (flags: ctx: let - target = optionalString flags.absolute "${ctx.path}/" + "topcopy"; - in { - phases = twice { - sources = { - x.symlink = { - inherit target; - inputs = optionalAttrs flags.inputs { dep.follows = "alt"; }; - }; - topcopy.file = "/fixtures/filesrc"; - } // optionalAttrs flags.inputs alt; - check = '' - expect_eq link "$(readlink "$T"/x)" ${target} - test -e "$T"/x/flake.nix || fail "flake.nix missing" - '' + optionalString flags.inputs '' - expect_eq msg "$(nix_eval_online "$T"/.populate/flakes/x#msg)" top:alt,sub - ''; - }; - }); - # writeDeploy's arguments to nixos-rebuild, which a stand-in records. # flake is what gets deployed: nothing, or a flake from a file, git, or # flake source, or one whose inputs get drawn from a source, by rewriting @@ -809,1444 +105,4 @@ assert !(krops.isLocalTarget (targets.remote "/")); }]; }) targetKinds; - # Features spanning several sources. - features = concatMap (targetKind: let - s = name: args: scenario ({ - name = "${name}-${targetKind}"; - inherit targetKind; - isolate = true; - } // args); - copying = targetKind != "sudo"; - fetchOnTarget = !copying; - # A scenario for each way of drawing inputs, which f gets as mode, along - # with draw, which adds inputs drawn that way to a source's options, and - # flake, which gives the flake to evaluate for a source. - modes = name: f: map - (mode: s "${name}-${mode}" (f { - draw = drawInputs mode; - flake = n: - if mode == "generated" then ''"$T"/.populate/flakes/${n}'' else ''"$T"/${n}''; - inherit mode; - })) - [ "rewrite" "generated" ]; - in lib.flatten [ - # A source draws an input from a source that draws inputs itself. - (modes "chain" ({ draw, flake, ... }: { - phases = twice { - sources = alt // { - a.flake = { url = "/fixtures/top"; inherit fetchOnTarget; } // draw { dep.follows = "b"; }; - b.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - } // draw { inner.follows = "alt"; }; - }; - check = '' - gc - expect_eq msg "$(nix_eval ${flake "a"}#msg)" top:dep+alt,sub - ''; - }; - })) - # An input of an input drawn from a source gets drawn from another - # source. - (modes "nested" ({ draw, flake, ... }: { - phases = twice { - sources = alt // { - x.flake = { - url = "/fixtures/top"; inherit fetchOnTarget; - } // draw { dep = { follows = "b"; inputs.inner.follows = "alt"; }; }; - b.flake-input = { url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; }; - }; - check = '' - gc - expect_eq msg "$(nix_eval ${flake "x"}#msg)" top:dep+alt,sub - ''; - }; - })) - # The lock file gets rewritten or generated again when a source inputs - # get drawn from changes. - (modes "relock" ({ draw, flake, ... }: let - x.file = { path = "/fixtures/filesrc"; } // draw { dep.follows = "a"; }; - in { - phases = [ - { - sources = { inherit x; a.file = "/fixtures/alt"; }; - check = '' - expect_eq msg "$(nix_eval_online ${flake "x"}#msg)" top:alt,sub - ''; - } - { - sources = { inherit x; a.file = "/fixtures/alt2"; }; - check = '' - expect_eq msg "$(nix_eval_online ${flake "x"}#msg)" top:alt2,sub - ''; - } - ]; - })) - # What drawing inputs needs gets removed once a source draws no inputs - # anymore. - (modes "removal" ({ draw, mode, ... }: let - state = { - rewrite = "derived/x/result"; - generated = "flakes/x/flake.lock"; - }.${mode}; - in { - phases = [ - { - sources = alt // { - x.flake = { url = "/fixtures/top"; inherit fetchOnTarget; } // draw { dep.follows = "alt"; }; - }; - check = '' - test -e "$T"/.populate/${state} || fail "${state} missing" - ''; - } - { - sources = alt // { - x.flake = { url = "/fixtures/top"; inherit fetchOnTarget; }; - }; - check = '' - test ! -e "$T"/.populate/${dirOf state} || fail "${dirOf state} remains" - '' + checkFlake { attr = "msg"; expected = "top:dep+inner,sub"; }; - } - ]; - })) - # Patches get applied in order to a copy, which becomes a store path and - # gets made again only when the patches change. - (s "patches" (let - x = patches: { - x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget patches; - }; - }; - both = x [ "/fixtures/patches/hello.patch" "/fixtures/patches/hello2.patch" ]; - in { - phases = [ - { - sources = both; - check = checkFlake { attr = "greeting"; expected = "hello2+inner"; }; - # The key changes whenever the copy gets made again, which - # the store path doesn't show, being the same. - mutate = '' - readlink "$T"/x > "$T".first - stat -c %y "$T"/.populate/derived/x/key > "$T".key - ''; - } - { - sources = both; - check = checkFlake { attr = "greeting"; expected = "hello2+inner"; } + '' - expect_eq "store path" "$(readlink "$T"/x)" "$(cat "$T".first)" - expect_eq "copy made at" "$(stat -c %y "$T"/.populate/derived/x/key)" "$(cat "$T".key)" - ''; - } - { - sources = x [ "/fixtures/patches/hello.patch" ]; - check = checkFlake { attr = "greeting"; expected = "hello+inner"; } + '' - test "$(readlink "$T"/x)" != "$(cat "$T".first)" || fail "store path unchanged" - expect_eq patches "$(ls "$T"/.populate/patches/x)" 0001-hello.patch - ''; - } - { - sources = x []; - check = checkFlake { attr = "greeting"; expected = "dep+inner"; } + '' - test ! -e "$T"/.populate/patches || fail "patches remain" - test ! -e "$T"/.populate/derived || fail "derived remains" - ''; - } - ]; - })) - (s "patch-fails" { - phases = [{ - sources.x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - patches = [ "/fixtures/patches/bad.patch" ]; - }; - expect.fail = "error: patch bad.patch does not apply to source x"; - }]; - }) - # Patches apply in the subdirectory the target path shows. - (s "patch-subdir" { - phases = twice { - sources.x.flake-input = { - url = "/fixtures/top"; name = "sub"; inherit fetchOnTarget; - patches = [ "/fixtures/patches/sub.patch" ]; - }; - check = checkFlake { attr = "who"; expected = "patched"; subdir = true; }; - }; - }) - # A copy with a rewritten lock file gets made again only when a source - # it draws inputs from changes. - (s "rewrite-cache" (let - x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - inputs.inner.follows = "a"; - }; - in { - phases = [ - { - sources = { inherit x; a.file = "/fixtures/alt"; }; - check = checkFlake { attr = "greeting"; expected = "dep+alt"; }; - # The key changes whenever the copy gets made again, which - # the store path doesn't show, being the same. - mutate = '' - readlink "$T"/x > "$T".first - stat -c %y "$T"/.populate/derived/x/key > "$T".key - ''; - } - { - sources = { inherit x; a.file = "/fixtures/alt"; }; - check = checkFlake { attr = "greeting"; expected = "dep+alt"; } + '' - expect_eq "store path" "$(readlink "$T"/x)" "$(cat "$T".first)" - expect_eq "copy made at" "$(stat -c %y "$T"/.populate/derived/x/key)" "$(cat "$T".key)" - ''; - } - { - sources = { inherit x; a.file = "/fixtures/alt2"; }; - check = checkFlake { attr = "greeting"; expected = "dep+alt2"; } + '' - test "$(readlink "$T"/x)" != "$(cat "$T".first)" || fail "store path unchanged" - ''; - } - ]; - })) - # A materialized input is a writable copy, patched and with a rewritten - # lock file, which gets made again only when what it derives from - # changes, and becomes a link again when not materialized anymore. - (s "materialize" (let - x = patches: alt // { - x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget patches; - materialize = true; - inputs.inner.follows = "alt"; - }; - }; - hello = [ "/fixtures/patches/hello.patch" ]; - in { - phases = [ - { - sources = x hello; - check = '' - test ! -L "$T"/x || fail "x is a link" - test -w "$T"/x/flake.nix || fail "flake.nix isn't writable" - gc - expect_eq greeting "$(nix_eval "$T"/x#greeting)" hello+alt - ''; - mutate = '' - echo local > "$T"/x/local - ''; - } - { - sources = x hello; - check = '' - expect_eq local "$(cat "$T"/x/local)" local - ''; - } - { - sources = x (hello ++ [ "/fixtures/patches/hello2.patch" ]); - check = '' - test ! -e "$T"/x/local || fail "local remains" - gc - expect_eq greeting "$(nix_eval "$T"/x#greeting)" hello2+alt - ''; - } - { - sources = alt // { - x.flake-input = { url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; }; - }; - check = checkFlake { attr = "greeting"; expected = "dep+inner"; } + '' - test ! -e "$T"/.populate/derived || fail "derived remains" - ''; - } - ]; - })) - # Roots follow the delivered input. - (s "retarget" { - phases = [ - { - sources.x.flake-input = { url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; }; - check = '' - expect_eq roots "$(ls "$T"/.populate/flake-inputs/x | wc -l)" 1 - ''; - } - { - sources.x.flake-input = { url = "/fixtures/top"; name = "sub"; inherit fetchOnTarget; }; - check = '' - test ! -e "$T"/.populate/flake-inputs/x || fail "roots remain" - test ! -e "$T"/.populate/flake-inputs || fail "empty roots directory remains" - '' + checkFlake { attr = "who"; expected = "sub"; subdir = true; }; - } - ]; - }) - # Pruning removes everything sources don't deliver anymore, including - # garbage collector roots, and keeps everything else. - (s "prune" (let - sources = { - a.file = "/fixtures/alt"; - b.flake = { url = "/fixtures/top"; inherit fetchOnTarget; }; - c.flake-input = { url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; }; - d.symlink = "a"; - }; - in { - prepare = '' - mkdir -p "$T" - echo other > "$T"/other - ''; - phases = [ - { - inherit sources; - check = '' - test -e "$T"/.populate/flake-inputs/b || fail "roots of b missing" - test -e "$T"/.populate/flake-inputs/c || fail "roots of c missing" - ''; - } - { - # Without pruning, nothing gets removed. - sources = { inherit (sources) a; }; - check = '' - for name in b c d other .populate/flake-inputs/b .populate/flake-inputs/c; do - test -e "$T"/$name || fail "$name removed" - done - ''; - # An upload an interrupted run left behind. - mutate = '' - mkdir -p "$T"/.populate/flake-uploads/c/tree - ''; - } - { - # b changes its type, so its roots go, while b stays. - sources = { inherit (sources) a; b.symlink = "a"; }; - prune = true; - output = map - (name: "pruning '${targetName targetKind "/var/krops/prune-${targetKind}/${name}"}'...") - [ "c" "d" "other" ]; - check = '' - test -e "$T"/a/flake.nix || fail "a removed" - expect_eq b "$(readlink "$T"/b)" a - test -d "$T"/.populate || fail ".populate removed" - for name in c d other .populate/flake-inputs .populate/flake-uploads; do - test ! -e "$T"/$name || fail "$name not pruned" - done - if nix-store --gc --print-roots 2>/dev/null | grep -F "$T/"; then - fail "garbage collector roots remain" - fi - ''; - } - ]; - })) - (s "cycle" { - phases = [{ - sources = { - a.file = { path = "/fixtures/alt"; inputs.foo.follows = "b"; }; - b.file = { path = "/fixtures/alt"; inputs.foo.follows = "a"; }; - }; - expect = "eval-error"; - control = { - a.file = { path = "/fixtures/alt"; inputs.foo.follows = "b"; }; - b.file = "/fixtures/alt"; - }; - }]; - }) - (s "self" { - phases = [{ - sources.a.file = { path = "/fixtures/alt"; inputs.foo.follows = "a"; }; - expect = "eval-error"; - control = alt // { - a.file = { path = "/fixtures/alt"; inputs.foo.follows = "alt"; }; - }; - }]; - }) - (s "missing" { - phases = [{ - sources.a.file = { path = "/fixtures/alt"; inputs.foo.follows = "nope"; }; - expect = "eval-error"; - control = { - a.file = { path = "/fixtures/alt"; inputs.foo.follows = "nope"; }; - nope.file = "/fixtures/alt"; - }; - }]; - }) - (s "noflake" { - phases = [{ - sources = alt // { - x.file = { path = "/fixtures/noflake"; inputs.foo.follows = "alt"; }; - }; - expect.fail = "error: source x draws flake inputs from other sources, but contains no flake.nix"; - }]; - }) - (s "noinput" { - phases = [{ - sources.x.flake-input = { url = "/fixtures/top"; name = "nope"; inherit fetchOnTarget; }; - expect.fail = "error: flake /fixtures/top has no input nope"; - }]; - }) - # An input locked to a path the target doesn't have. - (s "gone" { - phases = [{ - sources.x.flake = { url = "/fixtures/usegone"; fetchOnTarget = true; }; - expect.fail = "error: flake /fixtures/usegone: input gone refers to /fixtures/gone, which does not exist on the target"; - }]; - }) - ]) targetKinds; - - # Edge cases of the flake source types and of generated flakes: unusual lock - # files, references, and changes between deploys. - edge-cases = concatMap (targetKind: let - s = name: args: scenario ({ - name = "${name}-${targetKind}"; - inherit targetKind; - isolate = true; - } // args); - copying = targetKind != "sudo"; - fetchOnTarget = !copying; - roots = n: '' - expect_eq roots "$(ls "$T"/.populate/flake-inputs/x 2>/dev/null | wc -l)" ${toString n} - ''; - # A scenario for each way of drawing inputs, which f gets as mode, along - # with draw, which adds inputs drawn that way to a source's options, and - # flake, which gives the flake to evaluate for a source. - modes = name: f: map - (mode: s "${name}-${mode}" (f { - draw = drawInputs mode; - flake = n: - if mode == "generated" then ''"$T"/.populate/flakes/${n}'' else ''"$T"/${n}''; - inherit mode; - })) - [ "rewrite" "generated" ]; - in lib.flatten [ - # The registry entry kropsremote, which fixtures.sh adds on the deploying - # machine, points at ${url}/remote.tar.gz. The deploying machine has no - # global registry, which it couldn't download. - (s "indirect" { - phases = twice { - sources.x.flake = { url = "kropsremote"; inherit fetchOnTarget; }; - check = checkFlake { attr = "msg"; expected = "remote:dep+inner"; }; - }; - }) - (s "remote-subdir" { - phases = twice { - sources.x.flake = { url = "${url}/mono.tar.gz?dir=sub"; inherit fetchOnTarget; }; - check = checkFlake { attr = "who"; expected = "sub"; subdir = true; }; - }; - }) - (modes "subdir-inputs" ({ draw, mode, ... }: { - phases = twice { - sources = alt // { - x.flake = { - url = "git+file:/fixtures/monoin?dir=sub"; inherit fetchOnTarget; - } // draw { dep.follows = "alt"; }; - }; - check = checkFlake { - attr = "msg"; expected = "monoin:alt"; subdir = true; - generated = mode == "generated"; - }; - }; - })) - (s "dirty" { - phases = twice { - sources.x.flake = { url = "/fixtures/dirty"; inherit fetchOnTarget; }; - check = checkFlake { attr = "msg"; expected = "dirty:dep+inner,sub"; } + '' - test ! -e "$T"/x/untracked || fail "untracked file delivered" - ''; - }; - }) - (s "unlocked" { - phases = [{ - sources.x.flake = { url = "/fixtures/unlocked"; inherit fetchOnTarget; }; - expect.fail = "requires lock file changes"; - }]; - }) - (s "notdir" { - phases = [{ - sources = { - x.file = { path = "/fixtures/filesrc"; inputs.dep.follows = "p"; }; - p.pipe = "/fixtures/pipe"; - }; - expect.fail = "error: source p is not a directory"; - }]; - }) - (s "noinput-nested" { - phases = [{ - sources.x.flake-input = { url = "/fixtures/top"; name = "dep/nope"; inherit fetchOnTarget; }; - expect.fail = "error: flake /fixtures/top has no input dep/nope"; - }]; - }) - (s "shared" { - phases = twice { - sources = { - x.flake = { url = "/fixtures/top"; inherit fetchOnTarget; }; - dep.flake-input = { url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; }; - sub.flake-input = { url = "/fixtures/top"; name = "sub"; fetchOnTarget = true; }; - }; - check = checkFlake { attr = "msg"; expected = "top:dep+inner,sub"; } + '' - expect_eq dep "$(nix_eval "$T"/dep#greeting)" dep+inner - expect_eq sub "$(nix_eval "$T"/sub#who)" sub - ''; - }; - }) - (s "follows-empty" { - phases = twice { - sources.x.flake = { url = "/fixtures/nofollow"; fetchOnTarget = true; }; - check = checkFlake { attr = "msg"; expected = "nofollow"; }; - }; - }) - (s "follows-cycle" { - phases = twice { - sources.x.flake = { url = "/fixtures/cyc"; fetchOnTarget = true; }; - check = checkFlake { attr = "msg"; expected = "cyc:cyca,cycb"; }; - }; - }) - # Names resolve through the parent's lock file, so dep/inner is the - # parent's inner, which dep's inner follows. - (s "follows-name" { - phases = twice { - sources.x.flake-input = { url = "/fixtures/follow"; name = "dep/inner"; inherit fetchOnTarget; }; - check = checkFlake { attr = "who"; expected = "inner2"; }; - }; - }) - # The delivered input comes with the inputs its own lock file pins, which - # evaluating it needs, not with the parent's inner, which it follows there. - (s "follows-closure" { - phases = twice { - sources.x.flake-input = { url = "/fixtures/follow"; name = "dep"; inherit fetchOnTarget; }; - check = checkFlake { attr = "greeting"; expected = "dep+inner"; } + roots 1; - }; - }) - (s "relative-input" { - phases = twice { - sources.x.flake = { url = "/fixtures/rel"; fetchOnTarget = true; }; - check = checkFlake { attr = "msg"; expected = "rel:lib"; }; - }; - }) - # The target can't fetch an input of the flake. The deploying machine - # fetched it when locking, so its fetcher cache has to go. - (s "fetch-failure" { - prepareDeployer = '' - rm -fR /root/.cache/nix - ''; - phases = [{ - sources.x.flake = { url = "/fixtures/broken"; fetchOnTarget = true; }; - expect.fail = "vanishing.tar.gz"; - }]; - }) - # The delivered input itself is locked to a path the target lacks. - (s "gone-input" { - phases = [{ - sources.x.flake-input = { url = "/fixtures/usegone"; name = "gone"; fetchOnTarget = true; }; - expect.fail = "input gone refers to /fixtures/gone, which does not exist on the target"; - }]; - }) - # An input that gets drawn from a source isn't needed on the target, with - # all it pins. - (modes "overridden-roots" ({ draw, mode, ... }: { - # What gets delivered doesn't depend on how inputs get drawn. - exhaustive = mode == "generated"; - phases = twice { - sources = alt // { - x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - } // draw { inner.follows = "alt"; }; - }; - check = checkFlake { - attr = "greeting"; expected = "dep+alt"; - generated = mode == "generated"; - } + roots 0; - }; - })) - # The input's own lock file pins something unreachable, which gets drawn - # from a source anyway. - (modes "own-lock-unreachable" ({ draw, mode, ... }: { - # What gets delivered doesn't depend on how inputs get drawn. - exhaustive = mode == "generated"; - prepareDeployer = '' - rm -fR /root/.cache/nix - ''; - phases = twice { - sources = alt // { - x.flake-input = { - url = "/fixtures/usepinned"; name = "dep"; inherit fetchOnTarget; - } // draw { inner.follows = "alt"; }; - }; - check = checkFlake { - attr = "greeting"; expected = "pinned+alt"; - generated = mode == "generated"; - }; - }; - })) - # The input's own lock file pins something unreachable, or lacks an input - # its flake.nix has. That fails, unless the input isn't required to come - # with its inputs. - (s "own-lock-broken" (let - x = url: requireInputs: { - x.flake-input = { inherit url; name = "dep"; inherit fetchOnTarget requireInputs; }; - }; - delivered = '' - test -e "$T"/x/flake.nix || fail "input not delivered" - ''; - in { - prepareDeployer = '' - rm -fR /root/.cache/nix - ''; - phases = [ - { - sources = x "/fixtures/usepinned" true; - expect.fail = "error: source x: the inputs its own lock file pins can't be delivered. Set its requireInputs to false to deliver it anyway."; - } - { - sources = x "/fixtures/usepinned" false; - check = delivered + roots 0; - } - { - sources = x "/fixtures/usestale" true; - expect.fail = "error: source x: the inputs its own lock file pins can't be delivered. Set its requireInputs to false to deliver it anyway."; - } - { - sources = x "/fixtures/usestale" false; - check = delivered + roots 2; - } - { - sources = x "/fixtures/usestale" false; - check = delivered + roots 2; - } - ]; - })) - # Redeploying an unchanged input while where it comes from is - # unreachable and the fetcher caches are gone: the store has it. - (s "offline-redeploy" (let - sources.x.flake-input = { url = "/fixtures/offline"; name = "gap"; inherit fetchOnTarget; }; - check = checkFlake { attr = "who"; expected = "gap"; }; - in { - prepareDeployer = '' - if test -e /fixtures/www/gap.tar.gz.off; then - mv /fixtures/www/gap.tar.gz.off /fixtures/www/gap.tar.gz - fi - ''; - phases = [ - { - inherit sources check; - mutate = '' - rm -fR /root/.cache/nix - ''; - mutateDeployer = '' - rm -fR /root/.cache/nix - mv /fixtures/www/gap.tar.gz /fixtures/www/gap.tar.gz.off - ''; - } - { - inherit sources check; - mutateDeployer = '' - mv /fixtures/www/gap.tar.gz.off /fixtures/www/gap.tar.gz - ''; - } - ]; - })) - (s "flake-to-file" { - phases = [ - { - sources.x.flake = { url = "/fixtures/top"; inherit fetchOnTarget; }; - check = roots 3; - mutate = '' - readlink "$T"/x > "$T"/old - ''; - } - { - sources.x.file = "/fixtures/alt"; - check = '' - test ! -L "$T"/x || fail "x is still a link to $(readlink "$T"/x)" - test -e "$T"/x/flake.nix || fail "flake.nix missing" - nix-store --verify-path "$(cat "$T"/old)" || fail "store path changed" - '' + roots 0; - } - ]; - }) - (s "symlink-to-flake" { - phases = [ - { - sources = alt // { x.symlink = "alt"; }; - check = '' - expect_eq link "$(readlink "$T"/x)" alt - ''; - } - { - sources = alt // { x.flake = { url = "/fixtures/top"; inherit fetchOnTarget; }; }; - check = checkFlake { attr = "msg"; expected = "top:dep+inner,sub"; } + '' - test -e "$T"/alt/flake.nix || fail "alt changed" - ''; - } - ]; - }) - # The ssh master stops, after failing as well as after succeeding. - (s "ssh-master" (let - checkDeployer = '' - for i in 1 2 3 4 5 6 7 8 9 10; do - if ! pgrep -f 'ssh: .*/populate\..*\[mux\]' >/dev/null; then - exit 0 - fi - sleep 0.5 - done - fail "ssh master remains" - ''; - in { - phases = [ - { - sources.x.flake-input = { url = "/fixtures/top"; name = "nope"; inherit fetchOnTarget; }; - expect.fail = "error: flake /fixtures/top has no input nope"; - inherit checkDeployer; - } - { - sources = alt; - inherit checkDeployer; - } - ]; - })) - # Pruning entries whose names a shell's read would strip or split. - (s "prune-names" { - prepare = '' - mkdir -p "$T/ lead" "$T/trail " "$T/$(printf 'new\nline')" "$T/axb" "$T/[b]" - ''; - phases = [{ - sources = alt; - prune = true; - check = '' - # In the C locale, ls sorts by bytes, so . comes first. - expect_eq entries "$(LC_ALL=C ls -A "$T" | tr '\n' ' ')" '.populate alt ' - ''; - }]; - }) - # Misspelt input names draw nothing, so they fail before anything - # changes: of the source's flake, and below an input drawn from a source. - (modes "inputs-typo" ({ draw, ... }: { - phases = [ - { - sources = alt // { - x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - } // draw { innr.follows = "alt"; }; - }; - expect.fail = "error: source x draws input innr from source alt, but its flake has no input innr"; - } - { - sources = { - x.flake = { - url = "/fixtures/top"; inherit fetchOnTarget; - } // draw { dep = { follows = "b"; inputs.qq.follows = "c2"; }; }; - b.file = "/fixtures/two"; - c2.file = "/fixtures/c2"; - }; - expect.fail = "error: source x draws input dep/qq from source c2, but the flake of source b has no input qq"; - } - ]; - })) - # A signal ending populate leaves neither the ssh master nor the - # temporary directory. - (s "interrupt" { - prepareDeployer = '' - find "''${TMPDIR:-/tmp}" -maxdepth 1 -name 'populate.*' -exec rm -fR {} + - ''; - phases = [{ - sources.x.pipe = "/fixtures/pipe-slow"; - interrupt = 3; - checkDeployer = '' - for i in 1 2 3 4 5 6 7 8 9 10; do - if ! pgrep -f 'ssh: .*/populate\..*\[mux\]' >/dev/null; then - break - fi - sleep 0.5 - done - ! pgrep -f 'ssh: .*/populate\..*\[mux\]' >/dev/null || - fail "ssh master remains" - expect_eq "temporary directories" \ - "$(find "''${TMPDIR:-/tmp}" -maxdepth 1 -name 'populate.*')" "" - ''; - }]; - }) - # An input of an input drawn from a source that draws inputs itself - # gets drawn from another source. - (modes "override" ({ draw, flake, ... }: { - # Drawing inputs happens on the target alike for every kind of target. - exhaustive = targetKind != "local"; - phases = twice { - sources = { - x.flake = { - url = "/fixtures/top"; inherit fetchOnTarget; - } // draw { dep = { follows = "b"; inputs.q.follows = "c2"; }; }; - b.file = { path = "/fixtures/two"; } // draw { p.follows = "c1"; }; - c1.file = "/fixtures/c1"; - c2.file = "/fixtures/c2"; - }; - check = '' - expect_eq msg "$(nix_eval_online ${flake "x"}#msg)" top:two:c1+c2,sub - ''; - }; - })) - # The same one level deeper: the input gets drawn from a source below - # an input that the source in between draws from a source itself. - (modes "override-deep" ({ draw, flake, ... }: { - # Drawing inputs happens on the target alike for every kind of target. - exhaustive = targetKind != "local"; - phases = twice { - sources = { - x.flake = { - url = "/fixtures/top"; inherit fetchOnTarget; - } // draw { dep = { follows = "b"; inputs.p.inputs.z.follows = "c2"; }; }; - b.file = { path = "/fixtures/two"; } // draw { p.follows = "c3"; }; - c2.file = "/fixtures/c2"; - c3.file = "/fixtures/c3"; - }; - check = '' - expect_eq msg "$(nix_eval_online ${flake "x"}#msg)" 'top:two:c3(c2)+inner,sub' - ''; - }; - })) - # A source with a rewritten lock file draws an input from a source with - # a generated flake, and an input below it from another source. - (s "override-mixed" { - # Drawing inputs happens on the target alike for every kind of target. - exhaustive = targetKind != "local"; - phases = twice { - sources = { - x.flake = { - url = "/fixtures/top"; inherit fetchOnTarget; - inputs.dep = { follows = "b"; inputs.q.follows = "c2"; }; - }; - b.file = { - path = "/fixtures/two"; - rewriteLock = false; - inputs.p.follows = "c1"; - }; - c1.file = "/fixtures/c1"; - c2.file = "/fixtures/c2"; - }; - check = '' - expect_eq msg "$(nix_eval_online "$T"/x#msg)" top:two:c1+c2,sub - ''; - }; - }) - (modes "nonflake-input" ({ draw, flake, ... }: { - # Drawing inputs happens on the target alike for every kind of target. - exhaustive = targetKind != "local"; - phases = twice { - sources = { - x.file = { path = "/fixtures/usedata"; } // draw { data.follows = "data"; }; - data.file = "/fixtures/data"; - }; - check = '' - expect_eq msg "$(nix_eval ${flake "x"}#msg)" data:hello - ''; - }; - })) - # The target directory in a Git work tree. - (modes "gitdir" ({ draw, flake, ... }: { - prepare = '' - mkdir -p "$T" - git -C "$T" init -q - ''; - phases = twice { - sources = alt // { - x.file = { path = "/fixtures/filesrc"; } // draw { dep.follows = "alt"; }; - }; - check = '' - # Not just the path, which Nix takes for the enclosing work tree. - expect_eq msg "$(nix_eval_online path:${flake "x"}#msg)" top:alt,sub - ''; - }; - })) - # Output of the same length, which rsync's quick check doesn't notice. - (s "pipe-change" { - prepareDeployer = '' - echo piped > /fixtures/pipe2-data - ''; - phases = [ - { - sources.x.pipe = "/fixtures/pipe2"; - check = '' - expect_eq x "$(cat "$T"/x)" piped - ''; - mutateDeployer = '' - echo PIPED > /fixtures/pipe2-data - ''; - } - { - sources.x.pipe = "/fixtures/pipe2"; - check = '' - expect_eq x "$(cat "$T"/x)" PIPED - ''; - mutateDeployer = '' - echo piped > /fixtures/pipe2-data - ''; - } - ]; - }) - # Source names that aren't input names, or that Nix has another use - # for, both of sources inputs get drawn from and of sources drawing them. - (modes "source-name" ({ draw, flake, ... }: let - x = from: { path = "/fixtures/filesrc"; } // draw { dep.follows = from; }; - in { - # Drawing inputs happens on the target alike for every kind of target. - exhaustive = targetKind != "local"; - phases = twice { - sources = { - "alt-1.0".file = "/fixtures/alt"; - self.file = "/fixtures/alt"; - x.file = x "alt-1.0"; - y.file = x "self"; - "a.b_c-d".file = x "self"; - }; - check = '' - expect_eq x "$(nix_eval_online ${flake "x"}#msg)" top:alt,sub - expect_eq y "$(nix_eval_online ${flake "y"}#msg)" top:alt,sub - expect_eq a.b_c-d "$(nix_eval_online ${flake "a.b_c-d"}#msg)" top:alt,sub - ''; - }; - })) - # An upload an interrupted run left behind. - (s "upload-leftover" { - phases = [ - { - sources.x.flake = { url = "/fixtures/top"; fetchOnTarget = true; }; - check = checkFlake { attr = "msg"; expected = "top:dep+inner,sub"; }; - mutate = '' - mkdir -p "$T"/.populate/flake-uploads/x/tree - echo half > "$T"/.populate/flake-uploads/x/tree/half - ''; - } - { - sources.x.flake = { url = "/fixtures/top"; fetchOnTarget = true; }; - check = checkFlake { attr = "msg"; expected = "top:dep+inner,sub"; }; - } - ]; - }) - ] ++ lib.optional (targetKind == "local") - # The target has the path the input is locked to. - (s "uselocal" { - phases = twice { - sources.x.flake = { url = "/fixtures/uselocal"; fetchOnTarget = true; }; - check = checkFlake { attr = "msg"; expected = "uselocal:alt"; }; - }; - }) - ) targetKinds; - - - # Populate replaces and removes things in the target directory. These - # scenarios check that it doesn't anywhere else: names and paths that lead - # out of the target directory don't evaluate, and symlinks in it get - # replaced or refused instead of followed. The canaries, which every phase - # of every scenario checks, tell if something outside changed; these - # scenarios point links at them. - safety = concatMap (targetKind: let - s = name: args: scenario ({ - name = "${name}-${targetKind}"; - inherit targetKind; - } // args); - copying = targetKind != "sudo"; - fetchOnTarget = !copying; - outside = "/var/krops-outside"; - hello = [ "/fixtures/patches/hello.patch" ]; - # Sources that use every kind of state populate keeps: x a copy with - # patches, y garbage collector roots and, where the flake gets uploaded, - # an upload, and z a generated flake. - stateful = alt // { - x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - patches = hello; - inputs.inner.follows = "alt"; - }; - y.flake = { url = "/fixtures/top"; inherit fetchOnTarget; }; - z.file = { - path = "/fixtures/filesrc"; - rewriteLock = false; - inputs.dep.follows = "alt"; - }; - }; - # A source deployed where a symlink to something outside is. The link - # gets replaced, never followed. - link = type: { sources, to, check, says ? true }: let - phase = { - inherit sources; - check = '' - case $(readlink "$T"/x || :) in - ${outside}/*) fail "x still links outside" ;; - esac - '' + check; - }; - in s "link-${type}" { - isolate = true; - prepare = '' - mkdir -p "$T" - ln -s ${outside}/${to} "$T"/x - ''; - phases = [ - (phase // { - output = optional says - "replacing symlink '${targetName targetKind "/var/krops/link-${type}-${targetKind}/x"}', which points to '${outside}/${to}'..."; - }) - phase - ]; - }; - # Something of populate's state replaced by a symlink to outside between - # two deploys. The second one refuses to use it. - state = name: { - entry, backup ? false, - message ? "/${entry} is a symlink, but populate needs a directory of its own there", - }: s "state-${name}" { - isolate = true; - phases = [ - { - sources = stateful; - inherit backup; - mutate = '' - rm -fR "$T"/${entry} - mkdir -p "$(dirname "$T"/${entry})" - ln -s ${outside}/dir "$T"/${entry} - ''; - } - { - sources = stateful; - inherit backup; - expect.fail = message; - } - ]; - }; - in lib.flatten [ - (link "file" { - sources.x.file = "/fixtures/alt"; - to = "dir"; - check = '' - test -e "$T"/x/flake.nix || fail "flake.nix missing" - ''; - }) - # What rsync logs about each item: what changed, and its size. - (s "rsync-log" { - phases = [{ - sources.x.file = "/fixtures/alt"; - output = [ - "f+++++++++ flake.nix " "/53" - # Named like pruning names it. - "populating '${targetName targetKind "/var/krops/rsync-log-${targetKind}/x"}'..." - ]; - }]; - }) - # The link points at a Git work tree, which resetting and cleaning would - # change. - (link "git" { - sources.x.git = { url = gitUrl; ref = gitHead; }; - to = "repo"; - check = '' - expect_eq HEAD "$(git -C "$T"/x rev-parse HEAD)" ${gitHead} - ''; - }) - (link "pass" { - sources.x.pass = { dir = "/fixtures/pass"; name = "x"; }; - to = "dir"; - check = '' - expect_eq a "$(cat "$T"/x/a)" secret-a - ''; - }) - (link "passage" { - sources.x.passage = { - dir = "/fixtures/passage/store/x"; - identities_file = "/fixtures/passage/identities"; - }; - to = "dir"; - check = '' - expect_eq a "$(cat "$T"/x/a)" secret-a - ''; - }) - (link "pipe" { - sources.x.pipe = "/fixtures/pipe"; - to = "file"; - check = '' - expect_eq x "$(cat "$T"/x)" piped - ''; - }) - (link "derivation" { - sources.x.derivation = '' - derivation { - name = "krops-test"; - system = builtins.currentSystem; - builder = "/bin/sh"; - args = [ "-c" "echo built > $out" ]; - } - ''; - to = "file"; - check = '' - expect_eq x "$(cat "$T"/x)" built - ''; - }) - (link "symlink" { - sources = alt // { x.symlink = "alt"; }; - to = "dir"; - says = false; - check = '' - expect_eq link "$(readlink "$T"/x)" alt - ''; - }) - (link "flake" { - sources.x.flake = { url = "/fixtures/top"; inherit fetchOnTarget; }; - to = "dir"; - check = checkFlake { attr = "msg"; expected = "top:dep+inner,sub"; }; - }) - (link "flake-materialized" { - sources.x.flake = { - url = "/fixtures/top"; inherit fetchOnTarget; - materialize = true; - }; - to = "dir"; - check = checkFlake { - attr = "msg"; expected = "top:dep+inner,sub"; materialized = true; - }; - }) - (link "flake-input-patched" { - sources.x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - patches = hello; - }; - to = "dir"; - check = checkFlake { attr = "greeting"; expected = "hello+inner"; }; - }) - # Symlinks to outside in what a source replaces: rsync and Git remove - # them, and so does replacing a directory by a link. - (s "inner-links" (let - prepare = '' - for name in a b c; do - mkdir -p "$T"/$name - ln -s ${outside}/dir "$T"/$name/keep - ln -s ${outside}/dir "$T"/$name/stale - ln -s ${outside}/repo/.git "$T"/$name/.git - done - # A work tree whose repository is elsewhere. - mkdir -p "$T"/d - echo "gitdir: ${outside}/repo/.git" > "$T"/d/.git - ''; - in { - isolate = true; - inherit prepare; - phases = twice { - sources = { - a.file = "/fixtures/filesrc"; - b.git = { url = gitUrl; ref = gitHead; }; - c.flake = { url = "/fixtures/top"; inherit fetchOnTarget; }; - d.git = { url = gitUrl; ref = gitHead; }; - }; - check = '' - expect_eq keep "$(cat "$T"/a/keep)" keep - test ! -L "$T"/a/stale || fail "a/stale remains" - expect_eq HEAD "$(git -C "$T"/b rev-parse HEAD)" ${gitHead} - test ! -L "$T"/b/.git || fail "b/.git remains a link" - test ! -L "$T"/b/stale || fail "b/stale remains" - expect_eq HEAD "$(git -C "$T"/d rev-parse HEAD)" ${gitHead} - test -d "$T"/d/.git || fail "d/.git isn't a directory" - expect_eq "store directory" "$(dirname "$(readlink "$T"/c)")" /nix/store - ''; - }; - })) - (state "sentinel" { - entry = ".populate"; - message = "error: sentinel file is a symlink"; - }) - (state "backup" { entry = ".populate/backup"; backup = true; }) - (map - (entry: state (lib.replaceStrings ["/"] ["-"] entry) { - entry = ".populate/${entry}"; - }) - [ - "derived" "flake-inputs" "flake-uploads" "flakes" "patches" - "derived/x" "patches/x" "flake-inputs/y" "flake-uploads/y" "flakes/z" - ]) - # Symlinks to outside among what populate removes: leftovers of - # interrupted runs, state of sources that are gone, and, when pruning, - # entries of the target directory. They get removed as links. So do - # hard links to a read-only file outside, whose mode stays. - (s "leftovers" { - isolate = true; - prepare = '' - mkdir -p "$T"/hard - ln -s ${outside}/dir "$T"/other - ln -s ${outside}/repo "$T"/repo - ln ${outside}/dir/sub/file "$T"/hard/link - ln ${outside}/dir/sub/file "$T"/hardlink - ''; - phases = [ - { - sources = stateful; - mutate = '' - ln -s ${outside}/dir "$T"/.populate/derived/x/work - ln -s ${outside}/dir "$T"/.populate/derived/gone - ln -s ${outside}/dir "$T"/.populate/flakes/gone - ln -s ${outside}/dir "$T"/.populate/patches/gone - ln -s ${outside}/dir "$T"/.populate/flake-inputs/gone - mkdir -p "$T"/.populate/flake-uploads - ln -s ${outside}/dir "$T"/.populate/flake-uploads/gone - ''; - } - { - sources = stateful; - check = '' - for name in derived/x/work derived/gone flakes/gone patches/gone; do - test ! -L "$T"/.populate/$name || fail "$name remains" - done - for name in other repo .populate/flake-inputs/gone .populate/flake-uploads/gone; do - test -L "$T"/$name || fail "$name removed without pruning" - done - ''; - } - { - sources = stateful; - prune = true; - check = '' - for name in other repo hard hardlink .populate/flake-inputs/gone .populate/flake-uploads; do - test ! -L "$T"/$name && test ! -e "$T"/$name || fail "$name not pruned" - done - ''; - } - ]; - }) - # A target path with characters that mean something to shells and in - # URLs. - (s "odd-target" (let - targetPath = "/var/krops/odd-target-${targetKind}/a b*c?d#e%f"; - in { - isolate = true; - phases = twice { - sources = stateful // { - g.git = { url = gitUrl; ref = gitHead; }; - p.pipe = "/fixtures/pipe"; - }; - inherit targetPath; - prune = true; - check = '' - D=${lib.escapeShellArg targetPath} - test -e "$D"/alt/flake.nix || fail "alt missing" - expect_eq HEAD "$(git -C "$D"/g rev-parse HEAD)" ${gitHead} - expect_eq p "$(cat "$D"/p)" piped - expect_eq entries "$(ls "$T")" 'a b*c?d#e%f' - gc - expect_eq greeting "$(nix_eval "$(readlink -f "$D"/x)"#greeting)" hello+alt - expect_eq msg "$(nix_eval "$(readlink -f "$D"/y)"#msg)" top:dep+inner,sub - ''; - }; - })) - # The target directory itself may be a symlink: what it points to is the - # target directory then. - (s "linked-target" { - isolate = true; - prepare = '' - rm -fR "$T"-real - mkdir "$T"-real - ln -s "$(basename "$T")"-real "$T" - ''; - phases = twice { - sources = stateful; - check = '' - test -L "$T" || fail "the target directory isn't a link anymore" - test -e "$T"-real/alt/flake.nix || fail "alt missing" - gc - expect_eq greeting "$(nix_eval "$(readlink -f "$T"/x)"#greeting)" hello+alt - expect_eq msg "$(nix_eval "$(readlink -f "$T"/y)"#msg)" top:dep+inner,sub - expect_eq msg "$(nix_eval_online "path:$(readlink -f "$T"/.populate/flakes/z)#msg")" top:alt,sub - ''; - }; - }) - # Git work trees whose .git directory names places elsewhere, or a - # command: a work tree elsewhere, a configuration file elsewhere, another - # repository, and a command run when Git checks for changes. Populate - # refuses them, telling why, and replaces them by fresh clones with - # reclone. A hook doesn't run. - (s "git-foreign" (let - elsewhere = "/var/krops-elsewhere"; - git = name: reclone: { - ${name}.git = { url = gitUrl; ref = gitHead; inherit reclone; }; - }; - untouched = '' - cmp -s ${elsewhere}/config ${elsewhere}/config.orig || - fail "what b/.git/config links to changed" - test ! -e ${elsewhere}/ran || fail "a command in a .git directory ran" - ''; - refused = name: message: { - sources = git name false; - expect.fail = "error: populate doesn't use the Git work tree ${targetName targetKind "/var/krops/git-foreign-${targetKind}/${name}"}, because ${message}. Fix that, remove the work tree, or set the source's reclone to true to replace it by a fresh clone."; - }; - in { - isolate = true; - prepare = '' - rm -fR ${elsewhere} - mkdir -p ${elsewhere} "$T" - for name in a b c d e; do - git clone -q ${gitUrl} "$T"/$name - git -C "$T"/$name checkout -q ${gitFirst} - done - git -C "$T"/a config core.worktree ${outside}/dir - mv "$T"/b/.git/config ${elsewhere}/config - ln -s ${elsewhere}/config "$T"/b/.git/config - cp -p ${elsewhere}/config ${elsewhere}/config.orig - printf '#! /bin/sh\ntouch ${elsewhere}/ran\n' > "$T"/c/.git/hooks/reference-transaction - chmod +x "$T"/c/.git/hooks/reference-transaction - echo ${outside}/repo/.git > "$T"/d/.git/commondir - git -C "$T"/e config core.fsmonitor "touch ${elsewhere}/ran" - ''; - phases = [ - (refused "a" "/var/krops/git-foreign-${targetKind}/a/.git/config sets core.worktree to ${outside}/dir") - (refused "b" "/var/krops/git-foreign-${targetKind}/b/.git contains symlinks: /var/krops/git-foreign-${targetKind}/b/.git/config") - { - sources = git "c" false; - check = untouched + '' - expect_eq "c HEAD" "$(git -C "$T"/c rev-parse HEAD)" ${gitHead} - ''; - } - (refused "d" "/var/krops/git-foreign-${targetKind}/d/.git/commondir names another repository") - (refused "e" "/var/krops/git-foreign-${targetKind}/e/.git/config sets core.fsmonitor, which neither git clone nor populate does") - { - sources = git "a" true // git "b" true // git "c" true // git "d" true // git "e" true; - output = map - (name: "replacing the Git work tree '${targetName targetKind "/var/krops/git-foreign-${targetKind}/${name}"}', because") - [ "a" "b" "d" "e" ]; - check = untouched + '' - for name in a b c d e; do - expect_eq "$name HEAD" "$(git -C "$T"/$name rev-parse HEAD)" ${gitHead} - test -e "$T"/$name/two || fail "$name/two missing" - done - ''; - } - ]; - })) - # A file in populate's state replaced by a symlink to a file outside. - (s "state-key" (let - sources.x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - patches = hello; - }; - in { - isolate = true; - phases = [ - { - inherit sources; - mutate = '' - rm "$T"/.populate/derived/x/key - ln -s ${outside}/file "$T"/.populate/derived/x/key - ''; - } - { - inherit sources; - check = checkFlake { attr = "greeting"; expected = "hello+inner"; }; - } - ]; - })) - # Stale state that contains a hard link to a read-only file outside, - # whose mode stays. - (s "state-hard-link" (let - sources.x.flake-input = { - url = "/fixtures/top"; name = "dep"; inherit fetchOnTarget; - patches = hello; - }; - in { - isolate = true; - phases = [ - { - inherit sources; - mutate = '' - mkdir -p "$T"/.populate/derived/gone "$T"/.populate/derived/x/work - ln ${outside}/dir/sub/file "$T"/.populate/derived/gone/file - ln ${outside}/dir/sub/file "$T"/.populate/derived/x/work/file - ''; - } - { - inherit sources; - check = '' - test ! -e "$T"/.populate/derived/gone || fail "gone remains" - ''; - } - ]; - })) - # The source contains flake.lock.populate and a file like the temporary - # copy of the lock file, symlinks to a file outside. - (s "lock-temporary-link" { - isolate = true; - prepareDeployer = '' - rm -fR /var/krops-src/lock-temporary-link - mkdir -p /var/krops-src - cp -R /fixtures/filesrc /var/krops-src/lock-temporary-link - ln -s ${outside}/file /var/krops-src/lock-temporary-link/flake.lock.populate - ln -s ${outside}/file /var/krops-src/lock-temporary-link/.flake.lock.XXXXXX - ''; - phases = twice { - sources = alt // { - x.file = { - path = "/var/krops-src/lock-temporary-link"; - inputs.dep.follows = "alt"; - }; - }; - check = '' - expect_eq msg "$(nix_eval_online path:"$T"/x#msg)" top:alt,sub - ''; - }; - }) - # A file in the target directory is a hard link to a read-only file - # outside with the same contents, which rsync takes for unchanged, and - # would fix the mode and time of in place. - (s "rsync-hard-link" { - isolate = true; - prepareDeployer = '' - rm -fR /var/krops-src/rsync-hard-link - mkdir -p /var/krops-src/rsync-hard-link - echo outside > /var/krops-src/rsync-hard-link/file - ''; - prepare = '' - mkdir -p "$T"/x - ln ${outside}/dir/sub/file "$T"/x/file - ''; - phases = twice { - sources.x.file = { - path = "/var/krops-src/rsync-hard-link"; - useChecksum = true; - }; - check = '' - expect_eq file "$(cat "$T"/x/file)" outside - expect_eq links "$(stat -c %h "$T"/x/file)" 1 - ''; - }; - }) - (lib.optionals (targetKind == "local") [ - # Rewriting a lock file changes no other hard link to it. The lock - # file is like the source's, with its modification time, so rsync - # leaves the link in place. (The source is on the deploying machine, - # so this only runs there.) - (s "lock-hard-link" { - prepare = '' - mkdir -p "$T" - cp -a /fixtures/filesrc "$T"/x - cp -p "$T"/x/flake.lock "$T".lock - ln -f "$T".lock "$T"/x/flake.lock - ''; - phases = twice { - sources = alt // { - x.file = { path = "/fixtures/filesrc"; inputs.dep.follows = "alt"; }; - }; - check = '' - cmp -s "$T".lock /fixtures/filesrc/flake.lock || - fail "the other hard link changed" - expect_eq msg "$(nix_eval_online "$T"/x#msg)" top:alt,sub - ''; - }; - }) - # Names that lead out of the target directory, to the directory itself, - # or to populate's state. - (s "names" { - phases = map - (name: { - sources.${name}.file = "/fixtures/alt"; - expect = "eval-error"; - control = { ok.file = "/fixtures/alt"; }; - }) - [ "" "." ".." ".populate" "a/b" "../x" "/etc" "a\nb" "a b" "a*b" "a?b" "a+b" "a=b" "-a" ]; - }) - # Target paths that aren't absolute, that are the root directory, or - # that resolve to another directory than they name. - (s "paths" { - phases = map - (targetPath: { - sources = alt; - inherit targetPath; - expect = "eval-error"; - controlTargetPath = "/var/krops/paths-local"; - }) - [ "" "/" "//" "/." "relative" "/var/krops/.." "/var/krops/../.." "/var/krops/a\nb" ]; - }) - ]) - ]) targetKinds; - } |
