source common.sh if [[ -z $(type -p git) ]]; then echo "Git not installed; skipping flake tests" exit 99 fi clearStore rm -rf $TEST_HOME/.cache $TEST_HOME/.config registry=$TEST_ROOT/registry.json flake1Dir=$TEST_ROOT/flake1 flake2Dir=$TEST_ROOT/flake2 flake3Dir=$TEST_ROOT/flake3 flake5Dir=$TEST_ROOT/flake5 flake6Dir=$TEST_ROOT/flake6 flake7Dir=$TEST_ROOT/flake7 templatesDir=$TEST_ROOT/templates nonFlakeDir=$TEST_ROOT/nonFlake badFlakeDir=$TEST_ROOT/badFlake flakeA=$TEST_ROOT/flakeA flakeB=$TEST_ROOT/flakeB flakeGitBare=$TEST_ROOT/flakeGitBare flakeFollowsA=$TEST_ROOT/follows/flakeA flakeFollowsB=$TEST_ROOT/follows/flakeA/flakeB flakeFollowsC=$TEST_ROOT/follows/flakeA/flakeB/flakeC flakeFollowsD=$TEST_ROOT/follows/flakeA/flakeD flakeFollowsE=$TEST_ROOT/follows/flakeA/flakeE for repo in $flake1Dir $flake2Dir $flake3Dir $flake7Dir $templatesDir $nonFlakeDir $flakeA $flakeB $flakeFollowsA; do rm -rf $repo $repo.tmp mkdir -p $repo # Give one repo a non-master initial branch. extraArgs= if [[ $repo == $flake2Dir ]]; then extraArgs="--initial-branch=main" fi git -C $repo init $extraArgs git -C $repo config user.email "foobar@example.com" git -C $repo config user.name "Foobar" done cat > $flake1Dir/flake.nix <<EOF { description = "Bla bla"; outputs = inputs: rec { packages.$system = rec { foo = import ./simple.nix; default = foo; }; # To test "nix flake init". legacyPackages.x86_64-linux.hello = import ./simple.nix; }; } EOF cp ./simple.nix ./simple.builder.sh ./config.nix $flake1Dir/ git -C $flake1Dir add flake.nix simple.nix simple.builder.sh config.nix git -C $flake1Dir commit -m 'Initial' cat > $flake2Dir/flake.nix <<EOF { description = "Fnord"; outputs = { self, flake1 }: rec { packages.$system.bar = flake1.packages.$system.foo; }; } EOF git -C $flake2Dir add flake.nix git -C $flake2Dir commit -m 'Initial' cat > $flake3Dir/flake.nix <<EOF { description = "Fnord"; outputs = { self, flake2 }: rec { packages.$system.xyzzy = flake2.packages.$system.bar; checks = { xyzzy = packages.$system.xyzzy; }; }; } EOF git -C $flake3Dir add flake.nix git -C $flake3Dir commit -m 'Initial' cat > $nonFlakeDir/README.md <<EOF FNORD EOF git -C $nonFlakeDir add README.md git -C $nonFlakeDir commit -m 'Initial' # Construct a custom registry, additionally test the --registry flag nix registry add --registry $registry flake1 git+file://$flake1Dir nix registry add --registry $registry flake2 git+file://$flake2Dir nix registry add --registry $registry flake3 git+file://$flake3Dir nix registry add --registry $registry flake4 flake3 nix registry add --registry $registry flake5 hg+file://$flake5Dir nix registry add --registry $registry nixpkgs flake1 nix registry add --registry $registry templates git+file://$templatesDir # Test 'nix flake list'. [[ $(nix registry list | wc -l) == 7 ]] # Test 'nix flake metadata'. nix flake metadata flake1 nix flake metadata flake1 | grep -q 'Locked URL:.*flake1.*' # Test 'nix flake metadata' on a local flake. (cd $flake1Dir && nix flake metadata) | grep -q 'URL:.*flake1.*' (cd $flake1Dir && nix flake metadata .) | grep -q 'URL:.*flake1.*' nix flake metadata $flake1Dir | grep -q 'URL:.*flake1.*' # Test 'nix flake metadata --json'. json=$(nix flake metadata flake1 --json | jq .) [[ $(echo "$json" | jq -r .description) = 'Bla bla' ]] [[ -d $(echo "$json" | jq -r .path) ]] [[ $(echo "$json" | jq -r .lastModified) = $(git -C $flake1Dir log -n1 --format=%ct) ]] hash1=$(echo "$json" | jq -r .revision) echo -n '# foo' >> $flake1Dir/flake.nix git -C $flake1Dir commit -a -m 'Foo' hash2=$(nix flake metadata flake1 --json --refresh | jq -r .revision) [[ $hash1 != $hash2 ]] # Test 'nix build' on a flake. nix build -o $TEST_ROOT/result flake1#foo [[ -e $TEST_ROOT/result/hello ]] # Test packages.default. nix build -o $TEST_ROOT/result flake1 [[ -e $TEST_ROOT/result/hello ]] nix build -o $TEST_ROOT/result $flake1Dir nix build -o $TEST_ROOT/result git+file://$flake1Dir # Check that store symlinks inside a flake are not interpreted as flakes. nix build -o $flake1Dir/result git+file://$flake1Dir nix path-info $flake1Dir/result # 'getFlake' on a mutable flakeref should fail in pure mode, but succeed in impure mode. (! nix build -o $TEST_ROOT/result --expr "(builtins.getFlake \"$flake1Dir\").packages.$system.default") nix build -o $TEST_ROOT/result --expr "(builtins.getFlake \"$flake1Dir\").packages.$system.default" --impure # 'getFlake' on an immutable flakeref should succeed even in pure mode. nix build -o $TEST_ROOT/result --expr "(builtins.getFlake \"git+file://$flake1Dir?rev=$hash2\").packages.$system.default" # Building a flake with an unlocked dependency should fail in pure mode. (! nix build -o $TEST_ROOT/result flake2#bar --no-registries) (! nix build -o $TEST_ROOT/result flake2#bar --no-use-registries) (! nix eval --expr "builtins.getFlake \"$flake2Dir\"") # But should succeed in impure mode. (! nix build -o $TEST_ROOT/result flake2#bar --impure) nix build -o $TEST_ROOT/result flake2#bar --impure --no-write-lock-file nix eval --expr "builtins.getFlake \"$flake2Dir\"" --impure # Building a local flake with an unlocked dependency should fail with --no-update-lock-file. nix build -o $TEST_ROOT/result $flake2Dir#bar --no-update-lock-file 2>&1 | grep 'requires lock file changes' # But it should succeed without that flag. nix build -o $TEST_ROOT/result $flake2Dir#bar --no-write-lock-file nix build -o $TEST_ROOT/result $flake2Dir#bar --no-update-lock-file 2>&1 | grep 'requires lock file changes' nix build -o $TEST_ROOT/result $flake2Dir#bar --commit-lock-file [[ -e $flake2Dir/flake.lock ]] [[ -z $(git -C $flake2Dir diff master) ]] # Rerunning the build should not change the lockfile. nix build -o $TEST_ROOT/result $flake2Dir#bar [[ -z $(git -C $flake2Dir diff master) ]] # Building with a lockfile should not require a fetch of the registry. nix build -o $TEST_ROOT/result --flake-registry file:///no-registry.json $flake2Dir#bar --refresh nix build -o $TEST_ROOT/result --no-registries $flake2Dir#bar --refresh nix build -o $TEST_ROOT/result --no-use-registries $flake2Dir#bar --refresh # Updating the flake should not change the lockfile. nix flake lock $flake2Dir [[ -z $(git -C $flake2Dir diff master) ]] # Now we should be able to build the flake in pure mode. nix build -o $TEST_ROOT/result flake2#bar # Or without a registry. nix build -o $TEST_ROOT/result --no-registries git+file://$flake2Dir#bar --refresh nix build -o $TEST_ROOT/result --no-use-registries git+file://$flake2Dir#bar --refresh # Test whether indirect dependencies work. nix build -o $TEST_ROOT/result $flake3Dir#xyzzy git -C $flake3Dir add flake.lock # Add dependency to flake3. rm $flake3Dir/flake.nix cat > $flake3Dir/flake.nix <<EOF { description = "Fnord"; outputs = { self, flake1, flake2 }: rec { packages.$system.xyzzy = flake2.packages.$system.bar; packages.$system."sth sth" = flake1.packages.$system.foo; }; } EOF git -C $flake3Dir add flake.nix git -C $flake3Dir commit -m 'Update flake.nix' # Check whether `nix build` works with an incomplete lockfile nix build -o $TEST_ROOT/result $flake3Dir#"sth sth" nix build -o $TEST_ROOT/result $flake3Dir#"sth%20sth" # Check whether it saved the lockfile (! [[ -z $(git -C $flake3Dir diff master) ]]) git -C $flake3Dir add flake.lock git -C $flake3Dir commit -m 'Add lockfile' # Test whether registry caching works. nix registry list --flake-registry file://$registry | grep -q flake3 mv $registry $registry.tmp nix store gc nix registry list --flake-registry file://$registry --refresh | grep -q flake3 mv $registry.tmp $registry # Test whether flakes are registered as GC roots for offline use. # FIXME: use tarballs rather than git. rm -rf $TEST_HOME/.cache nix store gc # get rid of copies in the store to ensure they get fetched to our git cache _NIX_FORCE_HTTP=1 nix build -o $TEST_ROOT/result git+file://$flake2Dir#bar mv $flake1Dir $flake1Dir.tmp mv $flake2Dir $flake2Dir.tmp nix store gc _NIX_FORCE_HTTP=1 nix build -o $TEST_ROOT/result git+file://$flake2Dir#bar _NIX_FORCE_HTTP=1 nix build -o $TEST_ROOT/result git+file://$flake2Dir#bar --refresh mv $flake1Dir.tmp $flake1Dir mv $flake2Dir.tmp $flake2Dir # Add nonFlakeInputs to flake3. rm $flake3Dir/flake.nix cat > $flake3Dir/flake.nix <<EOF { inputs = { flake1 = {}; flake2 = {}; nonFlake = { url = git+file://$nonFlakeDir; flake = false; }; nonFlakeFile = { url = path://$nonFlakeDir/README.md; flake = false; }; nonFlakeFile2 = { url = "$nonFlakeDir/README.md"; flake = false; }; }; description = "Fnord"; outputs = inputs: rec { packages.$system.xyzzy = inputs.flake2.packages.$system.bar; packages.$system.sth = inputs.flake1.packages.$system.foo; packages.$system.fnord = with import ./config.nix; mkDerivation { inherit system; name = "fnord"; dummy = builtins.readFile (builtins.path { name = "source"; path = ./.; filter = path: type: baseNameOf path == "config.nix"; } + "/config.nix"); dummy2 = builtins.readFile (builtins.path { name = "source"; path = inputs.flake1; filter = path: type: baseNameOf path == "simple.nix"; } + "/simple.nix"); buildCommand = '' cat \${inputs.nonFlake}/README.md > \$out [[ \$(cat \${inputs.nonFlake}/README.md) = \$(cat \${inputs.nonFlakeFile}) ]] [[ \${inputs.nonFlakeFile} = \${inputs.nonFlakeFile2} ]] ''; }; }; } EOF cp ./config.nix $flake3Dir git -C $flake3Dir add flake.nix config.nix git -C $flake3Dir commit -m 'Add nonFlakeInputs' # Check whether `nix build` works with a lockfile which is missing a # nonFlakeInputs. nix build -o $TEST_ROOT/result $flake3Dir#sth --commit-lock-file nix build -o $TEST_ROOT/result flake3#fnord [[ $(cat $TEST_ROOT/result) = FNORD ]] # Check whether flake input fetching is lazy: flake3#sth does not # depend on flake2, so this shouldn't fail. rm -rf $TEST_HOME/.cache clearStore mv $flake2Dir $flake2Dir.tmp mv $nonFlakeDir $nonFlakeDir.tmp nix build -o $TEST_ROOT/result flake3#sth (! nix build -o $TEST_ROOT/result flake3#xyzzy) (! nix build -o $TEST_ROOT/result flake3#fnord) mv $flake2Dir.tmp $flake2Dir mv $nonFlakeDir.tmp $nonFlakeDir nix build -o $TEST_ROOT/result flake3#xyzzy flake3#fnord # Test doing multiple `lookupFlake`s nix build -o $TEST_ROOT/result flake4#xyzzy # Test 'nix flake update' and --override-flake. nix flake lock $flake3Dir [[ -z $(git -C $flake3Dir diff master) ]] nix flake update $flake3Dir --override-flake flake2 nixpkgs [[ ! -z $(git -C $flake3Dir diff master) ]] # Make branch "removeXyzzy" where flake3 doesn't have xyzzy anymore git -C $flake3Dir checkout -b removeXyzzy rm $flake3Dir/flake.nix cat > $flake3Dir/flake.nix <<EOF { inputs = { nonFlake = { url = "$nonFlakeDir"; flake = false; }; }; description = "Fnord"; outputs = { self, flake1, flake2, nonFlake }: rec { packages.$system.sth = flake1.packages.$system.foo; packages.$system.fnord = with import ./config.nix; mkDerivation { inherit system; name = "fnord"; buildCommand = '' cat \${nonFlake}/README.md > \$out ''; }; }; } EOF nix flake lock $flake3Dir git -C $flake3Dir add flake.nix flake.lock git -C $flake3Dir commit -m 'Remove packages.xyzzy' git -C $flake3Dir checkout master # Test whether fuzzy-matching works for registry entries. (! nix build -o $TEST_ROOT/result flake4/removeXyzzy#xyzzy) nix build -o $TEST_ROOT/result flake4/removeXyzzy#sth # Testing the nix CLI nix registry add flake1 flake3 [[ $(nix registry list | wc -l) == 8 ]] nix registry pin flake1 [[ $(nix registry list | wc -l) == 8 ]] nix registry pin flake1 flake3 [[ $(nix registry list | wc -l) == 8 ]] nix registry remove flake1 [[ $(nix registry list | wc -l) == 7 ]] # Test 'nix flake init'. cat > $templatesDir/flake.nix <<EOF { description = "Some templates"; outputs = { self }: { templates = rec { trivial = { path = ./trivial; description = "A trivial flake"; welcomeText = '' Welcome to my trivial flake ''; }; default = trivial; }; }; } EOF mkdir $templatesDir/trivial cat > $templatesDir/trivial/flake.nix <<EOF { description = "A flake for building Hello World"; outputs = { self, nixpkgs }: { packages.x86_64-linux = rec { hello = nixpkgs.legacyPackages.x86_64-linux.hello; default = hello; }; }; } EOF git -C $templatesDir add flake.nix trivial/flake.nix git -C $templatesDir commit -m 'Initial' nix flake check templates nix flake show templates nix flake show templates --json | jq (cd $flake7Dir && nix flake init) (cd $flake7Dir && nix flake init) # check idempotence git -C $flake7Dir add flake.nix nix flake check $flake7Dir nix flake show $flake7Dir nix flake show $flake7Dir --json | jq git -C $flake7Dir commit -a -m 'Initial' # Test 'nix flake new'. rm -rf $flake6Dir nix flake new -t templates#trivial $flake6Dir nix flake new -t templates#trivial $flake6Dir # check idempotence nix flake check $flake6Dir # Test 'nix flake clone'. rm -rf $TEST_ROOT/flake1-v2 nix flake clone flake1 --dest $TEST_ROOT/flake1-v2 [ -e $TEST_ROOT/flake1-v2/flake.nix ] # More 'nix flake check' tests. cat > $flake3Dir/flake.nix <<EOF { outputs = { flake1, self }: { overlay = final: prev: { }; }; } EOF nix flake check $flake3Dir cat > $flake3Dir/flake.nix <<EOF { outputs = { flake1, self }: { overlay = finalll: prev: { }; }; } EOF (! nix flake check $flake3Dir) cat > $flake3Dir/flake.nix <<EOF { outputs = { flake1, self }: { nixosModules.foo = { a.b.c = 123; foo = true; }; }; } EOF nix flake check $flake3Dir cat > $flake3Dir/flake.nix <<EOF { outputs = { flake1, self }: { nixosModules.foo = { a.b.c = 123; foo = assert false; true; }; }; } EOF (! nix flake check $flake3Dir) cat > $flake3Dir/flake.nix <<EOF { outputs = { flake1, self }: { nixosModule = { config, pkgs, ... }: { a.b.c = 123; }; }; } EOF nix flake check $flake3Dir cat > $flake3Dir/flake.nix <<EOF { outputs = { flake1, self }: { nixosModule = { config, pkgs }: { a.b.c = 123; }; }; } EOF (! nix flake check $flake3Dir) cat > $flake3Dir/flake.nix <<EOF { outputs = { flake1, self }: { packages.system-1.default = "foo"; packages.system-2.default = "bar"; }; } EOF checkRes=$(nix flake check --keep-going $flake3Dir 2>&1 && fail "nix flake check should have failed" || true) echo "$checkRes" | grep -q "packages.system-1.default" echo "$checkRes" | grep -q "packages.system-2.default" # Test 'follows' inputs. cat > $flake3Dir/flake.nix <<EOF { inputs.foo = { type = "indirect"; id = "flake1"; }; inputs.bar.follows = "foo"; outputs = { self, foo, bar }: { }; } EOF nix flake lock $flake3Dir [[ $(jq -c .nodes.root.inputs.bar $flake3Dir/flake.lock) = '["foo"]' ]] cat > $flake3Dir/flake.nix <<EOF { inputs.bar.follows = "flake2/flake1"; outputs = { self, flake2, bar }: { }; } EOF nix flake lock $flake3Dir [[ $(jq -c .nodes.root.inputs.bar $flake3Dir/flake.lock) = '["flake2","flake1"]' ]] cat > $flake3Dir/flake.nix <<EOF { inputs.bar.follows = "flake2"; outputs = { self, flake2, bar }: { }; } EOF nix flake lock $flake3Dir [[ $(jq -c .nodes.root.inputs.bar $flake3Dir/flake.lock) = '["flake2"]' ]] # Test overriding inputs of inputs. cat > $flake3Dir/flake.nix <<EOF { inputs.flake2.inputs.flake1 = { type = "git"; url = file://$flake7Dir; }; outputs = { self, flake2 }: { }; } EOF nix flake lock $flake3Dir [[ $(jq .nodes.flake1.locked.url $flake3Dir/flake.lock) =~ flake7 ]] cat > $flake3Dir/flake.nix <<EOF { inputs.flake2.inputs.flake1.follows = "foo"; inputs.foo.url = git+file://$flake7Dir; outputs = { self, flake2 }: { }; } EOF nix flake update $flake3Dir [[ $(jq -c .nodes.flake2.inputs.flake1 $flake3Dir/flake.lock) =~ '["foo"]' ]] [[ $(jq .nodes.foo.locked.url $flake3Dir/flake.lock) =~ flake7 ]] # Test git+file with bare repo. rm -rf $flakeGitBare git clone --bare $flake1Dir $flakeGitBare nix build -o $TEST_ROOT/result git+file://$flakeGitBare # Test Mercurial flakes. rm -rf $flake5Dir mkdir $flake5Dir cat > $flake5Dir/flake.nix <<EOF { outputs = { self, flake1 }: { packages.$system.default = flake1.packages.$system.default; expr = assert builtins.pathExists ./flake.lock; 123; }; } EOF if [[ -n $(type -p hg) ]]; then hg init $flake5Dir hg add $flake5Dir/flake.nix hg commit --config ui.username=foobar@example.org $flake5Dir -m 'Initial commit' nix build -o $TEST_ROOT/result hg+file://$flake5Dir [[ -e $TEST_ROOT/result/hello ]] (! nix flake metadata --json hg+file://$flake5Dir | jq -e -r .revision) nix eval hg+file://$flake5Dir#expr nix eval hg+file://$flake5Dir#expr (! nix eval hg+file://$flake5Dir#expr --no-allow-dirty) (! nix flake metadata --json hg+file://$flake5Dir | jq -e -r .revision) hg commit --config ui.username=foobar@example.org $flake5Dir -m 'Add lock file' nix flake metadata --json hg+file://$flake5Dir --refresh | jq -e -r .revision nix flake metadata --json hg+file://$flake5Dir [[ $(nix flake metadata --json hg+file://$flake5Dir | jq -e -r .revCount) = 1 ]] nix build -o $TEST_ROOT/result hg+file://$flake5Dir --no-registries --no-allow-dirty nix build -o $TEST_ROOT/result hg+file://$flake5Dir --no-use-registries --no-allow-dirty fi # Test path flakes. rm -rf $flake5Dir/.hg $flake5Dir/flake.lock nix flake lock path://$flake5Dir # Test tarball flakes. tar cfz $TEST_ROOT/flake.tar.gz -C $TEST_ROOT flake5 nix build -o $TEST_ROOT/result file://$TEST_ROOT/flake.tar.gz # Building with a tarball URL containing a SRI hash should also work. url=$(nix flake metadata --json file://$TEST_ROOT/flake.tar.gz | jq -r .url) [[ $url =~ sha256- ]] nix build -o $TEST_ROOT/result $url # Building with an incorrect SRI hash should fail. nix build -o $TEST_ROOT/result "file://$TEST_ROOT/flake.tar.gz?narHash=sha256-qQ2Zz4DNHViCUrp6gTS7EE4+RMqFQtUfWF2UNUtJKS0=" 2>&1 | grep 'NAR hash mismatch' # Test --override-input. git -C $flake3Dir reset --hard nix flake lock $flake3Dir --override-input flake2/flake1 file://$TEST_ROOT/flake.tar.gz -vvvvv [[ $(jq .nodes.flake1_2.locked.url $flake3Dir/flake.lock) =~ flake.tar.gz ]] nix flake lock $flake3Dir --override-input flake2/flake1 flake1 [[ $(jq -r .nodes.flake1_2.locked.rev $flake3Dir/flake.lock) =~ $hash2 ]] nix flake lock $flake3Dir --override-input flake2/flake1 flake1/master/$hash1 [[ $(jq -r .nodes.flake1_2.locked.rev $flake3Dir/flake.lock) =~ $hash1 ]] # Test --update-input. nix flake lock $flake3Dir [[ $(jq -r .nodes.flake1_2.locked.rev $flake3Dir/flake.lock) = $hash1 ]] nix flake lock $flake3Dir --update-input flake2/flake1 [[ $(jq -r .nodes.flake1_2.locked.rev $flake3Dir/flake.lock) =~ $hash2 ]] # Test 'nix flake metadata --json'. nix flake metadata $flake3Dir --json | jq . # Test circular flake dependencies. cat > $flakeA/flake.nix <<EOF { inputs.b.url = git+file://$flakeB; inputs.b.inputs.a.follows = "/"; outputs = { self, nixpkgs, b }: { foo = 123 + b.bar; xyzzy = 1000; }; } EOF git -C $flakeA add flake.nix cat > $flakeB/flake.nix <<EOF { inputs.a.url = git+file://$flakeA; outputs = { self, nixpkgs, a }: { bar = 456 + a.xyzzy; }; } EOF git -C $flakeB add flake.nix git -C $flakeB commit -a -m 'Foo' [[ $(nix eval $flakeA#foo) = 1579 ]] [[ $(nix eval $flakeA#foo) = 1579 ]] sed -i $flakeB/flake.nix -e 's/456/789/' git -C $flakeB commit -a -m 'Foo' [[ $(nix eval --update-input b $flakeA#foo) = 1912 ]] # Test list-inputs with circular dependencies nix flake metadata $flakeA # Test flake follow paths mkdir -p $flakeFollowsB mkdir -p $flakeFollowsC mkdir -p $flakeFollowsD mkdir -p $flakeFollowsE cat > $flakeFollowsA/flake.nix <<EOF { description = "Flake A"; inputs = { B = { url = "path:./flakeB"; inputs.foobar.follows = "foobar"; }; foobar.url = "path:$flakeFollowsA/flakeE"; }; outputs = { ... }: {}; } EOF cat > $flakeFollowsB/flake.nix <<EOF { description = "Flake B"; inputs = { foobar.url = "path:$flakeFollowsA/flakeE"; goodoo.follows = "C/goodoo"; C = { url = "path:./flakeC"; inputs.foobar.follows = "foobar"; }; }; outputs = { ... }: {}; } EOF cat > $flakeFollowsC/flake.nix <<EOF { description = "Flake C"; inputs = { foobar.url = "path:$flakeFollowsA/flakeE"; goodoo.follows = "foobar"; }; outputs = { ... }: {}; } EOF cat > $flakeFollowsD/flake.nix <<EOF { description = "Flake D"; inputs = {}; outputs = { ... }: {}; } EOF cat > $flakeFollowsE/flake.nix <<EOF { description = "Flake E"; inputs = {}; outputs = { ... }: {}; } EOF git -C $flakeFollowsA add flake.nix flakeB/flake.nix \ flakeB/flakeC/flake.nix flakeD/flake.nix flakeE/flake.nix nix flake metadata $flakeFollowsA nix flake update $flakeFollowsA oldLock="$(cat "$flakeFollowsA/flake.lock")" # Ensure that locking twice doesn't change anything nix flake lock $flakeFollowsA newLock="$(cat "$flakeFollowsA/flake.lock")" diff <(echo "$newLock") <(echo "$oldLock") [[ $(jq -c .nodes.B.inputs.C $flakeFollowsA/flake.lock) = '"C"' ]] [[ $(jq -c .nodes.B.inputs.foobar $flakeFollowsA/flake.lock) = '["foobar"]' ]] [[ $(jq -c .nodes.C.inputs.foobar $flakeFollowsA/flake.lock) = '["B","foobar"]' ]] # Ensure removing follows from flake.nix removes them from the lockfile cat > $flakeFollowsA/flake.nix <<EOF { description = "Flake A"; inputs = { B = { url = "path:./flakeB"; inputs.nonFlake.follows = "D"; }; D.url = "path:./flakeD"; }; outputs = { ... }: {}; } EOF nix flake lock $flakeFollowsA [[ $(jq -c .nodes.B.inputs.foobar $flakeFollowsA/flake.lock) = '"foobar"' ]] jq -r -c '.nodes | keys | .[]' $flakeFollowsA/flake.lock | grep "^foobar$" # Ensure a relative path is not allowed to go outside the store path cat > $flakeFollowsA/flake.nix <<EOF { description = "Flake A"; inputs = { B.url = "path:../flakeB"; }; outputs = { ... }: {}; } EOF git -C $flakeFollowsA add flake.nix nix flake lock $flakeFollowsA 2>&1 | grep 'points outside' # Test flake in store does not evaluate rm -rf $badFlakeDir mkdir $badFlakeDir echo INVALID > $badFlakeDir/flake.nix nix store delete $(nix store add-path $badFlakeDir) [[ $(nix path-info $(nix store add-path $flake1Dir)) =~ flake1 ]] [[ $(nix path-info path:$(nix store add-path $flake1Dir)) =~ simple ]]