lix/tests/flakes.sh

626 lines
16 KiB
Bash
Raw Normal View History

2019-05-07 21:22:47 +00:00
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
2019-05-07 21:22:47 +00:00
registry=$TEST_ROOT/registry.json
2019-05-01 09:38:48 +00:00
flake1Dir=$TEST_ROOT/flake1
flake2Dir=$TEST_ROOT/flake2
flake3Dir=$TEST_ROOT/flake3
2019-06-11 11:09:06 +00:00
flake4Dir=$TEST_ROOT/flake4
2020-01-27 12:45:49 +00:00
flake5Dir=$TEST_ROOT/flake5
2019-06-19 12:48:40 +00:00
flake7Dir=$TEST_ROOT/flake7
nonFlakeDir=$TEST_ROOT/nonFlake
2019-05-07 21:22:47 +00:00
2019-06-19 12:48:40 +00:00
for repo in $flake1Dir $flake2Dir $flake3Dir $flake7Dir $nonFlakeDir; do
rm -rf $repo $repo.tmp
2019-05-07 21:22:47 +00:00
mkdir $repo
git -C $repo init
git -C $repo config user.email "foobar@example.com"
git -C $repo config user.name "Foobar"
done
2019-05-01 09:38:48 +00:00
cat > $flake1Dir/flake.nix <<EOF
2019-05-07 21:22:47 +00:00
{
2019-08-30 11:11:33 +00:00
edition = 201909;
2019-05-07 21:22:47 +00:00
description = "Bla bla";
outputs = inputs: rec {
packages.$system.foo = import ./simple.nix;
defaultPackage.$system = packages.$system.foo;
2019-10-15 17:53:29 +00:00
# To test "nix flake init".
2019-11-20 12:07:44 +00:00
legacyPackages.x86_64-linux.hello = import ./simple.nix;
2019-05-07 21:22:47 +00:00
};
}
EOF
2019-05-01 09:38:48 +00:00
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'
2019-05-07 21:22:47 +00:00
2019-05-01 09:38:48 +00:00
cat > $flake2Dir/flake.nix <<EOF
2019-05-07 21:22:47 +00:00
{
2019-08-30 11:11:33 +00:00
edition = 201909;
2019-05-07 21:22:47 +00:00
description = "Fnord";
2019-08-30 11:11:33 +00:00
outputs = { self, flake1 }: rec {
packages.$system.bar = flake1.packages.$system.foo;
2019-05-07 21:22:47 +00:00
};
}
EOF
2019-05-01 09:38:48 +00:00
git -C $flake2Dir add flake.nix
git -C $flake2Dir commit -m 'Initial'
2019-05-07 21:22:47 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
2019-08-30 11:11:33 +00:00
edition = 201909;
description = "Fnord";
2019-08-30 11:11:33 +00:00
outputs = { self, flake2 }: rec {
packages.$system.xyzzy = flake2.packages.$system.bar;
2019-06-19 12:48:40 +00:00
checks = {
xyzzy = packages.$system.xyzzy;
2019-06-19 12:48:40 +00:00
};
};
}
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'
2019-05-07 21:22:47 +00:00
cat > $registry <<EOF
{
"flakes": {
"flake:flake1": {
"url": "git+file://$flake1Dir"
2019-05-07 21:22:47 +00:00
},
"flake:flake2": {
"url": "git+file://$flake2Dir"
2019-05-07 21:22:47 +00:00
},
"flake:flake3": {
"url": "git+file://$flake3Dir"
2019-05-07 21:22:47 +00:00
},
"flake:flake4": {
"url": "flake:flake3"
2019-06-11 11:09:06 +00:00
},
2020-01-27 12:45:49 +00:00
"flake:flake5": {
"url": "hg+file://$flake5Dir"
},
"flake:nixpkgs": {
"url": "flake:flake1"
2019-05-07 21:22:47 +00:00
}
},
"version": 1
}
EOF
# Test 'nix flake list'.
[[ $(nix flake list | wc -l) == 6 ]]
2019-05-07 21:22:47 +00:00
# Test 'nix flake info'.
2020-01-28 15:34:37 +00:00
nix flake info flake1 | grep -q 'URL: .*flake1.*'
2019-05-16 21:14:27 +00:00
# Test 'nix flake info' on a local flake.
2020-01-28 15:34:37 +00:00
(cd $flake1Dir && nix flake info) | grep -q 'URL: .*flake1.*'
(cd $flake1Dir && nix flake info .) | grep -q 'URL: .*flake1.*'
nix flake info $flake1Dir | grep -q 'URL: .*flake1.*'
2019-05-07 21:22:47 +00:00
# Test 'nix flake info --json'.
2020-01-28 15:34:37 +00:00
json=$(nix flake info flake1 --json | jq .)
2019-05-07 21:22:47 +00:00
[[ $(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 info flake1 --json --refresh | jq -r .revision)
[[ $hash1 != $hash2 ]]
2019-05-07 21:22:47 +00:00
# Test 'nix build' on a flake.
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result flake1#foo
2019-05-07 21:22:47 +00:00
[[ -e $TEST_ROOT/result/hello ]]
# Test defaultPackage.
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result flake1
2019-05-07 21:22:47 +00:00
[[ -e $TEST_ROOT/result/hello ]]
2020-01-28 15:34:37 +00:00
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.
2020-01-28 15:34:37 +00:00
nix build -o $flake1Dir/result git+file://$flake1Dir
nix path-info $flake1Dir/result
2019-05-07 21:22:47 +00:00
# Building a flake with an unlocked dependency should fail in pure mode.
2020-01-28 15:34:37 +00:00
(! nix build -o $TEST_ROOT/result flake2#bar --no-registries)
2020-01-27 12:45:49 +00:00
(! nix eval --expr "builtins.getFlake \"$flake2Dir\"")
2019-05-07 21:22:47 +00:00
# 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
2019-05-07 21:22:47 +00:00
# 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'
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result $flake2Dir#bar
2019-05-01 09:38:48 +00:00
[[ -e $flake2Dir/flake.lock ]]
git -C $flake2Dir add flake.lock
2019-05-01 09:38:48 +00:00
git -C $flake2Dir commit flake.lock -m 'Add flake.lock'
2019-05-07 21:22:47 +00:00
2019-05-09 11:55:33 +00:00
# Rerunning the build should not change the lockfile.
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result $flake2Dir#bar
[[ -z $(git -C $flake2Dir diff master) ]]
2019-05-09 11:55:33 +00:00
# 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 --tarball-ttl 0
2020-01-27 12:45:49 +00:00
nix build -o $TEST_ROOT/result --no-registries $flake2Dir#bar --tarball-ttl 0
2019-06-19 12:48:40 +00:00
# Updating the flake should not change the lockfile.
2020-01-28 15:34:37 +00:00
nix flake update $flake2Dir
2019-06-19 12:48:40 +00:00
[[ -z $(git -C $flake2Dir diff master) ]]
2019-05-07 21:22:47 +00:00
# Now we should be able to build the flake in pure mode.
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result flake2#bar
2019-05-07 21:22:47 +00:00
# Or without a registry.
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result --no-registries git+file://$flake2Dir#bar --tarball-ttl 0
# Test whether indirect dependencies work.
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result $flake3Dir#xyzzy
git -C $flake3Dir add flake.lock
2019-05-22 12:31:40 +00:00
# Add dependency to flake3.
rm $flake3Dir/flake.nix
cat > $flake3Dir/flake.nix <<EOF
{
2019-08-30 11:11:33 +00:00
edition = 201909;
description = "Fnord";
2019-08-30 11:11:33 +00:00
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
2020-01-28 15:34:37 +00:00
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) ]])
2019-05-22 12:31:40 +00:00
2019-07-12 12:37:45 +00:00
git -C $flake3Dir add flake.lock
git -C $flake3Dir commit -m 'Add lockfile'
2019-07-12 12:37:45 +00:00
# Unsupported editions should be an error.
2019-08-30 11:11:33 +00:00
sed -i $flake3Dir/flake.nix -e s/201909/201912/
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result $flake3Dir#sth 2>&1 | grep 'unsupported edition'
2019-05-22 21:52:29 +00:00
# Test whether registry caching works.
nix flake list --flake-registry file://$registry | grep -q flake3
mv $registry $registry.tmp
nix flake list --flake-registry file://$registry --tarball-ttl 0 | grep -q flake3
mv $registry.tmp $registry
# Test whether flakes are registered as GC roots for offline use.
2019-06-04 17:45:16 +00:00
# FIXME: use tarballs rather than git.
rm -rf $TEST_HOME/.cache
2020-01-28 15:34:37 +00:00
_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
2020-01-28 15:34:37 +00:00
_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 --tarball-ttl 0
mv $flake1Dir.tmp $flake1Dir
mv $flake2Dir.tmp $flake2Dir
# Add nonFlakeInputs to flake3.
rm $flake3Dir/flake.nix
cat > $flake3Dir/flake.nix <<EOF
{
2019-08-30 11:11:33 +00:00
edition = 201909;
inputs = {
flake1 = {};
flake2 = {};
nonFlake = {
url = git+file://$nonFlakeDir;
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";
buildCommand = ''
cat \${inputs.nonFlake}/README.md > \$out
'';
};
};
}
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.
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result $flake3Dir#sth
2019-07-12 12:37:45 +00:00
git -C $flake3Dir add flake.lock
2019-06-04 18:33:49 +00:00
git -C $flake3Dir commit -m 'Update nonFlakeInputs'
2020-01-28 15:34:37 +00:00
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
2020-01-28 15:34:37 +00:00
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
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result flake3#xyzzy flake3#fnord
2019-06-11 11:09:06 +00:00
# Test doing multiple `lookupFlake`s
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result flake4#xyzzy
2019-06-11 11:09:06 +00:00
2020-01-22 19:00:58 +00:00
# Test 'nix flake update' and --override-flake.
2020-01-28 15:34:37 +00:00
nix flake update $flake3Dir
2020-01-22 19:00:58 +00:00
[[ -z $(git -C $flake3Dir diff master) ]]
2020-01-28 15:34:37 +00:00
nix flake update $flake3Dir --recreate-lock-file --override-flake flake2 nixpkgs
2020-01-22 19:00:58 +00:00
[[ ! -z $(git -C $flake3Dir diff master) ]]
2019-06-11 11:09:06 +00:00
# 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
{
2019-08-30 11:11:33 +00:00
edition = 201909;
2019-06-11 11:09:06 +00:00
inputs = {
nonFlake = {
2019-10-08 14:30:04 +00:00
url = "$nonFlakeDir";
flake = false;
};
2019-06-11 11:09:06 +00:00
};
description = "Fnord";
outputs = { self, flake1, flake2, nonFlake }: rec {
packages.$system.sth = flake1.packages.$system.foo;
packages.$system.fnord =
2019-06-11 11:09:06 +00:00
with import ./config.nix;
mkDerivation {
inherit system;
name = "fnord";
buildCommand = ''
cat \${nonFlake}/README.md > \$out
2019-06-11 11:09:06 +00:00
'';
};
};
}
EOF
git -C $flake3Dir add flake.nix
git -C $flake3Dir commit -m 'Remove packages.xyzzy'
git -C $flake3Dir checkout master
# Test whether fuzzy-matching works for IsAlias
2020-01-28 15:34:37 +00:00
(! nix build -o $TEST_ROOT/result flake4/removeXyzzy#xyzzy)
2019-06-11 11:09:06 +00:00
# Test whether fuzzy-matching works for IsGit
2020-01-28 15:34:37 +00:00
(! nix build -o $TEST_ROOT/result flake4/removeXyzzy#xyzzy)
nix build -o $TEST_ROOT/result flake4/removeXyzzy#sth
2019-06-19 12:48:40 +00:00
# Testing the nix CLI
2020-01-28 15:34:37 +00:00
nix flake add flake1 flake3
[[ $(nix flake list | wc -l) == 7 ]]
2020-01-28 15:34:37 +00:00
nix flake pin flake1
[[ $(nix flake list | wc -l) == 7 ]]
2020-01-28 15:34:37 +00:00
nix flake remove flake1
[[ $(nix flake list | wc -l) == 6 ]]
2019-06-19 12:48:40 +00:00
2019-10-15 17:53:29 +00:00
# Test 'nix flake init'.
2019-06-19 12:48:40 +00:00
(cd $flake7Dir && nix flake init)
2019-10-15 17:53:29 +00:00
git -C $flake7Dir add flake.nix
2020-01-28 15:34:37 +00:00
nix flake check $flake7Dir
Respect lock files of inputs + fine-grained lock file control When computing a lock file, we now respect the lock files of flake inputs. This is important for usability / reproducibility. For example, the 'nixops' flake depends on the 'nixops-aws' and 'nixops-hetzner' repositories. So when the 'nixops' flake is used in another flake, we want the versions of 'nixops-aws' and 'nixops-hetzner' locked by the the 'nixops' flake because those presumably have been tested. This can lead to a proliferation of versions of flakes like 'nixpkgs' (since every flake's lock file could depend on a different version of 'nixpkgs'). This is not a major issue when using Nixpkgs overlays or NixOS modules, since then the top-level flake composes those overlays/modules into *its* version of Nixpkgs and all other versions are ignored. Lock file computation has been made a bit more lazy so it won't try to fetch all those versions of 'nixpkgs'. However, in case it's necessary to minimize flake versions, there now are two input attributes that allow this. First, you can copy an input from another flake, as follows: inputs.nixpkgs.follows = "dwarffs/nixpkgs"; This states that the calling flake's 'nixpkgs' input shall be the same as the 'nixpkgs' input of the 'dwarffs' input. Second, you can override inputs of inputs: inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; or equivalently, using 'follows': inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.follows = "nixpkgs"; This states that the 'nixpkgs' input of the 'nixops' input shall be the same as the calling flake's 'nixpkgs' input. Finally, at '-v' Nix now prints the changes to the lock file, e.g. $ nix flake update ~/Misc/eelco-configurations/hagbard inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed: updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd' removed 'nixops' removed 'nixops/nixops-aws' removed 'nixops/nixops-hetzner' removed 'nixops/nixpkgs'
2020-01-24 21:05:11 +00:00
git -C $flake7Dir commit -m 'Initial'
2019-06-19 12:48:40 +00:00
Respect lock files of inputs + fine-grained lock file control When computing a lock file, we now respect the lock files of flake inputs. This is important for usability / reproducibility. For example, the 'nixops' flake depends on the 'nixops-aws' and 'nixops-hetzner' repositories. So when the 'nixops' flake is used in another flake, we want the versions of 'nixops-aws' and 'nixops-hetzner' locked by the the 'nixops' flake because those presumably have been tested. This can lead to a proliferation of versions of flakes like 'nixpkgs' (since every flake's lock file could depend on a different version of 'nixpkgs'). This is not a major issue when using Nixpkgs overlays or NixOS modules, since then the top-level flake composes those overlays/modules into *its* version of Nixpkgs and all other versions are ignored. Lock file computation has been made a bit more lazy so it won't try to fetch all those versions of 'nixpkgs'. However, in case it's necessary to minimize flake versions, there now are two input attributes that allow this. First, you can copy an input from another flake, as follows: inputs.nixpkgs.follows = "dwarffs/nixpkgs"; This states that the calling flake's 'nixpkgs' input shall be the same as the 'nixpkgs' input of the 'dwarffs' input. Second, you can override inputs of inputs: inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; or equivalently, using 'follows': inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.follows = "nixpkgs"; This states that the 'nixpkgs' input of the 'nixops' input shall be the same as the calling flake's 'nixpkgs' input. Finally, at '-v' Nix now prints the changes to the lock file, e.g. $ nix flake update ~/Misc/eelco-configurations/hagbard inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed: updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd' removed 'nixops' removed 'nixops/nixops-aws' removed 'nixops/nixops-hetzner' removed 'nixops/nixpkgs'
2020-01-24 21:05:11 +00:00
# Test 'nix flake clone'.
2019-08-30 11:11:33 +00:00
rm -rf $TEST_ROOT/flake1-v2
2020-01-28 15:34:37 +00:00
nix flake clone flake1 --dest $TEST_ROOT/flake1-v2
[ -e $TEST_ROOT/flake1-v2/flake.nix ]
2019-09-10 14:03:03 +00:00
# More 'nix flake check' tests.
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
outputs = { flake1, self }: {
overlay = final: prev: {
};
};
}
EOF
2020-01-28 15:34:37 +00:00
nix flake check $flake3Dir
2019-09-10 14:03:03 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
outputs = { flake1, self }: {
overlay = finalll: prev: {
};
};
}
EOF
2020-01-28 15:34:37 +00:00
(! nix flake check $flake3Dir)
2019-09-10 14:03:03 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
outputs = { flake1, self }: {
nixosModules.foo = {
a.b.c = 123;
foo = true;
};
};
}
EOF
2020-01-28 15:34:37 +00:00
nix flake check $flake3Dir
2019-09-10 14:03:03 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
outputs = { flake1, self }: {
nixosModules.foo = {
a.b.c = 123;
foo = assert false; true;
};
};
}
EOF
2020-01-28 15:34:37 +00:00
(! nix flake check $flake3Dir)
2019-09-10 14:03:03 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
outputs = { flake1, self }: {
nixosModule = { config, pkgs, ... }: {
a.b.c = 123;
};
};
}
EOF
2020-01-28 15:34:37 +00:00
nix flake check $flake3Dir
2019-09-10 14:03:03 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
outputs = { flake1, self }: {
nixosModule = { config, pkgs }: {
a.b.c = 123;
};
};
}
EOF
2020-01-28 15:34:37 +00:00
(! nix flake check $flake3Dir)
Respect lock files of inputs + fine-grained lock file control When computing a lock file, we now respect the lock files of flake inputs. This is important for usability / reproducibility. For example, the 'nixops' flake depends on the 'nixops-aws' and 'nixops-hetzner' repositories. So when the 'nixops' flake is used in another flake, we want the versions of 'nixops-aws' and 'nixops-hetzner' locked by the the 'nixops' flake because those presumably have been tested. This can lead to a proliferation of versions of flakes like 'nixpkgs' (since every flake's lock file could depend on a different version of 'nixpkgs'). This is not a major issue when using Nixpkgs overlays or NixOS modules, since then the top-level flake composes those overlays/modules into *its* version of Nixpkgs and all other versions are ignored. Lock file computation has been made a bit more lazy so it won't try to fetch all those versions of 'nixpkgs'. However, in case it's necessary to minimize flake versions, there now are two input attributes that allow this. First, you can copy an input from another flake, as follows: inputs.nixpkgs.follows = "dwarffs/nixpkgs"; This states that the calling flake's 'nixpkgs' input shall be the same as the 'nixpkgs' input of the 'dwarffs' input. Second, you can override inputs of inputs: inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; or equivalently, using 'follows': inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.follows = "nixpkgs"; This states that the 'nixpkgs' input of the 'nixops' input shall be the same as the calling flake's 'nixpkgs' input. Finally, at '-v' Nix now prints the changes to the lock file, e.g. $ nix flake update ~/Misc/eelco-configurations/hagbard inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed: updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd' removed 'nixops' removed 'nixops/nixops-aws' removed 'nixops/nixops-hetzner' removed 'nixops/nixpkgs'
2020-01-24 21:05:11 +00:00
# Test 'follows' inputs.
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
inputs.foo = {
type = "indirect";
id = "flake1";
};
Respect lock files of inputs + fine-grained lock file control When computing a lock file, we now respect the lock files of flake inputs. This is important for usability / reproducibility. For example, the 'nixops' flake depends on the 'nixops-aws' and 'nixops-hetzner' repositories. So when the 'nixops' flake is used in another flake, we want the versions of 'nixops-aws' and 'nixops-hetzner' locked by the the 'nixops' flake because those presumably have been tested. This can lead to a proliferation of versions of flakes like 'nixpkgs' (since every flake's lock file could depend on a different version of 'nixpkgs'). This is not a major issue when using Nixpkgs overlays or NixOS modules, since then the top-level flake composes those overlays/modules into *its* version of Nixpkgs and all other versions are ignored. Lock file computation has been made a bit more lazy so it won't try to fetch all those versions of 'nixpkgs'. However, in case it's necessary to minimize flake versions, there now are two input attributes that allow this. First, you can copy an input from another flake, as follows: inputs.nixpkgs.follows = "dwarffs/nixpkgs"; This states that the calling flake's 'nixpkgs' input shall be the same as the 'nixpkgs' input of the 'dwarffs' input. Second, you can override inputs of inputs: inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; or equivalently, using 'follows': inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.follows = "nixpkgs"; This states that the 'nixpkgs' input of the 'nixops' input shall be the same as the calling flake's 'nixpkgs' input. Finally, at '-v' Nix now prints the changes to the lock file, e.g. $ nix flake update ~/Misc/eelco-configurations/hagbard inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed: updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd' removed 'nixops' removed 'nixops/nixops-aws' removed 'nixops/nixops-hetzner' removed 'nixops/nixpkgs'
2020-01-24 21:05:11 +00:00
inputs.bar.follows = "foo";
outputs = { self, foo, bar }: {
};
}
EOF
2020-01-28 15:34:37 +00:00
nix flake update $flake3Dir
2020-02-01 23:05:53 +00:00
[[ $(jq .inputs.foo.locked $flake3Dir/flake.lock) = $(jq .inputs.bar.locked $flake3Dir/flake.lock) ]]
Respect lock files of inputs + fine-grained lock file control When computing a lock file, we now respect the lock files of flake inputs. This is important for usability / reproducibility. For example, the 'nixops' flake depends on the 'nixops-aws' and 'nixops-hetzner' repositories. So when the 'nixops' flake is used in another flake, we want the versions of 'nixops-aws' and 'nixops-hetzner' locked by the the 'nixops' flake because those presumably have been tested. This can lead to a proliferation of versions of flakes like 'nixpkgs' (since every flake's lock file could depend on a different version of 'nixpkgs'). This is not a major issue when using Nixpkgs overlays or NixOS modules, since then the top-level flake composes those overlays/modules into *its* version of Nixpkgs and all other versions are ignored. Lock file computation has been made a bit more lazy so it won't try to fetch all those versions of 'nixpkgs'. However, in case it's necessary to minimize flake versions, there now are two input attributes that allow this. First, you can copy an input from another flake, as follows: inputs.nixpkgs.follows = "dwarffs/nixpkgs"; This states that the calling flake's 'nixpkgs' input shall be the same as the 'nixpkgs' input of the 'dwarffs' input. Second, you can override inputs of inputs: inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; or equivalently, using 'follows': inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.follows = "nixpkgs"; This states that the 'nixpkgs' input of the 'nixops' input shall be the same as the calling flake's 'nixpkgs' input. Finally, at '-v' Nix now prints the changes to the lock file, e.g. $ nix flake update ~/Misc/eelco-configurations/hagbard inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed: updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd' removed 'nixops' removed 'nixops/nixops-aws' removed 'nixops/nixops-hetzner' removed 'nixops/nixpkgs'
2020-01-24 21:05:11 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
inputs.bar.follows = "flake2/flake1";
outputs = { self, flake2, bar }: {
};
}
EOF
2020-01-28 15:34:37 +00:00
nix flake update $flake3Dir
2020-02-01 23:05:53 +00:00
[[ $(jq .inputs.bar.locked.url $flake3Dir/flake.lock) =~ flake1 ]]
Respect lock files of inputs + fine-grained lock file control When computing a lock file, we now respect the lock files of flake inputs. This is important for usability / reproducibility. For example, the 'nixops' flake depends on the 'nixops-aws' and 'nixops-hetzner' repositories. So when the 'nixops' flake is used in another flake, we want the versions of 'nixops-aws' and 'nixops-hetzner' locked by the the 'nixops' flake because those presumably have been tested. This can lead to a proliferation of versions of flakes like 'nixpkgs' (since every flake's lock file could depend on a different version of 'nixpkgs'). This is not a major issue when using Nixpkgs overlays or NixOS modules, since then the top-level flake composes those overlays/modules into *its* version of Nixpkgs and all other versions are ignored. Lock file computation has been made a bit more lazy so it won't try to fetch all those versions of 'nixpkgs'. However, in case it's necessary to minimize flake versions, there now are two input attributes that allow this. First, you can copy an input from another flake, as follows: inputs.nixpkgs.follows = "dwarffs/nixpkgs"; This states that the calling flake's 'nixpkgs' input shall be the same as the 'nixpkgs' input of the 'dwarffs' input. Second, you can override inputs of inputs: inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; or equivalently, using 'follows': inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.follows = "nixpkgs"; This states that the 'nixpkgs' input of the 'nixops' input shall be the same as the calling flake's 'nixpkgs' input. Finally, at '-v' Nix now prints the changes to the lock file, e.g. $ nix flake update ~/Misc/eelco-configurations/hagbard inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed: updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd' removed 'nixops' removed 'nixops/nixops-aws' removed 'nixops/nixops-hetzner' removed 'nixops/nixpkgs'
2020-01-24 21:05:11 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
inputs.bar.follows = "flake2";
outputs = { self, flake2, bar }: {
};
}
EOF
2020-01-28 15:34:37 +00:00
nix flake update $flake3Dir
2020-02-01 23:05:53 +00:00
[[ $(jq .inputs.bar.locked.url $flake3Dir/flake.lock) =~ flake2 ]]
Respect lock files of inputs + fine-grained lock file control When computing a lock file, we now respect the lock files of flake inputs. This is important for usability / reproducibility. For example, the 'nixops' flake depends on the 'nixops-aws' and 'nixops-hetzner' repositories. So when the 'nixops' flake is used in another flake, we want the versions of 'nixops-aws' and 'nixops-hetzner' locked by the the 'nixops' flake because those presumably have been tested. This can lead to a proliferation of versions of flakes like 'nixpkgs' (since every flake's lock file could depend on a different version of 'nixpkgs'). This is not a major issue when using Nixpkgs overlays or NixOS modules, since then the top-level flake composes those overlays/modules into *its* version of Nixpkgs and all other versions are ignored. Lock file computation has been made a bit more lazy so it won't try to fetch all those versions of 'nixpkgs'. However, in case it's necessary to minimize flake versions, there now are two input attributes that allow this. First, you can copy an input from another flake, as follows: inputs.nixpkgs.follows = "dwarffs/nixpkgs"; This states that the calling flake's 'nixpkgs' input shall be the same as the 'nixpkgs' input of the 'dwarffs' input. Second, you can override inputs of inputs: inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; or equivalently, using 'follows': inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.follows = "nixpkgs"; This states that the 'nixpkgs' input of the 'nixops' input shall be the same as the calling flake's 'nixpkgs' input. Finally, at '-v' Nix now prints the changes to the lock file, e.g. $ nix flake update ~/Misc/eelco-configurations/hagbard inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed: updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd' removed 'nixops' removed 'nixops/nixops-aws' removed 'nixops/nixops-hetzner' removed 'nixops/nixpkgs'
2020-01-24 21:05:11 +00:00
# Test overriding inputs of inputs.
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
inputs.flake2.inputs.flake1.url = git+file://$flake7Dir;
outputs = { self, flake2 }: {
};
}
EOF
2020-01-28 15:34:37 +00:00
nix flake update $flake3Dir
2020-02-01 23:05:53 +00:00
[[ $(jq .inputs.flake2.inputs.flake1.locked.url $flake3Dir/flake.lock) =~ flake7 ]]
Respect lock files of inputs + fine-grained lock file control When computing a lock file, we now respect the lock files of flake inputs. This is important for usability / reproducibility. For example, the 'nixops' flake depends on the 'nixops-aws' and 'nixops-hetzner' repositories. So when the 'nixops' flake is used in another flake, we want the versions of 'nixops-aws' and 'nixops-hetzner' locked by the the 'nixops' flake because those presumably have been tested. This can lead to a proliferation of versions of flakes like 'nixpkgs' (since every flake's lock file could depend on a different version of 'nixpkgs'). This is not a major issue when using Nixpkgs overlays or NixOS modules, since then the top-level flake composes those overlays/modules into *its* version of Nixpkgs and all other versions are ignored. Lock file computation has been made a bit more lazy so it won't try to fetch all those versions of 'nixpkgs'. However, in case it's necessary to minimize flake versions, there now are two input attributes that allow this. First, you can copy an input from another flake, as follows: inputs.nixpkgs.follows = "dwarffs/nixpkgs"; This states that the calling flake's 'nixpkgs' input shall be the same as the 'nixpkgs' input of the 'dwarffs' input. Second, you can override inputs of inputs: inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; or equivalently, using 'follows': inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>; inputs.nixops.inputs.nixpkgs.follows = "nixpkgs"; This states that the 'nixpkgs' input of the 'nixops' input shall be the same as the calling flake's 'nixpkgs' input. Finally, at '-v' Nix now prints the changes to the lock file, e.g. $ nix flake update ~/Misc/eelco-configurations/hagbard inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed: updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd' removed 'nixops' removed 'nixops/nixops-aws' removed 'nixops/nixops-hetzner' removed 'nixops/nixpkgs'
2020-01-24 21:05:11 +00:00
cat > $flake3Dir/flake.nix <<EOF
{
edition = 201909;
inputs.flake2.inputs.flake1.follows = "foo";
inputs.foo.url = git+file://$flake7Dir;
outputs = { self, flake2 }: {
};
}
EOF
2020-01-28 15:34:37 +00:00
nix flake update $flake3Dir --recreate-lock-file
2020-02-01 23:05:53 +00:00
[[ $(jq .inputs.flake2.inputs.flake1.locked.url $flake3Dir/flake.lock) =~ flake7 ]]
2020-01-27 12:45:49 +00:00
# Test Mercurial flakes.
if [[ -z $(type -p hg) ]]; then
echo "Git not installed; skipping Mercurial flake tests"
exit 99
fi
rm -rf $flake5Dir
hg init $flake5Dir
cat > $flake5Dir/flake.nix <<EOF
{
edition = 201909;
outputs = { self, flake1 }: {
defaultPackage.$system = flake1.defaultPackage.$system;
expr = assert builtins.pathExists ./flake.lock; 123;
};
}
EOF
hg add $flake5Dir/flake.nix
hg commit --config ui.username=foobar@example.org $flake5Dir -m 'Initial commit'
2020-01-28 15:34:37 +00:00
nix build -o $TEST_ROOT/result hg+file://$flake5Dir
2020-01-27 12:45:49 +00:00
[[ -e $TEST_ROOT/result/hello ]]
2020-01-28 15:34:37 +00:00
nix flake info --json hg+file://$flake5Dir | jq -e -r .revision
2020-01-27 12:45:49 +00:00
# This will fail because flake.lock is not tracked by Mercurial.
2020-01-28 15:34:37 +00:00
(! nix eval hg+file://$flake5Dir#expr)
2020-01-27 12:45:49 +00:00
hg add $flake5Dir/flake.lock
2020-01-28 15:34:37 +00:00
nix eval hg+file://$flake5Dir#expr
2020-01-27 12:45:49 +00:00
2020-01-28 15:34:37 +00:00
(! nix eval hg+file://$flake5Dir#expr --no-allow-dirty)
2020-01-27 12:45:49 +00:00
2020-01-28 15:34:37 +00:00
(! nix flake info --json hg+file://$flake5Dir | jq -e -r .revision)
2020-01-27 12:45:49 +00:00
hg commit --config ui.username=foobar@example.org $flake5Dir -m 'Add lock file'
2020-01-28 15:34:37 +00:00
nix flake info --json hg+file://$flake5Dir --refresh | jq -e -r .revision
nix flake info --json hg+file://$flake5Dir
[[ $(nix flake info --json hg+file://$flake5Dir | jq -e -r .revCount) = 1 ]]
2020-01-27 12:45:49 +00:00
nix build -o $TEST_ROOT/result hg+file://$flake5Dir --no-registries --no-allow-dirty
# Test tarball flakes
2020-02-01 11:26:05 +00:00
tar cfz $TEST_ROOT/flake.tar.gz -C $TEST_ROOT --exclude .hg 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 info --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 update $flake3Dir --override-input flake2/flake1 flake5
2020-02-01 23:05:53 +00:00
[[ $(jq .inputs.flake2.inputs.flake1.locked.url $flake3Dir/flake.lock) =~ flake5 ]]
nix flake update $flake3Dir --override-input flake2/flake1 flake1
2020-02-01 23:05:53 +00:00
[[ $(jq -r .inputs.flake2.inputs.flake1.locked.rev $flake3Dir/flake.lock) =~ $hash2 ]]
nix flake update $flake3Dir --override-input flake2/flake1 flake1/master/$hash1
2020-02-01 23:05:53 +00:00
[[ $(jq -r .inputs.flake2.inputs.flake1.locked.rev $flake3Dir/flake.lock) =~ $hash1 ]]
# Test --update-input.
nix flake update $flake3Dir
2020-02-01 23:05:53 +00:00
[[ $(jq -r .inputs.flake2.inputs.flake1.locked.rev $flake3Dir/flake.lock) = $hash1 ]]
nix flake update $flake3Dir --update-input flake2/flake1
2020-02-01 23:05:53 +00:00
[[ $(jq -r .inputs.flake2.inputs.flake1.locked.rev $flake3Dir/flake.lock) =~ $hash2 ]]
# Test 'nix flake list-inputs'.
[[ $(nix flake list-inputs $flake3Dir | wc -l) == 5 ]]
nix flake list-inputs $flake3Dir --json | jq .